maquinaweb-shared-auth 0.2.32__tar.gz → 0.2.34__tar.gz

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/PKG-INFO

@@ -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.32 → maquinaweb_shared_auth-0.2.34}/maquinaweb_shared_auth.egg-info/PKG-INFO

@@ -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.32 → maquinaweb_shared_auth-0.2.34}/maquinaweb_shared_auth.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ maquinaweb_shared_auth.egg-info/dependency_links.txt
 maquinaweb_shared_auth.egg-info/requires.txt
 maquinaweb_shared_auth.egg-info/top_level.txt
 shared_auth/__init__.py
+shared_auth/abstract_models.py
 shared_auth/app.py
 shared_auth/authentication.py
 shared_auth/conf.py
@@ -22,4 +23,5 @@ shared_auth/router.py
 shared_auth/serializers.py
 shared_auth/storage_backend.py
 shared_auth/urls.py
+shared_auth/utils.py
 shared_auth/views.py

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maquinaweb-shared-auth"
-version = "0.2.32"
+version = "0.2.34"
 description = "Models read-only para autenticação compartilhada entre projetos Django."
 readme = "README.md"
 requires-python = ">=3.13"

maquinaweb_shared_auth-0.2.34/shared_auth/__init__.py

@@ -0,0 +1,21 @@
+"""
+Biblioteca compartilhada para acesso aos models de autenticação
+"""
+
+__version__ = '1.0.0'
+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',
+]

maquinaweb_shared_auth-0.2.32/shared_auth/models.py → maquinaweb_shared_auth-0.2.34/shared_auth/abstract_models.py

@@ -1,6 +1,6 @@
 """
-Models READ-ONLY para acesso aos dados de autenticação
-ATENÇÃO: Estes models NÃO devem ser usados para criar migrations
+Models abstratos para customização
+Estes models podem ser herdados nos apps clientes para adicionar campos e métodos customizados
 """
 
 import os
@@ -14,10 +14,33 @@ from .managers import SharedMemberManager, SharedOrganizationManager, UserManage
 from .storage_backend import Storage
 
 
-class SharedToken(models.Model):
+def organization_image_path(instance, filename):
+    return os.path.join(
+        "organization",
+        str(instance.pk),
+        "images",
+        filename,
+    )
+
+
+class AbstractSharedToken(models.Model):
     """
-    Model READ-ONLY da tabela authtoken_token
+    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)
@@ -27,6 +50,7 @@ class SharedToken(models.Model):
     objects = models.Manager()
 
     class Meta:
+        abstract = True
         managed = False
         db_table = TOKEN_TABLE
 
@@ -36,7 +60,10 @@ class SharedToken(models.Model):
     @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
 
@@ -46,19 +73,24 @@ class SharedToken(models.Model):
         return True
 
 
-def organization_image_path(instance, filename):
-    return os.path.join(
-        "organization",
-        str(instance.pk),
-        "images",
-        filename,
-    )
-
-
-class SharedOrganization(models.Model):
+class AbstractSharedOrganization(models.Model):
     """
-    Model READ-ONLY da tabela organization
+    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
@@ -75,7 +107,8 @@ class SharedOrganization(models.Model):
     # 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()
@@ -84,7 +117,8 @@ class SharedOrganization(models.Model):
     objects = SharedOrganizationManager()
 
     class Meta:
-        managed = False  # CRITICAL: Não gera migrations
+        abstract = True
+        managed = False
         db_table = ORGANIZATION_TABLE
 
     def __str__(self):
@@ -99,8 +133,11 @@ class SharedOrganization(models.Model):
             if org.is_branch:
                 main = org.main_organization
         """
+        from .utils import get_organization_model
+        
         if self.main_organization_id:
-            return SharedOrganization.objects.get_or_fail(self.main_organization_id)
+            Organization = get_organization_model()
+            return Organization.objects.get_or_fail(self.main_organization_id)
         return None
 
     @property
@@ -111,7 +148,10 @@ class SharedOrganization(models.Model):
         Usage:
             branches = org.branches
         """
-        return SharedOrganization.objects.filter(main_organization_id=self.pk)
+        from .utils import get_organization_model
+        
+        Organization = get_organization_model()
+        return Organization.objects.filter(main_organization_id=self.pk)
 
     @property
     def members(self):
