oxutils 0.1.2__py3-none-any.whl → 0.1.6__py3-none-any.whl

oxutils/oxiliere/management/commands/init_oxiliere_system.py

@@ -0,0 +1,86 @@
+import uuid
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from django.db import transaction
+from django.contrib.auth import get_user_model
+from django_tenants.utils import get_tenant_model
+from oxutils.oxiliere.models import Domain, TenantUser
+from oxutils.oxiliere.utils import oxid_to_schema_name
+
+
+
+class Command(BaseCommand):
+    help = 'Initialise le tenant système Oxiliere'
+
+    @transaction.atomic
+    def handle(self, *args, **options):
+        TenantModel = get_tenant_model()
+        UserModel = get_user_model()
+        
+        # Configuration du tenant système depuis settings
+        system_slug = getattr(settings, 'OXI_SYSTEM_TENANT', 'tenant_oxisystem')
+        schema_name = oxid_to_schema_name(system_slug)
+        system_domain = getattr(settings, 'OXI_SYSTEM_DOMAIN', 'system.oxiliere.com')
+        owner_email = getattr(settings, 'OXI_SYSTEM_OWNER_EMAIL', 'dev@oxiliere.com')
+        owner_oxi_id = uuid.uuid4()
+        
+        self.stdout.write(self.style.WARNING(f'Initialisation du tenant système...'))
+        
+        # Vérifier si le tenant système existe déjà
+        if TenantModel.objects.filter(schema_name=schema_name).exists():
+            self.stdout.write(self.style.ERROR(f'Le tenant système "{schema_name}" existe déjà!'))
+            return
+        
+        # Créer le tenant système
+        self.stdout.write(f'Création du tenant système: {schema_name}')
+        tenant = TenantModel.objects.create(
+            name='Oxiliere System',
+            schema_name=schema_name,
+            oxi_id=system_slug,
+            subscription_plan='system',
+            subscription_status='active',
+        )
+        self.stdout.write(self.style.SUCCESS(f'✓ Tenant système créé: {tenant.name} ({tenant.schema_name})'))
+        
+        # Créer le domaine pour le tenant système
+        self.stdout.write(f'Création du domaine: {system_domain}')
+        domain = Domain.objects.create(
+            domain=system_domain,
+            tenant=tenant,
+            is_primary=True
+        )
+        self.stdout.write(self.style.SUCCESS(f'✓ Domaine créé: {domain.domain}'))
+        
+        self.stdout.write(f'Création du superuser: {owner_email}')
+        try:
+            superuser = UserModel.objects.get(email=owner_email)
+            self.stdout.write(self.style.WARNING(f'⚠ Superuser existe déjà: {superuser.email}'))
+        except UserModel.DoesNotExist:
+            superuser = UserModel.objects.create_superuser(
+                email=owner_email,
+                oxi_id=owner_oxi_id,
+                first_name='System',
+                last_name='Admin'
+            )
+            self.stdout.write(self.style.SUCCESS(f'✓ Superuser créé: {superuser.email}'))
+        
+        # Lier le superuser au tenant système
+        self.stdout.write('Liaison du superuser au tenant système')
+        tenant_user, created = TenantUser.objects.get_or_create(
+            tenant=tenant,
+            user=superuser,
+            defaults={
+                'is_owner': True,
+                'is_admin': True,
+            }
+        )
+        if created:
+            self.stdout.write(self.style.SUCCESS(f'✓ Superuser lié au tenant système'))
+        else:
+            self.stdout.write(self.style.WARNING(f'⚠ Liaison existe déjà'))
+        
+        self.stdout.write(self.style.SUCCESS('\n=== Initialisation terminée avec succès ==='))
+        self.stdout.write(f'Tenant: {tenant.name}')
+        self.stdout.write(f'Schema: {tenant.schema_name}')
+        self.stdout.write(f'Domain: {domain.domain}')
+        self.stdout.write(f'Superuser: {owner_email}')

oxutils/oxiliere/middleware.py

