oxutils 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

oxutils/oxiliere/middleware.py

@@ -7,15 +7,21 @@ from django.utils.deprecation import MiddlewareMixin
 
 from django_tenants.utils import (
     get_public_schema_name,
-    get_public_schema_urlconf
+    get_public_schema_urlconf,
+    get_tenant_types,
+    has_multi_type_tenants,
 )
 from oxutils.settings import oxi_settings
 from oxutils.constants import (
     ORGANIZATION_HEADER_KEY,
     ORGANIZATION_TOKEN_COOKIE_KEY
 )
+from oxutils.oxiliere.utils import is_system_tenant
 from oxutils.jwt.models import TokenTenant
 from oxutils.jwt.tokens import OrganizationAccessToken
+from oxutils.oxiliere.context import set_current_tenant_schema_name
+
+
 
 
 class TenantMainMiddleware(MiddlewareMixin):
@@ -45,9 +51,6 @@ class TenantMainMiddleware(MiddlewareMixin):
         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')
 
         # Try to get tenant from cookie token first
         tenant_token = request.COOKIES.get(ORGANIZATION_TOKEN_COOKIE_KEY)
@@ -57,21 +60,34 @@ class TenantMainMiddleware(MiddlewareMixin):
         if tenant_token:
             tenant = TokenTenant.for_token(tenant_token)
             # Verify the token's oxi_id matches the request
-            if tenant and tenant.oxi_id != oxi_id:
+            if not is_system_tenant(tenant) and tenant.oxi_id != oxi_id:
                 tenant = None
         
         # If no valid token, fetch from database
         if not tenant:
-            tenant_model = connection.tenant_model
-            try:
-                tenant = self.get_tenant(tenant_model, oxi_id)
-                # Mark that we need to set the cookie in the response
-                request._should_set_tenant_cookie = True
-            except tenant_model.DoesNotExist:
-                default_tenant = self.no_tenant_found(request, oxi_id)
-                return default_tenant
+            if oxi_id: # fetch with oxi_id on tenant
+                tenant_model = connection.tenant_model
+                try:
+                    tenant = self.get_tenant(tenant_model, oxi_id)
+                    # Mark that we need to set the cookie in the response
+                    request._should_set_tenant_cookie = True
+                except tenant_model.DoesNotExist:
+                    default_tenant = self.no_tenant_found(request, oxi_id)
+                    return default_tenant
+            else: # try to return the system tenant
+                try:
+                    from oxutils.oxiliere.caches import get_system_tenant
+                    tenant = get_system_tenant()
+                    request._should_set_tenant_cookie = True
+                except Exception as e:
+                    from django.http import HttpResponseBadRequest
+                    return HttpResponseBadRequest('Missing X-Organization-ID header')
+
+        if tenant.is_deleted or not tenant.is_active:
+            return self.no_tenant_found(request, oxi_id)
 
         request.tenant = tenant
+        set_current_tenant_schema_name(tenant.schema_name)
         connection.set_tenant(request.tenant)
         self.setup_url_routing(request)
 

oxutils/oxiliere/models.py

@@ -1,25 +1,44 @@
+import time
+import uuid
+import structlog
 from django.db import models
+from django.utils import timezone
+from django.contrib.auth.models import AbstractBaseUser
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
 from django_tenants.models import TenantMixin
 from oxutils.models import (
-    TimestampMixin,
     BaseModelMixin,
-    UUIDPrimaryKeyMixin,
 )
 from oxutils.oxiliere.enums import TenantStatus
+from oxutils.oxiliere.exceptions import DeleteError
+from oxutils.oxiliere.signals import (
+    tenant_user_removed,
+    tenant_user_added,
+)
+from oxutils.oxiliere.utils import (
+    is_system_tenant,
+    generate_schema_name,
+)
 
+logger = structlog.get_logger(__name__)
 
 
+class TenantQuerySet(models.QuerySet):
+    def active(self):
+        return self.filter(is_deleted=False)
 
-tenant_model = getattr(settings, 'TENANT_MODEL', 'oxiliere.Tenant')
-tenant_user_model = getattr(settings, 'TENANT_USER_MODEL', 'oxiliere.TenantUser')
+    def deleted(self):
+        return self.filter(is_deleted=True)
 
+class TenantManager(models.Manager):
+    def get_queryset(self):
+        return TenantQuerySet(self.model, using=self._db).active()
 
 
-class BaseTenant(TenantMixin, UUIDPrimaryKeyMixin, TimestampMixin):
+class BaseTenant(TenantMixin, BaseModelMixin):
     name = models.CharField(max_length=100)
-    oxi_id = models.CharField(unique=True)
+    oxi_id = models.CharField(unique=True, max_length=25)
     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)
@@ -29,24 +48,126 @@ class BaseTenant(TenantMixin, UUIDPrimaryKeyMixin, TimestampMixin):
         default=TenantStatus.ACTIVE
     )
 