@@ -123,7 +163,10 @@ class SharedOrganization(models.Model):
             for member in members:
                 print(member.user.email)
         """
-        return SharedMember.objects.for_organization(self.pk)
+        from .utils import get_member_model
+        
+        Member = get_member_model()
+        return Member.objects.for_organization(self.pk)
 
     @property
     def users(self):
@@ -133,6 +176,9 @@ class SharedOrganization(models.Model):
         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)
         )
@@ -142,14 +188,29 @@ class SharedOrganization(models.Model):
         return self.deleted_at is None
 
 
-class User(AbstractUser):
+class AbstractUser(AbstractUser):
     """
-    Model READ-ONLY da tabela auth_user
+    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()
@@ -158,6 +219,7 @@ class User(AbstractUser):
     objects = UserManager()
 
     class Meta:
+        abstract = True
         managed = False
         db_table = USER_TABLE
 
@@ -166,8 +228,13 @@ class User(AbstractUser):
         """
         Retorna todas as organizações associadas ao usuário.
         """
-        return SharedOrganization.objects.filter(
-            id__in=SharedMember.objects.filter(user_id=self.id).values_list(
+        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
             )
         )
@@ -176,14 +243,19 @@ class User(AbstractUser):
         """
         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 = SharedOrganization.objects.get(id=organization_id)
-        except SharedOrganization.DoesNotExist:
+            organization = Organization.objects.get(id=organization_id)
+        except Organization.DoesNotExist:
             raise OrganizationNotFoundError(
                 f"Organização com ID {organization_id} não encontrada."
             )
 
-        if not SharedMember.objects.filter(
+        if not Member.objects.filter(
             user_id=self.id, organization_id=organization.id
         ).exists():
             raise OrganizationNotFoundError("Usuário não é membro desta organização.")
@@ -191,10 +263,24 @@ class User(AbstractUser):
         return organization
 
 
-class SharedMember(models.Model):
+class AbstractSharedMember(models.Model):
     """
-    Model READ-ONLY da tabela organization_member
+    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()
@@ -204,6 +290,7 @@ class SharedMember(models.Model):
     objects = SharedMemberManager()
 
     class Meta:
+        abstract = True
         managed = False
         db_table = MEMBER_TABLE
 
@@ -220,6 +307,9 @@ class SharedMember(models.Model):
             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
@@ -232,4 +322,7 @@ class SharedMember(models.Model):
             org = member.organization
             print(org.name)
         """
-        return SharedOrganization.objects.get_or_fail(self.organization_id)
+        from .utils import get_organization_model
+        
+        Organization = get_organization_model()
+        return Organization.objects.get_or_fail(self.organization_id)

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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)

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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(

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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()

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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()
 

maquinaweb_shared_auth-0.2.34/shared_auth/models.py

@@ -0,0 +1,58 @@
+"""
+Models READ-ONLY para acesso aos dados de autenticação
+ATENÇÃO: Estes models NÃO devem ser usados para criar migrations
+
+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 .abstract_models import (
+    AbstractSharedMember,
+    AbstractSharedOrganization,
+    AbstractSharedToken,
+    AbstractUser,
+)
+
+
+class SharedToken(AbstractSharedToken):
+    """
+    Model READ-ONLY padrão da tabela authtoken_token
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedToken
+    """
+    
+    class Meta(AbstractSharedToken.Meta):
+        pass
+
+
+class SharedOrganization(AbstractSharedOrganization):
+    """
+    Model READ-ONLY padrão da tabela organization
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedOrganization
+    """
+    
+    class Meta(AbstractSharedOrganization.Meta):
+        pass
+
+
+class User(AbstractUser):
+    """
+    Model READ-ONLY padrão da tabela auth_user
+    
+    Para customizar, crie seu próprio model herdando de AbstractUser
+    """
+    
+    class Meta(AbstractUser.Meta):
+        pass
+
+
+class SharedMember(AbstractSharedMember):
+    """
+    Model READ-ONLY padrão da tabela organization_member
+    
+    Para customizar, crie seu próprio model herdando de AbstractSharedMember
+    """
+    
+    class Meta(AbstractSharedMember.Meta):
+        pass

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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
 
 

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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:

{maquinaweb_shared_auth-0.2.32 → maquinaweb_shared_auth-0.2.34}/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"):

maquinaweb_shared_auth-0.2.34/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/shared_auth/__init__.py

@@ -1,6 +0,0 @@
-"""
-Biblioteca compartilhada para acesso aos models de autenticação
-"""
-
-__version__ = '1.0.0'
-default_app_config = "shared_auth.app.SharedAuthConfig"