@@ -0,0 +1,97 @@
+from django.conf import settings
+from django.db import connection
+from django.http import Http404
+from django.urls import set_urlconf
+from django.utils.module_loading import import_string
+from django.utils.deprecation import MiddlewareMixin
+
+from django_tenants.utils import (
+    get_public_schema_name,
+    get_public_schema_urlconf
+)
+from oxutils.constants import ORGANIZATION_HEADER_KEY
+
+class TenantMainMiddleware(MiddlewareMixin):
+    TENANT_NOT_FOUND_EXCEPTION = Http404
+    """
+    This middleware should be placed at the very top of the middleware stack.
+    Selects the proper database schema using the request host. Can fail in
+    various ways which is better than corrupting or revealing data.
+    """
+
+    @staticmethod
+    def get_org_id_from_request(request):
+        """ Extracts organization ID from request header X-Organization-ID.
+        """
+        custom = 'HTTP_' + ORGANIZATION_HEADER_KEY.upper().replace('-', '_')
+        return request.headers.get(ORGANIZATION_HEADER_KEY) or request.META.get(custom)
+
+    def get_tenant(self, tenant_model, oxi_id):
+        """ Get tenant by oxi_id instead of domain.
+        """
+        return tenant_model.objects.get(oxi_id=oxi_id)
+
+    def process_request(self, request):
+        # Connection needs first to be at the public schema, as this is where
+        # the tenant metadata is stored.
+
+        connection.set_schema_to_public()
+        
+        oxi_id = self.get_org_id_from_request(request)
+        if not oxi_id:
+            from django.http import HttpResponseBadRequest
+            return HttpResponseBadRequest('Missing X-Organization-ID header')
+
+        tenant_model = connection.tenant_model
+        try:
+            tenant = self.get_tenant(tenant_model, oxi_id)
+        except tenant_model.DoesNotExist:
+            default_tenant = self.no_tenant_found(request, oxi_id)
+            return default_tenant
+
+        request.tenant = tenant
+        connection.set_tenant(request.tenant)
+        self.setup_url_routing(request)
+
+    def no_tenant_found(self, request, oxi_id):
+        """ What should happen if no tenant is found.
+        This makes it easier if you want to override the default behavior """
+        if hasattr(settings, 'DEFAULT_NOT_FOUND_TENANT_VIEW'):
+            view_path = settings.DEFAULT_NOT_FOUND_TENANT_VIEW
+            view = import_string(view_path)
+            if hasattr(view, 'as_view'):
+                response = view.as_view()(request)
+            else:
+                response = view(request)
+            if hasattr(response, 'render'):
+                response.render()
+            return response
+        elif hasattr(settings, 'SHOW_PUBLIC_IF_NO_TENANT_FOUND') and settings.SHOW_PUBLIC_IF_NO_TENANT_FOUND:
+            self.setup_url_routing(request=request, force_public=True)
+        else:
+            raise self.TENANT_NOT_FOUND_EXCEPTION('No tenant for X-Organization-ID "%s"' % oxi_id)
+
+    @staticmethod
+    def setup_url_routing(request, force_public=False):
+        """
+        Sets the correct url conf based on the tenant
+        :param request:
+        :param force_public
+        """
+        public_schema_name = get_public_schema_name()
+        if has_multi_type_tenants():
+            tenant_types = get_tenant_types()
+            if (not hasattr(request, 'tenant') or
+                    ((force_public or request.tenant.schema_name == get_public_schema_name()) and
+                     'URLCONF' in tenant_types[public_schema_name])):
+                request.urlconf = get_public_schema_urlconf()
+            else:
+                tenant_type = request.tenant.get_tenant_type()
+                request.urlconf = tenant_types[tenant_type]['URLCONF']
+            set_urlconf(request.urlconf)
+
+        else:
+            # Do we have a public-specific urlconf?
+            if (hasattr(settings, 'PUBLIC_SCHEMA_URLCONF') and
+                    (force_public or request.tenant.schema_name == get_public_schema_name())):
+                request.urlconf = settings.PUBLIC_SCHEMA_URLCONF

oxutils/oxiliere/models.py