+    # soft delete
+    is_deleted = models.BooleanField(default=False)
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+    suffix = models.CharField(max_length=8, editable=False)
+
     # default true, schema will be automatically created and synced when it is saved
     auto_create_schema = True
+    # Schema will be automatically deleted when related tenant is deleted
+    auto_drop_schema = True
+
+    objects = models.Manager()
+    active = TenantManager()
+
+
+    def __str__(self):
+        return self.name
+
+    def save(self, *args, **kwargs):
+        if self._state.adding:
+            self.suffix = uuid.uuid4().hex[:8]
+            self.schema_name = generate_schema_name(self.oxi_id, self.suffix)
+        super().save(*args, **kwargs)
+
+    def delete(self, *args, force_drop: bool = False, **kwargs) -> None:
+        """Override deleting of Tenant object.
+
+        Args:
+            force_drop (bool): If True, forces the deletion of the object. Defaults to False.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        if force_drop:
+            super().delete(force_drop, *args, **kwargs)
+        else:
+            logger.warning("Tenant deletion is not allowed. Use delete_tenant to delete the tenant.")
+            raise DeleteError(_("Tenant deletion is not allowed. Use delete_tenant to delete the tenant."))
+
+    def delete_tenant(self) -> None:
+        """Mark tenant for deletion."""
+
+        if self.is_deleted:
+            return
+
+        # Prevent public tenant schema from being deleted
+        if is_system_tenant(self):
+            logger.warning("Cannot delete public tenant schema.")
+            raise ValueError(_("Cannot delete public tenant schema"))
+
+        time_string = str(int(time.time()))
+        new_id = f"{time_string}-deleted-{self.oxi_id}"
+
+        self.oxi_id = new_id
+        self.deleted_at = timezone.now()
+        self.is_deleted = True
+        self.is_active = False
+        self.status = TenantStatus.DELETED
+
+        self.save(update_fields=[
+            'oxi_id', 'deleted_at', 'is_deleted', 'is_active', 'status'
+        ])
+
+    def restore(self):
+        if not self.is_deleted:
+            return
+
+        oxi_id = self.oxi_id.split("-deleted-")[1]
+        self.oxi_id = oxi_id
+        self.is_deleted = False
+        self.deleted_at = None
+        self.is_active = True
+        self.status = TenantStatus.ACTIVE
+        self.save(update_fields=["oxi_id", "is_deleted", "deleted_at", "is_active", "status"])
+
+    
+    def add_user(self, user: AbstractBaseUser, is_owner: bool = False, is_admin: bool = False):
+        """Add user to tenant."""
+
+        if self.users.filter(user=user).exists():
+            logger.warning("User is already a member of this tenant.")
+            raise ValueError(_("User is already a member of this tenant."))
+
+        self.users.create(user=user, is_owner=is_owner, is_admin=is_admin)
+        tenant_user_added.send(sender=self.__class__, tenant=self, user=user)
+        
+
+    def remove_user(self, user: AbstractBaseUser):
+        """Remove user from tenant."""
+
+        if not self.users.filter(user=user).exists():
+            logger.warning("User is not a member of this tenant.")
+            raise ValueError("User is not a member of this tenant.")
+
+        self.users.filter(user=user).delete()
+        logger.info("User removed from tenant.")
+        tenant_user_removed.send(sender=self.__class__, tenant=self, user=user)
+        
 
     class Meta:
         abstract = True
         verbose_name = _('Tenant')
         verbose_name_plural = _('Tenants')
         indexes = [
-            models.Index(fields=['oxi_id'])
+            models.Index(fields=['schema_name']),
+            models.Index(fields=['oxi_id']),
+            models.Index(fields=['is_deleted']),
+            models.Index(fields=['oxi_id', 'is_deleted'])
         ]
 
 
 class BaseTenantUser(BaseModelMixin):
     tenant = models.ForeignKey(
-        tenant_model, on_delete=models.CASCADE
+        settings.TENANT_MODEL, 
+        on_delete=models.CASCADE,
+        related_name='users'
     )
     user = models.ForeignKey(
-        settings.AUTH_USER_MODEL, on_delete=models.CASCADE
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.CASCADE,
+        related_name='tenants'
     )
     is_owner = models.BooleanField(default=False)
     is_admin = models.BooleanField(default=False)
@@ -69,13 +190,3 @@ class BaseTenantUser(BaseModelMixin):
         indexes = [
             models.Index(fields=['tenant', 'user'])
         ]
-
-
-class Tenant(BaseTenant):
-    class Meta(BaseTenant.Meta):
-        abstract = not tenant_model == 'oxiliere.Tenant'
-
-
-class TenantUser(BaseTenantUser):
-    class Meta(BaseTenantUser.Meta):
-        abstract = not tenant_user_model == 'oxiliere.TenantUser'

oxutils/oxiliere/permissions.py

@@ -1,9 +1,10 @@
 from ninja_extra.permissions import BasePermission
-from oxutils.oxiliere.models import TenantUser
+from oxutils.oxiliere.utils import get_tenant_user_model
 from oxutils.constants import OXILIERE_SERVICE_TOKEN
 from oxutils.jwt.tokens import OxilierServiceToken
 
 
+
 class TenantPermission(BasePermission):
     """
     Vérifie que l'utilisateur a accès au tenant actuel.
