maquinaweb-shared-auth 0.2.32__py3-none-any.whl → 0.2.34__py3-none-any.whl

{maquinaweb_shared_auth-0.2.32.dist-info → maquinaweb_shared_auth-0.2.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maquinaweb-shared-auth
-Version: 0.2.32
+Version: 0.2.34
 Summary: Models read-only para autenticação compartilhada entre projetos Django.
 Author-email: Seu Nome <seuemail@dominio.com>
 License: MIT

maquinaweb_shared_auth-0.2.34.dist-info/RECORD

@@ -0,0 +1,23 @@
+shared_auth/__init__.py,sha256=VVZP2qk5NCIQacyiVEkgTIVemYYTsISJh2Rn2VBvUXw,434
+shared_auth/abstract_models.py,sha256=jaixzhGl4B8Pc6ppG3BxSBNPZxVw6S3o9IDbcVmtGns,9436
+shared_auth/app.py,sha256=EHoLKlpW41o6ZxcH184aMhnWQxkVp9fH2_-89RjMz-4,215
+shared_auth/authentication.py,sha256=fwqhGUAslRFXVLBxuxrzB3q8eAWlAyRIuaZ3BL_s-zA,1653
+shared_auth/conf.py,sha256=WlSXQB7p3BfE3BL6WR6EDYpCHQEjDlxQlyf8dTfClsk,621
+shared_auth/decorators.py,sha256=-2RHRzvPJzN0c8Q-cB1_hf5tk386jcHZ9-GixKSe0ds,3346
+shared_auth/exceptions.py,sha256=VKamHjBl2yjXG2RsMrLrXru1_Q9IJXmy4xmDcXlpWsU,627
+shared_auth/fields.py,sha256=RAcmFh1D_nkbai_7t_OrPZhfhAipesy5kKnEj4LUvvM,1254
+shared_auth/managers.py,sha256=OQd76OeAkeyRoFnifQ0zZdp45h27QVwBpR0BgiiTFbQ,6968
+shared_auth/middleware.py,sha256=A8yc8Ld4EslEcPCdekfCrU7eAXgql_AntYjy1xMchu8,6335
+shared_auth/mixins.py,sha256=kcTkjrNu-UGLwXQHsq9vQDx7qQjILa3Na8HvouLU3Ms,7588
+shared_auth/models.py,sha256=HCVIog61J0xeygYIs_amSA-MsSRhxIlGTSkegA9b51c,1444
+shared_auth/permissions.py,sha256=l48n9qCUMrhQOTa5_Cv1vynv-bb3i5T05yLoyKvKmOM,2713
+shared_auth/router.py,sha256=JhlDjosViMBmuvYm08vJzKyvrg5P5ECtrU4tKAGsuoU,684
+shared_auth/serializers.py,sha256=PZENjBfD4GK8SnJL0Xp1Z6SzZlNNeyzJILp8uPxkEEI,14224
+shared_auth/storage_backend.py,sha256=Eqkjz8aF5UrOpRwYl-J0Td95IObfxnJ8eLQDJVFM3Io,184
+shared_auth/urls.py,sha256=591wWEWJPaHEGkcOZ8yvfgxddRyOcZLgOc0vNtF7XRI,289
+shared_auth/utils.py,sha256=hItxL-spzyS2jUHSm9gHoATGH1m5bNl9DYGrule_35s,3524
+shared_auth/views.py,sha256=2hyLnYSWUscfq-jVcskt-ukzDt4vg6IXeKjRDRu9RXk,1519
+maquinaweb_shared_auth-0.2.34.dist-info/METADATA,sha256=0ll4Oy9MyeitIUNiYs9V-984k-G_bOyabSydESbkkVA,26325
+maquinaweb_shared_auth-0.2.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maquinaweb_shared_auth-0.2.34.dist-info/top_level.txt,sha256=msyYRy02ZV7zz7GR1raUI5LXGFIFn2TIkgkeKZqKufE,12
+maquinaweb_shared_auth-0.2.34.dist-info/RECORD,,

shared_auth/__init__.py

@@ -3,4 +3,19 @@ Biblioteca compartilhada para acesso aos models de autenticação
 """
 
 __version__ = '1.0.0'
-default_app_config = "shared_auth.app.SharedAuthConfig"
+default_app_config = "shared_auth.app.SharedAuthConfig"
+
+# Exportar utilitários para facilitar importação
+from .utils import (
+    get_member_model,
+    get_organization_model,
+    get_token_model,
+    get_user_model,
+)
+
+__all__ = [
+    'get_token_model',
+    'get_organization_model',
+    'get_user_model',
+    'get_member_model',
+]

shared_auth/abstract_models.py

@@ -0,0 +1,328 @@
+"""
+Models abstratos para customização
+Estes models podem ser herdados nos apps clientes para adicionar campos e métodos customizados
+"""
+
+import os
+
+from django.contrib.auth.models import AbstractUser
+from django.db import models
+
+from .conf import MEMBER_TABLE, ORGANIZATION_TABLE, TOKEN_TABLE, USER_TABLE
+from .exceptions import OrganizationNotFoundError
+from .managers import SharedMemberManager, SharedOrganizationManager, UserManager
+from .storage_backend import Storage
+
+
+def organization_image_path(instance, filename):
+    return os.path.join(
+        "organization",
+        str(instance.pk),
+        "images",
+        filename,
+    )
+
+
+class AbstractSharedToken(models.Model):
+    """
+    Model abstrato READ-ONLY da tabela authtoken_token
+    Usado para validar tokens em outros sistemas
+    
+    Para customizar, crie um model no seu app:
+    
+    from shared_auth.abstract_models import AbstractSharedToken
+    
+    class CustomToken(AbstractSharedToken):
+        # Adicione campos customizados
+        custom_field = models.CharField(max_length=100)
+        
+        class Meta(AbstractSharedToken.Meta):
+            pass
+    
+    E configure no settings.py:
+    SHARED_AUTH_TOKEN_MODEL = 'seu_app.CustomToken'
+    """
+
+    key = models.CharField(max_length=40, primary_key=True)
+    user_id = models.IntegerField()
+    created = models.DateTimeField()
+
+    objects = models.Manager()
+
+    class Meta:
+        abstract = True
+        managed = False
+        db_table = TOKEN_TABLE
+
+    def __str__(self):
+        return self.key
+
+    @property
+    def user(self):
+        """Acessa usuário do token"""
+        from .utils import get_user_model
+        
+        if not hasattr(self, "_cached_user"):
+            User = get_user_model()
+            self._cached_user = User.objects.get_or_fail(self.user_id)
+        return self._cached_user
+
+    def is_valid(self):
+        """Verifica se token ainda é válido"""
+        # Implementar lógica de expiração se necessário
+        return True
+
+
+class AbstractSharedOrganization(models.Model):
+    """
+    Model abstrato READ-ONLY da tabela organization
+    Usado para acessar dados de organizações em outros sistemas
+    
+    Para customizar, crie um model no seu app:
+    
+    from shared_auth.abstract_models import AbstractSharedOrganization
+    
+    class CustomOrganization(AbstractSharedOrganization):
+        # Adicione campos customizados
+        custom_field = models.CharField(max_length=100)
+        
+        class Meta(AbstractSharedOrganization.Meta):
+            pass
+    
+    E configure no settings.py:
+    SHARED_AUTH_ORGANIZATION_MODEL = 'seu_app.CustomOrganization'
+    """
+
+    # Campos principais
+    name = models.CharField(max_length=255)
+    fantasy_name = models.CharField(max_length=255, blank=True, null=True)
+    cnpj = models.CharField(max_length=255, blank=True, null=True)
+    telephone = models.CharField(max_length=50, blank=True, null=True)
+    cellphone = models.CharField(max_length=50, blank=True, null=True)
+    email = models.EmailField(blank=True, null=True)
+    image_organization = models.ImageField(
+        storage=Storage, upload_to=organization_image_path, null=True
+    )
+
+    # Relacionamentos
+    main_organization_id = models.IntegerField(null=True, blank=True)
+    is_branch = models.BooleanField(default=False)
+    metadata = models.JSONField(default=dict)
+    
+    # Metadados
+    created_at = models.DateTimeField()
+    updated_at = models.DateTimeField()
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+    objects = SharedOrganizationManager()
+
+    class Meta:
+        abstract = True
+        managed = False
+        db_table = ORGANIZATION_TABLE
+
+    def __str__(self):
+        return self.fantasy_name or self.name or f"Org #{self.pk}"
+
+    @property
+    def main_organization(self):
+        """
+        Acessa organização principal (lazy loading)
+
+        Usage:
+            if org.is_branch:
+                main = org.main_organization
+        """
+        from .utils import get_organization_model
+        
+        if self.main_organization_id:
+            Organization = get_organization_model()
+            return Organization.objects.get_or_fail(self.main_organization_id)
+        return None
+
+    @property
+    def branches(self):
+        """
+        Retorna filiais desta organização
+
+        Usage:
+            branches = org.branches
+        """
+        from .utils import get_organization_model
+        
+        Organization = get_organization_model()
+        return Organization.objects.filter(main_organization_id=self.pk)
+
+    @property
+    def members(self):
+        """
+        Retorna membros desta organização
+
+        Usage:
+            members = org.members
+            for member in members:
+                print(member.user.email)
+        """
+        from .utils import get_member_model
+        
+        Member = get_member_model()
+        return Member.objects.for_organization(self.pk)
+
+    @property
+    def users(self):
+        """
+        Retorna usuários desta organização
+
+        Usage:
+            users = org.users
+        """
+        from .utils import get_user_model
+        
+        User = get_user_model()
+        return User.objects.filter(
+            id__in=self.members.values_list("user_id", flat=True)
+        )
+
+    def is_active(self):
+        """Verifica se organização está ativa"""
+        return self.deleted_at is None
+
+
+class AbstractUser(AbstractUser):
+    """
+    Model abstrato READ-ONLY da tabela auth_user
+    
+    Para customizar, crie um model no seu app:
+    
+    from shared_auth.abstract_models import AbstractUser
+    
+    class CustomUser(AbstractUser):
+        # Adicione campos customizados
+        custom_field = models.CharField(max_length=100)
+        
+        class Meta(AbstractUser.Meta):
+            pass
+    
+    E configure no settings.py:
+    SHARED_AUTH_USER_MODEL = 'seu_app.CustomUser'
+    """
+
+    date_joined = models.DateTimeField()
+    last_login = models.DateTimeField(null=True, blank=True)
+    avatar = models.ImageField(storage=Storage, blank=True, null=True)
+    
+    # Campos customizados
+    createdat = models.DateTimeField()
+    updatedat = models.DateTimeField()
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+    objects = UserManager()
+
+    class Meta:
+        abstract = True
+        managed = False
+        db_table = USER_TABLE
+
+    @property
+    def organizations(self):
+        """
+        Retorna todas as organizações associadas ao usuário.
+        """
+        from .utils import get_organization_model, get_member_model
+        
+        Organization = get_organization_model()
+        Member = get_member_model()
+        
+        return Organization.objects.filter(
+            id__in=Member.objects.filter(user_id=self.id).values_list(
+                "organization_id", flat=True
+            )
+        )
+
+    def get_org(self, organization_id):
+        """
+        Retorna a organização especificada pelo ID, se o usuário for membro.
+        """
+        from .utils import get_organization_model, get_member_model
+        
+        Organization = get_organization_model()
+        Member = get_member_model()
+        
+        try:
+            organization = Organization.objects.get(id=organization_id)
+        except Organization.DoesNotExist:
+            raise OrganizationNotFoundError(
+                f"Organização com ID {organization_id} não encontrada."
+            )
+
+        if not Member.objects.filter(
+            user_id=self.id, organization_id=organization.id
+        ).exists():
+            raise OrganizationNotFoundError("Usuário não é membro desta organização.")
+
+        return organization
+
+
+class AbstractSharedMember(models.Model):
+    """
+    Model abstrato READ-ONLY da tabela organization_member
+    Relacionamento entre User e Organization
+    
+    Para customizar, crie um model no seu app:
+    
+    from shared_auth.abstract_models import AbstractSharedMember
+    
+    class CustomMember(AbstractSharedMember):
+        # Adicione campos customizados
+        custom_field = models.CharField(max_length=100)
+        
+        class Meta(AbstractSharedMember.Meta):
+            pass
+    
+    E configure no settings.py:
+    SHARED_AUTH_MEMBER_MODEL = 'seu_app.CustomMember'
+    """
+
+    user_id = models.IntegerField()
+    organization_id = models.IntegerField()
+    metadata = models.JSONField(default=dict)
+
+    objects = SharedMemberManager()
+
+    class Meta:
+        abstract = True
+        managed = False
+        db_table = MEMBER_TABLE
+
+    def __str__(self):
+        return f"Member: User {self.user_id} - Org {self.organization_id}"
+
+    @property
+    def user(self):
+        """
+        Acessa usuário (lazy loading)
+
+        Usage:
+            member = SharedMember.objects.first()
+            user = member.user
+            print(user.email)
+        """
+        from .utils import get_user_model
+        
+        User = get_user_model()
+        return User.objects.get_or_fail(self.user_id)
+
+    @property
+    def organization(self):
+        """
+        Acessa organização (lazy loading)
+
+        Usage:
+            member = SharedMember.objects.first()
+            org = member.organization
+            print(org.name)
+        """
+        from .utils import get_organization_model
+        
+        Organization = get_organization_model()
+        return Organization.objects.get_or_fail(self.organization_id)

shared_auth/authentication.py

@@ -6,13 +6,15 @@ from django.utils.translation import gettext_lazy as _
 from rest_framework import exceptions
 from rest_framework.authentication import TokenAuthentication
 
-from .models import SharedToken, User
+from .utils import get_token_model, get_user_model
 
 
 class SharedTokenAuthentication(TokenAuthentication):
     """
     Autentica usando tokens do banco de dados compartilhado
 
+    Usa get_token_model() e get_user_model() para suportar models customizados.
+
     Usage em settings.py:
         REST_FRAMEWORK = {
             'DEFAULT_AUTHENTICATION_CLASSES': [
@@ -21,15 +23,21 @@ class SharedTokenAuthentication(TokenAuthentication):
         }
     """
 
-    model = SharedToken
+    @property
+    def model(self):
+        """Retorna o model de Token configurado"""
+        return get_token_model()
 
     def authenticate_credentials(self, key):
         """
         Valida o token no banco de dados compartilhado
         """
+        Token = get_token_model()
+        User = get_user_model()
+
         try:
-            token = SharedToken.objects.get(key=key)
-        except SharedToken.DoesNotExist:
+            token = Token.objects.get(key=key)
+        except Token.DoesNotExist:
             raise exceptions.AuthenticationFailed(_("Token inválido."))
 
         # Buscar usuário completo

shared_auth/decorators.py

@@ -6,7 +6,7 @@ from functools import wraps
 
 from django.http import JsonResponse
 
-from .models import SharedOrganization, SharedToken, User
+from .utils import get_organization_model, get_token_model, get_user_model
 
 
 def require_auth(view_func):
@@ -28,8 +28,11 @@ def require_auth(view_func):
             return JsonResponse({"error": "Token não fornecido"}, status=401)
 
         # Validar token
+        Token = get_token_model()
+        User = get_user_model()
+
         try:
-            token_obj = SharedToken.objects.get(key=token)
+            token_obj = Token.objects.get(key=token)
             user = User.objects.get(pk=token_obj.user_id)
 
             if not user.is_active or user.deleted_at is not None:
@@ -38,7 +41,7 @@ def require_auth(view_func):
             request.user = user
             request.auth = token_obj
 
-        except (SharedToken.DoesNotExist, User.DoesNotExist):
+        except (Token.DoesNotExist, User.DoesNotExist):
             return JsonResponse({"error": "Token inválido"}, status=401)
 
         return view_func(request, *args, **kwargs)
@@ -58,15 +61,17 @@ def require_organization(view_func):
             return JsonResponse({"error": "Organização não definida"}, status=403)
 
         # Buscar organização
+        Organization = get_organization_model()
+
         try:
-            org = SharedOrganization.objects.get(pk=request.organization_id)
+            org = Organization.objects.get(pk=request.organization_id)
 
             if not org.is_active():
                 return JsonResponse({"error": "Organização inativa"}, status=403)
 
             request.organization = org
 
-        except SharedOrganization.DoesNotExist:
+        except Organization.DoesNotExist:
             return JsonResponse({"error": "Organização não encontrada"}, status=404)
 
         return view_func(request, *args, **kwargs)

shared_auth/managers.py

@@ -95,7 +95,7 @@ class OrganizationQuerySetMixin:
             Lista de objetos com _cached_organization
         """
         objects = list(self.all())
-        from .models import SharedOrganization
+        from .utils import get_organization_model
 
         if not objects:
             return objects
@@ -104,8 +104,9 @@ class OrganizationQuerySetMixin:
         org_ids = set(obj.organization_id for obj in objects)
 
         # Buscar todas de uma vez
+        Organization = get_organization_model()
         organizations = {
-            org.pk: org for org in SharedOrganization.objects.filter(pk__in=org_ids)
+            org.pk: org for org in Organization.objects.filter(pk__in=org_ids)
         }
 
         # Cachear nos objetos
@@ -130,7 +131,7 @@ class UserQuerySetMixin:
         """
         Pré-carrega dados de usuários (evita N+1)
         """
-        from .models import User
+        from .utils import get_user_model
 
         objects = list(self.all())
 
@@ -139,6 +140,7 @@ class UserQuerySetMixin:
 
         user_ids = set(obj.user_id for obj in objects)
 
+        User = get_user_model()
         users = {user.pk: user for user in User.objects.filter(pk__in=user_ids)}
 
         for obj in objects:
@@ -154,7 +156,7 @@ class OrganizationUserQuerySetMixin(OrganizationQuerySetMixin, UserQuerySetMixin
         """
         Pré-carrega dados de organizações E usuários (evita N+1)
         """
-        from .models import SharedOrganization, User
+        from .utils import get_organization_model, get_user_model
 
         objects = list(self.all())
 
@@ -166,8 +168,11 @@ class OrganizationUserQuerySetMixin(OrganizationQuerySetMixin, UserQuerySetMixin
         user_ids = set(obj.user_id for obj in objects)
 
         # Buscar em batch
+        Organization = get_organization_model()
+        User = get_user_model()
+
         organizations = {
-            org.pk: org for org in SharedOrganization.objects.filter(pk__in=org_ids)
+            org.pk: org for org in Organization.objects.filter(pk__in=org_ids)
         }
 
         users = {user.pk: user for user in User.objects.filter(pk__in=user_ids)}
@@ -183,13 +188,15 @@ class OrganizationUserQuerySetMixin(OrganizationQuerySetMixin, UserQuerySetMixin
         """
         Cria objeto com validação de organização e usuário
         """
-        from .models import SharedMember, SharedOrganization
+        from .utils import get_member_model, get_organization_model
 
         # Valida organização
-        SharedOrganization.objects.get_or_fail(organization_id)
+        Organization = get_organization_model()
+        Organization.objects.get_or_fail(organization_id)
 
         # Valida usuário pertence à organização
-        if not SharedMember.objects.filter(
+        Member = get_member_model()
+        if not Member.objects.filter(
             user_id=user_id, organization_id=organization_id
         ).exists():
             raise ValueError(

shared_auth/middleware.py

@@ -6,7 +6,12 @@ from django.http import JsonResponse
 from django.utils.deprecation import MiddlewareMixin
 
 from .authentication import SharedTokenAuthentication
-from .models import SharedMember, SharedOrganization, SharedToken, User
+from .utils import (
+    get_member_model,
+    get_organization_model,
+    get_token_model,
+    get_user_model,
+)
 
 
 class SharedAuthMiddleware(MiddlewareMixin):
@@ -50,8 +55,11 @@ class SharedAuthMiddleware(MiddlewareMixin):
             return None
 
         # Validar token e buscar usuário
+        Token = get_token_model()
+        User = get_user_model()
+
         try:
-            token_obj = SharedToken.objects.get(key=token)
+            token_obj = Token.objects.get(key=token)
             user = User.objects.get(pk=token_obj.user_id)
 
             if not user.is_active or user.deleted_at is not None:
@@ -63,7 +71,7 @@ class SharedAuthMiddleware(MiddlewareMixin):
             # request.user = user
             request.auth = token_obj
 
-        except (SharedToken.DoesNotExist, User.DoesNotExist):
+        except (Token.DoesNotExist, User.DoesNotExist):
             # request.user = None
             request.auth = None
 
@@ -159,9 +167,8 @@ class OrganizationMiddleware(MiddlewareMixin):
                 return
 
         request.organization_id = organization_id
-        request.organization = SharedOrganization.objects.filter(
-            pk=organization_id
-        ).first()
+        Organization = get_organization_model()
+        request.organization = Organization.objects.filter(pk=organization_id).first()
 
     @staticmethod
     def _authenticate_user(request):
@@ -194,7 +201,8 @@ class OrganizationMiddleware(MiddlewareMixin):
             return None
 
         # Buscar a primeira organização que o usuário pertence
-        member = SharedMember.objects.filter(user_id=request.user.pk).first()
+        Member = get_member_model()
+        member = Member.objects.filter(user_id=request.user.pk).first()
 
         return member.organization_id if member else None
 
@@ -210,6 +218,8 @@ class OrganizationMiddleware(MiddlewareMixin):
 
 
 def get_member(user_id, organization_id):
-    return SharedMember.objects.filter(
+    """Busca membro usando o model configurado"""
+    Member = get_member_model()
+    return Member.objects.filter(
         user_id=user_id, organization_id=organization_id
     ).first()

shared_auth/mixins.py

@@ -44,9 +44,10 @@ class OrganizationMixin(models.Model):
         Acessa organização do banco de auth (lazy loading com cache)
         """
         if not hasattr(self, "_cached_organization"):
-            from shared_auth.models import SharedOrganization
+            from shared_auth.utils import get_organization_model
 
-            self._cached_organization = SharedOrganization.objects.get_or_fail(
+            Organization = get_organization_model()
+            self._cached_organization = Organization.objects.get_or_fail(
                 self.organization_id
             )
         return self._cached_organization
@@ -69,7 +70,7 @@ class OrganizationMixin(models.Model):
         """Retorna nome da organização (safe)"""
         try:
             return self.organization.name
-        except:
+        except Exception:
             return None
 
 
@@ -108,8 +109,9 @@ class UserMixin(models.Model):
         Acessa usuário do banco de auth (lazy loading com cache)
         """
         if not hasattr(self, "_cached_user"):
-            from shared_auth.models import User
+            from shared_auth.utils import get_user_model
 
+            User = get_user_model()
             self._cached_user = User.objects.get_or_fail(self.user_id)
         return self._cached_user
 
@@ -118,7 +120,7 @@ class UserMixin(models.Model):
         """Retorna email do usuário (safe)"""
         try:
             return self.user.email
-        except:
+        except Exception:
             return None
 
     @property
@@ -126,7 +128,7 @@ class UserMixin(models.Model):
         """Retorna nome completo do usuário (safe)"""
         try:
             return self.user.get_full_name()
-        except:
+        except Exception:
             return None
 
     @property
@@ -138,7 +140,7 @@ class UserMixin(models.Model):
         """Verifica se o usuário está ativo"""
         try:
             return self.user.is_active and self.user.deleted_at is None
-        except:
+        except Exception:
             return False
 
 
@@ -171,9 +173,10 @@ class OrganizationUserMixin(OrganizationMixin, UserMixin):
         Returns:
             bool: True se pertence, False caso contrário
         """
-        from shared_auth.models import SharedMember
+        from shared_auth.utils import get_member_model
 
-        return SharedMember.objects.filter(
+        Member = get_member_model()
+        return Member.objects.filter(
             user_id=self.user_id, organization_id=self.organization_id
         ).exists()
 
@@ -182,9 +185,10 @@ class OrganizationUserMixin(OrganizationMixin, UserMixin):
         Verifica se um usuário pode acessar este registro
         (se pertence à mesma organização)
         """
-        from shared_auth.models import SharedMember
+        from shared_auth.utils import get_member_model
 
-        return SharedMember.objects.filter(
+        Member = get_member_model()
+        return Member.objects.filter(
             user_id=user_id, organization_id=self.organization_id
         ).exists()
 

shared_auth/models.py

@@ -1,235 +1,58 @@
 """
 Models READ-ONLY para acesso aos dados de autenticação
 ATENÇÃO: Estes models NÃO devem ser usados para criar migrations
-"""
-
-import os
 
-from django.contrib.auth.models import AbstractUser
-from django.db import models
+Para customizar estes models, herde dos models abstratos em shared_auth.abstract_models
+e configure no settings.py. Veja a documentação em abstract_models.py
+"""
 
-from .conf import MEMBER_TABLE, ORGANIZATION_TABLE, TOKEN_TABLE, USER_TABLE
-from .exceptions import OrganizationNotFoundError
-from .managers import SharedMemberManager, SharedOrganizationManager, UserManager
-from .storage_backend import Storage
+from .abstract_models import (
+    AbstractSharedMember,
+    AbstractSharedOrganization,
+    AbstractSharedToken,
+    AbstractUser,
+)
 
 
-class SharedToken(models.Model):
+class SharedToken(AbstractSharedToken):
     """
-    Model READ-ONLY da tabela authtoken_token
-    Usado para validar tokens em outros sistemas
+    Model READ-ONLY padrão da tabela authtoken_token
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedToken
     """
-
-    key = models.CharField(max_length=40, primary_key=True)
-    user_id = models.IntegerField()
-    created = models.DateTimeField()
-
-    objects = models.Manager()
-
-    class Meta:
-        managed = False
-        db_table = TOKEN_TABLE
-
-    def __str__(self):
-        return self.key
-
-    @property
-    def user(self):
-        """Acessa usuário do token"""
-        if not hasattr(self, "_cached_user"):
-            self._cached_user = User.objects.get_or_fail(self.user_id)
-        return self._cached_user
-
-    def is_valid(self):
-        """Verifica se token ainda é válido"""
-        # Implementar lógica de expiração se necessário
-        return True
-
-
-def organization_image_path(instance, filename):
-    return os.path.join(
-        "organization",
-        str(instance.pk),
-        "images",
-        filename,
-    )
+    
+    class Meta(AbstractSharedToken.Meta):
+        pass
 
 
-class SharedOrganization(models.Model):
+class SharedOrganization(AbstractSharedOrganization):
     """
-    Model READ-ONLY da tabela organization
-    Usado para acessar dados de organizações em outros sistemas
+    Model READ-ONLY padrão da tabela organization
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedOrganization
     """
-
-    # Campos principais
-    name = models.CharField(max_length=255)
-    fantasy_name = models.CharField(max_length=255, blank=True, null=True)
-    cnpj = models.CharField(max_length=255, blank=True, null=True)
-    telephone = models.CharField(max_length=50, blank=True, null=True)
-    cellphone = models.CharField(max_length=50, blank=True, null=True)
-    email = models.EmailField(blank=True, null=True)
-    image_organization = models.ImageField(
-        storage=Storage, upload_to=organization_image_path, null=True
-    )
-
-    # Relacionamentos
-    main_organization_id = models.IntegerField(null=True, blank=True)
-    is_branch = models.BooleanField(default=False)
-
-    # Metadados
-    created_at = models.DateTimeField()
-    updated_at = models.DateTimeField()
-    deleted_at = models.DateTimeField(null=True, blank=True)
-
-    objects = SharedOrganizationManager()
-
-    class Meta:
-        managed = False  # CRITICAL: Não gera migrations
-        db_table = ORGANIZATION_TABLE
-
-    def __str__(self):
-        return self.fantasy_name or self.name or f"Org #{self.pk}"
-
-    @property
-    def main_organization(self):
-        """
-        Acessa organização principal (lazy loading)
-
-        Usage:
-            if org.is_branch:
-                main = org.main_organization
-        """
-        if self.main_organization_id:
-            return SharedOrganization.objects.get_or_fail(self.main_organization_id)
-        return None
-
-    @property
-    def branches(self):
-        """
-        Retorna filiais desta organização
-
-        Usage:
-            branches = org.branches
-        """
-        return SharedOrganization.objects.filter(main_organization_id=self.pk)
-
-    @property
-    def members(self):
-        """
-        Retorna membros desta organização
-
-        Usage:
-            members = org.members
-            for member in members:
-                print(member.user.email)
-        """
-        return SharedMember.objects.for_organization(self.pk)
-
-    @property
-    def users(self):
-        """
-        Retorna usuários desta organização
-
-        Usage:
-            users = org.users
-        """
-        return User.objects.filter(
-            id__in=self.members.values_list("user_id", flat=True)
-        )
-
-    def is_active(self):
-        """Verifica se organização está ativa"""
-        return self.deleted_at is None
+    
+    class Meta(AbstractSharedOrganization.Meta):
+        pass
 
 
 class User(AbstractUser):
     """
-    Model READ-ONLY da tabela auth_user
+    Model READ-ONLY padrão da tabela auth_user
+    
+    Para customizar, crie seu próprio model herdando de AbstractUser
     """
+    
+    class Meta(AbstractUser.Meta):
+        pass
 
-    date_joined = models.DateTimeField()
-    last_login = models.DateTimeField(null=True, blank=True)
-    avatar = models.ImageField(storage=Storage, blank=True, null=True)
-    # Campos customizados
-    createdat = models.DateTimeField()
-    updatedat = models.DateTimeField()
-    deleted_at = models.DateTimeField(null=True, blank=True)
-
-    objects = UserManager()
-
-    class Meta:
-        managed = False
-        db_table = USER_TABLE
-
-    @property
-    def organizations(self):
-        """
-        Retorna todas as organizações associadas ao usuário.
-        """
-        return SharedOrganization.objects.filter(
-            id__in=SharedMember.objects.filter(user_id=self.id).values_list(
-                "organization_id", flat=True
-            )
-        )
-
-    def get_org(self, organization_id):
-        """
-        Retorna a organização especificada pelo ID, se o usuário for membro.
-        """
-        try:
-            organization = SharedOrganization.objects.get(id=organization_id)
-        except SharedOrganization.DoesNotExist:
-            raise OrganizationNotFoundError(
-                f"Organização com ID {organization_id} não encontrada."
-            )
-
-        if not SharedMember.objects.filter(
-            user_id=self.id, organization_id=organization.id
-        ).exists():
-            raise OrganizationNotFoundError("Usuário não é membro desta organização.")
 
-        return organization
-
-
-class SharedMember(models.Model):
+class SharedMember(AbstractSharedMember):
     """
-    Model READ-ONLY da tabela organization_member
-    Relacionamento entre User e Organization
+    Model READ-ONLY padrão da tabela organization_member
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedMember
     """
-
-    user_id = models.IntegerField()
-    organization_id = models.IntegerField()
-    metadata = models.JSONField(default=dict)
-
-    objects = SharedMemberManager()
-
-    class Meta:
-        managed = False
-        db_table = MEMBER_TABLE
-
-    def __str__(self):
-        return f"Member: User {self.user_id} - Org {self.organization_id}"
-
-    @property
-    def user(self):
-        """
-        Acessa usuário (lazy loading)
-
-        Usage:
-            member = SharedMember.objects.first()
-            user = member.user
-            print(user.email)
-        """
-        return User.objects.get_or_fail(self.user_id)
-
-    @property
-    def organization(self):
-        """
-        Acessa organização (lazy loading)
-
-        Usage:
-            member = SharedMember.objects.first()
-            org = member.organization
-            print(org.name)
-        """
-        return SharedOrganization.objects.get_or_fail(self.organization_id)
+    
+    class Meta(AbstractSharedMember.Meta):
+        pass

shared_auth/permissions.py

@@ -5,6 +5,7 @@ Permissões customizadas para DRF
 from rest_framework import permissions
 
 from shared_auth.middleware import get_member
+from shared_auth.utils import get_organization_model
 
 
 class IsAuthenticated(permissions.BasePermission):
@@ -35,12 +36,12 @@ class HasActiveOrganization(permissions.BasePermission):
             return False
 
         # Verificar se organização está ativa
-        from .models import SharedOrganization
+        Organization = get_organization_model()
 
         try:
-            org = SharedOrganization.objects.get(pk=request.organization_id)
+            org = Organization.objects.get(pk=request.organization_id)
             return org.is_active()
-        except SharedOrganization.DoesNotExist:
+        except Organization.DoesNotExist:
             return False
 
 

shared_auth/router.py

@@ -3,7 +3,7 @@ class SharedAuthRouter:
     Direciona queries dos models compartilhados para o banco correto
     """
 
-    route_app_labels = {"shared_auth", "auth", "admin"}
+    route_app_labels = {"shared_auth", "auth", "admin", "contenttypes"}
 
     def db_for_read(self, model, **hints):
         if model._meta.app_label in self.route_app_labels:

shared_auth/serializers.py

@@ -13,7 +13,7 @@ Se quiser usar separadamente:
 
 from rest_framework import serializers
 
-from .models import SharedOrganization, User
+from .utils import get_organization_model, get_user_model
 
 
 class OrganizationCreateSerializerMixin(serializers.ModelSerializer):
@@ -28,6 +28,8 @@ class OrganizationCreateSerializerMixin(serializers.ModelSerializer):
                 fields = ['id', 'titulo', 'conteudo']
     """
 
+    organization_id = serializers.IntegerField(required=False)
+
     def create(self, validated_data):
         """Automatically set organization_id from request context"""
         if self.context.get("request") and hasattr(
@@ -116,8 +118,17 @@ class OrganizationListCreateSerializerMixin(
 
 
 class OrganizationSerializer(serializers.ModelSerializer):
+    """
+    Serializer para o model de Organization configurado.
+    Usa get_organization_model() para suportar models customizados.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.Meta.model = get_organization_model()
+
     class Meta:
-        model = SharedOrganization
+        model = None  # Será definido dinamicamente no __init__
         fields = "__all__"
 
 
@@ -133,6 +144,8 @@ class UserCreateSerializerMixin(serializers.ModelSerializer):
                 fields = ['id', 'titulo', 'conteudo']
     """
 
+    user_id = serializers.IntegerField(required=False)
+
     def create(self, validated_data):
         """Automatically set user_id from request context"""
         if self.context.get("request") and hasattr(self.context["request"], "user"):
@@ -182,7 +195,7 @@ class UserSerializerMixin(serializers.ModelSerializer):
     def get_user(self, obj):
         """Retorna dados do usuário como objeto"""
         try:
-            user: User = obj.user
+            user = obj.user
             return {
                 "id": user.pk,
                 "username": user.username,
@@ -213,8 +226,17 @@ class UserListCreateSerializerMixin(UserSerializerMixin, UserCreateSerializerMix
 
 
 class UserSerializer(serializers.ModelSerializer):
+    """
+    Serializer para o model de User configurado.
+    Usa get_user_model() para suportar models customizados.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.Meta.model = get_user_model()
+
     class Meta:
-        model = User
+        model = None  # Será definido dinamicamente no __init__
         fields = [
             "id",
             "username",
@@ -241,6 +263,9 @@ class OrganizationUserCreateSerializerMixin(serializers.ModelSerializer):
                 fields = ['id', 'titulo', 'conteudo']
     """
 
+    organization_id = serializers.IntegerField(required=False)
+    user_id = serializers.IntegerField(required=False)
+
     def create(self, validated_data):
         """Automatically set both organization_id and user_id from request context"""
         if self.context.get("request"):

shared_auth/utils.py

@@ -0,0 +1,113 @@
+"""
+Utilitários para obter os models configurados
+Similar ao get_user_model() do Django
+"""
+
+from django.apps import apps
+from django.core.exceptions import ImproperlyConfigured
+
+from .conf import get_setting
+
+
+def get_token_model():
+    """
+    Retorna o model de Token configurado ou o padrão.
+    
+    Usage:
+        from shared_auth.utils import get_token_model
+        
+        Token = get_token_model()
+        token = Token.objects.get(key='abc123')
+    """
+    model_string = get_setting('SHARED_AUTH_TOKEN_MODEL', 'shared_auth.SharedToken')
+    
+    try:
+        return apps.get_model(model_string, require_ready=False)
+    except ValueError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_TOKEN_MODEL deve estar no formato 'app_label.model_name'. "
+            f"Recebido: '{model_string}'"
+        )
+    except LookupError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_TOKEN_MODEL refere-se ao model '{model_string}' "
+            f"que não foi instalado ou é inválido."
+        )
+
+
+def get_organization_model():
+    """
+    Retorna o model de Organization configurado ou o padrão.
+    
+    Usage:
+        from shared_auth.utils import get_organization_model
+        
+        Organization = get_organization_model()
+        org = Organization.objects.get(id=1)
+    """
+    model_string = get_setting('SHARED_AUTH_ORGANIZATION_MODEL', 'shared_auth.SharedOrganization')
+    
+    try:
+        return apps.get_model(model_string, require_ready=False)
+    except ValueError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_ORGANIZATION_MODEL deve estar no formato 'app_label.model_name'. "
+            f"Recebido: '{model_string}'"
+        )
+    except LookupError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_ORGANIZATION_MODEL refere-se ao model '{model_string}' "
+            f"que não foi instalado ou é inválido."
+        )
+
+
+def get_user_model():
+    """
+    Retorna o model de User configurado ou o padrão.
+    
+    Usage:
+        from shared_auth.utils import get_user_model
+        
+        User = get_user_model()
+        user = User.objects.get(id=1)
+    """
+    model_string = get_setting('SHARED_AUTH_USER_MODEL', 'shared_auth.User')
+    
+    try:
+        return apps.get_model(model_string, require_ready=False)
+    except ValueError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_USER_MODEL deve estar no formato 'app_label.model_name'. "
+            f"Recebido: '{model_string}'"
+        )
+    except LookupError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_USER_MODEL refere-se ao model '{model_string}' "
+            f"que não foi instalado ou é inválido."
+        )
+
+
+def get_member_model():
+    """
+    Retorna o model de Member configurado ou o padrão.
+    
+    Usage:
+        from shared_auth.utils import get_member_model
+        
+        Member = get_member_model()
+        member = Member.objects.get(id=1)
+    """
+    model_string = get_setting('SHARED_AUTH_MEMBER_MODEL', 'shared_auth.SharedMember')
+    
+    try:
+        return apps.get_model(model_string, require_ready=False)
+    except ValueError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_MEMBER_MODEL deve estar no formato 'app_label.model_name'. "
+            f"Recebido: '{model_string}'"
+        )
+    except LookupError:
+        raise ImproperlyConfigured(
+            f"SHARED_AUTH_MEMBER_MODEL refere-se ao model '{model_string}' "
+            f"que não foi instalado ou é inválido."
+        )

maquinaweb_shared_auth-0.2.32.dist-info/RECORD

@@ -1,21 +0,0 @@
-shared_auth/__init__.py,sha256=Ta8lIbyn22J6wU-TgWeSvdDHS4NBRf4Sv1Ag8VtY-bE,152
-shared_auth/app.py,sha256=EHoLKlpW41o6ZxcH184aMhnWQxkVp9fH2_-89RjMz-4,215
-shared_auth/authentication.py,sha256=AidtDV4zBWkezN2H6iyOiRNrBoWGgcYiXQU1WkhfUIo,1409
-shared_auth/conf.py,sha256=WlSXQB7p3BfE3BL6WR6EDYpCHQEjDlxQlyf8dTfClsk,621
-shared_auth/decorators.py,sha256=RT-Qfi7oGBo6PvWJRR1dqJUQdU6ZOf9p-8mV3rZmqQ0,3237
-shared_auth/exceptions.py,sha256=VKamHjBl2yjXG2RsMrLrXru1_Q9IJXmy4xmDcXlpWsU,627
-shared_auth/fields.py,sha256=RAcmFh1D_nkbai_7t_OrPZhfhAipesy5kKnEj4LUvvM,1254
-shared_auth/managers.py,sha256=NpIDMY7BWl1pKZKCepuNDxz7eekEUhKkOUYsWGbwyos,6715
-shared_auth/middleware.py,sha256=72GF8kGijbhw98v2Q-1sXBXk-7Bamfyvypm9h8xLX_I,6112
-shared_auth/mixins.py,sha256=BSYNTWYjLRGuxfy7x-uAaNZmrTMsm67ogAQzjrU2DoQ,7388
-shared_auth/models.py,sha256=QMY_Oyr4x7AtSNAFV3UfoJY0YBZwFKePvfVNWt-vQTc,6562
-shared_auth/permissions.py,sha256=FNIp12ePOUlXVp26zNMAyEtzX9kwyP7RuNIgaaCXtPA,2671
-shared_auth/router.py,sha256=zYidJ7j40lQLrhkCtAQAp-rQLhua_UF0X7SDzYRcV5w,668
-shared_auth/serializers.py,sha256=5jmyoyAAMCeMqxuVyw-tGPI8MCLfPslG94cdRL19B3Y,13374
-shared_auth/storage_backend.py,sha256=Eqkjz8aF5UrOpRwYl-J0Td95IObfxnJ8eLQDJVFM3Io,184
-shared_auth/urls.py,sha256=591wWEWJPaHEGkcOZ8yvfgxddRyOcZLgOc0vNtF7XRI,289
-shared_auth/views.py,sha256=2hyLnYSWUscfq-jVcskt-ukzDt4vg6IXeKjRDRu9RXk,1519
-maquinaweb_shared_auth-0.2.32.dist-info/METADATA,sha256=lIGuKuLhYkiFs9jDv-Kr6vlxW0N6tTciSdoZngCwRvA,26325
-maquinaweb_shared_auth-0.2.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maquinaweb_shared_auth-0.2.32.dist-info/top_level.txt,sha256=msyYRy02ZV7zz7GR1raUI5LXGFIFn2TIkgkeKZqKufE,12
-maquinaweb_shared_auth-0.2.32.dist-info/RECORD,,