@@ -0,0 +1,55 @@
+from django.db import models
+from django.conf import settings
+from django_tenants.models import TenantMixin, DomainMixin
+from oxutils.models import (
+    TimestampMixin,
+    BaseModelMixin,
+)
+from oxutils.oxiliere.enums import TenantStatus
+
+
+
+
+class Tenant(TenantMixin, TimestampMixin):
+    name = models.CharField(max_length=100)
+    oxi_id = models.UUIDField(unique=True)
+    subscription_plan = models.CharField(max_length=255, null=True, blank=True)
+    subscription_status = models.CharField(max_length=255, null=True, blank=True)
+    subscription_end_date = models.DateTimeField(null=True, blank=True)
+    status = models.CharField(
+        max_length=20,
+        choices=TenantStatus.choices,
+        default=TenantStatus.ACTIVE
+    )
+
+    # default true, schema will be automatically created and synced when it is saved
+    auto_create_schema = True
+
+
+class Domain(DomainMixin):
+    pass
+
+
+
+class TenantUser(BaseModelMixin):
+    tenant = models.ForeignKey(
+        settings.TENANT_MODEL, on_delete=models.CASCADE
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE
+    )
+    is_owner = models.BooleanField(default=False)
+    is_admin = models.BooleanField(default=False)
+    status = models.CharField(
+        max_length=20,
+        choices=TenantStatus.choices,
+        default=TenantStatus.ACTIVE
+    )
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=['tenant', 'user'],
+                name='unique_tenant_user'
+            )
+        ]

oxutils/oxiliere/permissions.py

@@ -0,0 +1,104 @@
+from ninja.permissions import BasePermission
+from django.conf import settings
+from oxutils.oxiliere.models import TenantUser
+
+
+class TenantPermission(BasePermission):
+    """
+    Vérifie que l'utilisateur a accès au tenant actuel.
+    L'utilisateur doit être authentifié et avoir un lien avec le tenant.
+    """
+    def has_permission(self, request, view):
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        if not hasattr(request, 'tenant'):
+            return False
+        
+        # Vérifier que l'utilisateur a accès à ce tenant
+        return TenantUser.objects.filter(
+            tenant=request.tenant,
+            user=request.user
+        ).exists()
+
+
+class TenantOwnerPermission(BasePermission):
+    """
+    Vérifie que l'utilisateur est propriétaire (owner) du tenant actuel.
+    """
+    def has_permission(self, request, view):
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        if not hasattr(request, 'tenant'):
+            return False
+        
+        # Vérifier que l'utilisateur est owner du tenant
+        return TenantUser.objects.filter(
+            tenant=request.tenant,
+            user=request.user,
+            is_owner=True
+        ).exists()
+
+
+class TenantAdminPermission(BasePermission):
+    """
+    Vérifie que l'utilisateur est admin ou owner du tenant actuel.
+    """
+    def has_permission(self, request, view):
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        if not hasattr(request, 'tenant'):
+            return False
+        
+        # Vérifier que l'utilisateur est admin ou owner du tenant
+        return TenantUser.objects.filter(
+            tenant=request.tenant,
+            user=request.user,
+            is_admin=True
+        ).exists() or TenantUser.objects.filter(
+            tenant=request.tenant,
+            user=request.user,
+            is_owner=True
+        ).exists()
+
+
+class TenantUserPermission(BasePermission):
+    """
+    Vérifie que l'utilisateur est un membre du tenant actuel.
+    Alias de TenantPermission pour plus de clarté sémantique.
+    """
+    def has_permission(self, request, view):
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        if not hasattr(request, 'tenant'):
+            return False
+        
+        return TenantUser.objects.filter(
+            tenant=request.tenant,
+            user=request.user
+        ).exists()
+
+
+class OxiliereServicePermission(BasePermission):
+    """
+    Vérifie que la requête provient d'un service interne Oxiliere.
+    Utilise un token de service ou une clé API spéciale.
+    """
+    def has_permission(self, request, view):
+        # Vérifier le header de service
+        service_token = request.headers.get('X-Oxiliere-Service-Token')
+        
+        if not service_token:
+            return False
+        
+        # Comparer avec le token configuré dans settings
+        expected_token = getattr(settings, 'OXILIERE_SERVICE_TOKEN', None)
+        
+        if not expected_token:
+            return False
+        
+        return service_token == expected_token
+

oxutils/oxiliere/schemas.py