@@ -17,7 +18,7 @@ class TenantPermission(BasePermission):
             return False
         
         # Vérifier que l'utilisateur a accès à ce tenant
-        return TenantUser.objects.filter(
+        return get_tenant_user_model().objects.filter(
             tenant__pk=request.tenant.pk,
             user__pk=request.user.pk
         ).exists()
@@ -34,7 +35,7 @@ class TenantOwnerPermission(BasePermission):
         if not hasattr(request, 'tenant'):
             return False
         
-        return TenantUser.objects.filter(
+        return get_tenant_user_model().objects.filter(
             tenant__pk=request.tenant.pk,
             user__pk=request.user.pk,
             is_owner=True
@@ -52,7 +53,7 @@ class TenantAdminPermission(BasePermission):
         if not hasattr(request, 'tenant'):
             return False
         
-        return TenantUser.objects.filter(
+        return get_tenant_user_model().objects.filter(
             tenant__pk=request.tenant.pk,
             user__pk=request.user.pk,
             is_admin=True
@@ -71,7 +72,7 @@ class TenantUserPermission(BasePermission):
         if not hasattr(request, 'tenant'):
             return False
         
-        return TenantUser.objects.filter(
+        return get_tenant_user_model().objects.filter(
             tenant__pk=request.tenant.pk,
             user__pk=request.user.pk
         ).exists()

oxutils/oxiliere/schemas.py

@@ -4,8 +4,10 @@ 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
+from oxutils.oxiliere.utils import (
+    get_tenant_user_model,
+)
+from oxutils.oxiliere.authorization import grant_manager_access_to_owners
 import structlog
 
 logger = structlog.get_logger(__name__)
@@ -22,6 +24,8 @@ class TenantSchema(Schema):
 
 class TenantOwnerSchema(Schema):
     oxi_id: UUID
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
     email: str
 
 
@@ -34,6 +38,7 @@ class CreateTenantSchema(Schema):
     def create_tenant(self):
         UserModel = get_user_model()
         TenantModel = get_tenant_model()
+        TenantUserModel = get_tenant_user_model()
 
         if TenantModel.objects.filter(oxi_id=self.tenant.oxi_id).exists():
             logger.info("tenant_exists", oxi_id=self.tenant.oxi_id)
@@ -42,25 +47,29 @@ class CreateTenantSchema(Schema):
         user, _ = UserModel.objects.get_or_create(
             oxi_id=self.owner.oxi_id,
             defaults={
+                'id': self.owner.oxi_id,
                 'email': self.owner.email,
+                'first_name': self.owner.first_name,
+                'last_name': self.owner.last_name
             }
         )
         
         tenant = TenantModel.objects.create(
             name=self.tenant.name,
-            schema_name=oxid_to_schema_name(self.tenant.oxi_id),
+            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(
+        TenantUserModel.objects.create(
             tenant=tenant,
             user=user,
             is_owner=True,
             is_admin=True,
         )
 
+        grant_manager_access_to_owners(tenant)
         logger.info("tenant_created", oxi_id=self.tenant.oxi_id)
         return tenant

oxutils/oxiliere/signals.py

@@ -0,0 +1,5 @@
+from django.dispatch import Signal
+
+
+tenant_user_removed = Signal()
+tenant_user_added = Signal()

oxutils/oxiliere/utils.py

@@ -1,6 +1,8 @@
 from typing import Any
+import uuid
 from django.apps import apps
 from django.conf import settings
+from .constants import OXI_SYSTEM_TENANT
 
 
 
@@ -20,6 +22,15 @@ def get_tenant_model() -> Any:
 def get_tenant_user_model() -> Any:
     return get_model('TENANT_USER_MODEL')
 
+def is_system_tenant(tenant: Any) -> bool:
+    return tenant.schema_name == get_system_tenant_schema_name()
+
+def get_system_tenant_schema_name():
+    system_schema_name = oxid_to_schema_name(
+        getattr(settings, 'OXI_SYSTEM_TENANT', OXI_SYSTEM_TENANT)
+    )
+
+    return system_schema_name
 
 def oxid_to_schema_name(oxid: str) -> str:
     """
@@ -58,6 +69,13 @@ def oxid_to_schema_name(oxid: str) -> str:
     return schema_name
 
 
+def generate_schema_name(oxi_id: str, suffix: str = None) -> str:
+    cleaned = oxid_to_schema_name(oxi_id)
+    if suffix:
+        return f"{cleaned}_{suffix}"
+    return f"{cleaned}_{uuid.uuid4().hex[:8]}"
+
+
 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