@@ -0,0 +1,65 @@
+from typing import Optional
+from ninja import Schema
+from django.db import transaction
+from django.contrib.auth import get_user_model
+from django_tenants.utils import get_tenant_model
+from oxutils.oxiliere.models import TenantUser
+from oxutils.oxiliere.utils import oxid_to_schema_name
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+class TenantSchema(Schema):
+    name: str
+    oxi_id: str
+    subscription_plan: Optional[str]
+    subscription_status: Optional[str]
+    subscription_end_date: Optional[str]
+    status: Optional[str]
+
+
+class TenantOwnerSchema(Schema):
+    oxi_id: str
+    email: str
+
+
+class CreateTenantSchema(Schema):
+    tenant: TenantSchema
+    owner: TenantOwnerSchema
+
+
+    @transaction.atomic
+    def create_tenant(self):
+        UserModel = get_user_model()
+        TenantModel = get_tenant_model()
+
+        if TenantModel.objects.filter(oxi_id=self.tenant.oxi_id).exists():
+            logger.info("tenant_exists", oxi_id=self.tenant.oxi_id)
+            raise ValueError("Tenant with oxi_id {} already exists".format(self.tenant.oxi_id))
+
+        user = UserModel.objects.get_or_create(
+            oxi_id=self.owner.oxi_id,
+            defaults={
+                'email': self.owner.email,
+            }
+        )
+        
+        tenant = TenantModel.objects.create(
+            name=self.tenant.name,
+            schema_name=oxid_to_schema_name(self.tenant.oxi_id),
+            oxi_id=self.tenant.oxi_id,
+            subscription_plan=self.tenant.subscription_plan,
+            subscription_status=self.tenant.subscription_status,
+            subscription_end_date=self.tenant.subscription_end_date,
+        )
+        
+        TenantUser.objects.create(
+            tenant=tenant,
+            user=user,
+            is_owner=True,
+            is_admin=True,
+        )
+
+        logger.info("tenant_created", oxi_id=self.tenant.oxi_id)
+        return tenant

oxutils/oxiliere/settings.py

@@ -0,0 +1,17 @@
+import os
+
+TENANT_LIMIT_SET_CALLS = True
+
+CACHEOPS_PREFIX = 'oxutils.oxiliere.cacheops.cacheops_prefix'
+
+
+REDIS_URLS = os.getenv("REDIS_URLS", "redis://127.0.0.1:6379").split(",")
+
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.redis.RedisCache",
+        "LOCATION": REDIS_URLS,
+        'KEY_FUNCTION': 'django_tenants.cache.make_key',
+        'REVERSE_KEY_FUNCTION': 'django_tenants.cache.reverse_key',
+    }
+}

oxutils/oxiliere/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

oxutils/oxiliere/utils.py

@@ -0,0 +1,76 @@
+# utils.py
+
+def oxid_to_schema_name(oxid: str) -> str:
+    """
+    Convertit un OXI-ID (slug) en nom de schéma PostgreSQL valide.
+    
+    Règles PostgreSQL pour les noms de schéma:
+    - Doit commencer par une lettre (a-z) ou underscore (_)
+    - Peut contenir uniquement des lettres, chiffres et underscores
+    - Maximum 63 caractères
+    - Sensible à la casse mais conventionnellement en minuscules
+    
+    Args:
+        oxid: Slug de l'organisation (ex: "my-company", "acme-corp")
+    
+    Returns:
+        Nom de schéma valide (format: tenant_mycompany, tenant_acmecorp)
+    """
+    if not oxid:
+        raise ValueError("oxi_id cannot be empty")
+    
+    # Nettoyer le slug: remplacer les tirets par underscores et convertir en minuscules
+    clean_id = str(oxid).replace('-', '_').lower()
+    
+    # Supprimer tous les caractères non-alphanumériques sauf underscore
+    import re
+    clean_id = re.sub(r'[^a-z0-9_]', '', clean_id)
+    
+    # Préfixer avec 'tenant_' pour s'assurer que ça commence par une lettre
+    # et pour éviter les conflits avec les schémas système de PostgreSQL
+    schema_name = f"tenant_{clean_id}"
+    
+    # Vérifier la longueur (PostgreSQL limite à 63 caractères)
+    if len(schema_name) > 63:
+        raise ValueError(f"Schema name too long: {len(schema_name)} characters (max 63)")
+    
+    return schema_name
+
+
+def update_tenant_user(oxi_org_id: str, oxi_user_id: str, data: dict):
+    if not data or isinstance(data, dict) == False: return
+    if not oxi_org_id or not oxi_user_id: return
+
+    from oxutils.oxiliere.caches import get_tenant_user
+
+    TENANT_USER_FIELDS = ['is_owner', 'is_admin', 'status', 'is_active']
+    tenant_user = get_tenant_user(oxi_org_id, oxi_user_id)
+    changes = False
+
+    for key, value in data.items():
+        if key in TENANT_USER_FIELDS:
+            setattr(tenant_user, key, value)
+            changes = True
+
+    if changes:
+        tenant_user.save()
+
+
+def update_tenant(oxi_id: str, data: dict):
+    if not data or isinstance(data, dict) == False: return
+    if not oxi_id: return
+
+    from oxutils.oxiliere.caches import get_tenant_by_oxi_id
+
+    TENANT_FIELDS = ['name', 'status', 'subscription_plan', 'subscription_status', 'subscription_end_date']
+
+    tenant = get_tenant_by_oxi_id(oxi_id)
+    changes = False
+
+    for key, value in data.items():
+        if key in TENANT_FIELDS:
+            setattr(tenant, key, value)
+            changes = True
+
+    if changes:
+        tenant.save()

oxutils/pdf/__init__.py

@@ -0,0 +1,10 @@
+from .views import WeasyTemplateResponse, WeasyTemplateResponseMixin, WeasyTemplateView
+from .printer import Printer
+
+
+__all__ = [
+    'WeasyTemplateResponse',
+    'WeasyTemplateResponseMixin',
+    'WeasyTemplateView',
+    'Printer',
+]

oxutils/pdf/printer.py

@@ -0,0 +1,81 @@
+import weasyprint
+from django.conf import settings
+from django.template.loader import render_to_string
+
+from oxutils.pdf.utils import django_url_fetcher
+
+
+class Printer:
+    template_name = None
+    pdf_stylesheets = []
+    pdf_options = {}
+
+    def __init__(self, template_name=None, context=None, stylesheets=None, options=None, base_url=None):
+        self.template_name = template_name or self.template_name
+        self.context = context or {}
+        self._stylesheets = stylesheets or self.pdf_stylesheets
+        self._options = options.copy() if options else self.pdf_options.copy()
+        self._base_url = base_url
+
+    def get_context_data(self, **kwargs):
+        context = self.context.copy()
+        context.update(kwargs)
+        return context
+
+    def get_pdf_filename(self):
+        return None
+
+    def get_base_url(self):
+        if self._base_url:
+            return self._base_url
+        return getattr(settings, 'WEASYPRINT_BASEURL', '/')
+
+    def get_url_fetcher(self):
+        return django_url_fetcher
+
+    def get_font_config(self):
+        return weasyprint.text.fonts.FontConfiguration()
+
+    def get_css(self, base_url, url_fetcher, font_config):
+        return [
+            weasyprint.CSS(
+                value,
+                base_url=base_url,
+                url_fetcher=url_fetcher,
+                font_config=font_config,
+            )
+            for value in self._stylesheets
+        ]
+
+    def render_html(self, **kwargs):
+        context = self.get_context_data(**kwargs)
+        return render_to_string(self.template_name, context)
+
+    def get_document(self, **kwargs):
+        base_url = self.get_base_url()
+        url_fetcher = self.get_url_fetcher()
+        font_config = self.get_font_config()
+
+        html_content = self.render_html(**kwargs)
+        html = weasyprint.HTML(
+            string=html_content,
+            base_url=base_url,
+            url_fetcher=url_fetcher,
+        )
+
+        self._options.setdefault(
+            'stylesheets',
+            self.get_css(base_url, url_fetcher, font_config),
+        )
+
+        return html.render(
+            font_config=font_config,
+            **self._options,
+        )
+
+    def write_pdf(self, output=None, **kwargs):
+        document = self.get_document(**kwargs)
+        return document.write_pdf(target=output, **self._options)
+
+    def write_object(self, file_obj, **kwargs):
+        return self.write_pdf(output=file_obj, **kwargs)