maquinaweb-shared-auth 0.2.60__py3-none-any.whl

shared_auth/permissions_helpers.py

@@ -0,0 +1,251 @@
+"""
+Helper functions para checagem e listagem de permissões
+Funções principais para o sistema de permissões multi-sistema
+"""
+
+
+def user_has_permission(user_id, organization_id, permission_codename, system_id, request=None):
+    """
+    Verifica se um usuário tem uma permissão específica.
+    
+    OTIMIZADO: Usa cache por request para eliminar queries duplicadas.
+    
+    Fluxo:
+    1. Busca Member (user + organization) - COM CACHE
+    2. Busca MemberSystemGroup (member + system) - COM CACHE
+    3. Busca GroupOrganizationPermissions - COM CACHE
+    4. Verifica se permission_codename está no grupo - COM CACHE
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        permission_codename: Código da permissão (ex: 'create_invoices')
+        system_id: ID do sistema
+        request: Request object (opcional, para cache)
+    
+    Returns:
+        bool: True se usuário tem a permissão, False caso contrário
+    
+    Usage:
+        from shared_auth.permissions_helpers import user_has_permission
+        
+        if user_has_permission(5, 1, 'create_invoices', 2, request):
+            # Usuário pode criar faturas
+            pass
+    """
+    from .permissions_cache import (
+        get_cached_member,
+        get_cached_member_group,
+        get_cached_permission_codenames,
+    )
+    
+    # 1. Buscar membro (COM CACHE)
+    member = get_cached_member(user_id, organization_id, request)
+    if not member:
+        return False
+    
+    # 2. Buscar grupo do membro no sistema (COM CACHE)
+    member_group = get_cached_member_group(member.id, system_id, request)
+    if not member_group:
+        return False
+    
+    # 3. Buscar codenames de permissões do grupo (COM CACHE)
+    codenames = get_cached_permission_codenames(member_group.group_id, system_id, request)
+    
+    # 4. Verificar se permissão está no set (O(1) lookup)
+    return permission_codename in codenames
+
+
+def get_user_permissions(user_id, organization_id, system_id, request=None):
+    """
+    Retorna todas as permissões do usuário em um sistema.
+    
+    OTIMIZADO: Usa cache por request para eliminar queries duplicadas.
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        system_id: ID do sistema
+        request: Request object (opcional, para cache)
+    
+    Returns:
+        list[Permission]: Lista de permissões do usuário
+    
+    Usage:
+        from shared_auth.permissions_helpers import get_user_permissions
+        
+        perms = get_user_permissions(5, 1, 2, request)
+        for perm in perms:
+            print(perm.codename)
+    """
+    from .permissions_cache import (
+        get_cached_all_permissions,
+        get_cached_member,
+        get_cached_member_group,
+    )
+    
+    # 1. Buscar membro (COM CACHE)
+    member = get_cached_member(user_id, organization_id, request)
+    if not member:
+        return []
+    
+    # 2. Buscar grupo do membro no sistema (COM CACHE)
+    member_group = get_cached_member_group(member.id, system_id, request)
+    if not member_group:
+        return []
+    
+    # 3. Buscar todas as permissões (COM CACHE)
+    return get_cached_all_permissions(member_group.group_id, system_id, request)
+
+
+def get_user_permission_codenames(user_id, organization_id, system_id, request=None):
+    """
+    Retorna lista de codenames de permissões do usuário.
+    
+    OTIMIZADO: Usa cache por request.
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        system_id: ID do sistema
+        request: Request object (opcional, para cache)
+    
+    Returns:
+        List[str]: Lista de codenames
+    
+    Usage:
+        from shared_auth.permissions_helpers import get_user_permission_codenames
+        
+        codenames = get_user_permission_codenames(5, 1, 2, request)
+        # ['create_invoices', 'edit_invoices', 'view_reports']
+    """
+    permissions = get_user_permissions(user_id, organization_id, system_id, request)
+    return [perm.codename for perm in permissions]
+
+
+def get_organization_permissions(organization_id, system_id):
+    """
+    Retorna permissões disponíveis no plano da organização.
+    
+    Fluxo:
+    1. Busca Subscription ativa
+    2. Busca Plan
+    3. Retorna permissões dos GroupPermissions do plano
+    
+    Args:
+        organization_id: ID da organização
+        system_id: ID do sistema
+    
+    Returns:
+        QuerySet[Permission]: Permissões do plano
+    
+    Usage:
+        from shared_auth.permissions_helpers import get_organization_permissions
+        
+        perms = get_organization_permissions(1, 2)
+        for perm in perms:
+            print(perm.codename)
+    """
+    from .utils import get_permission_model, get_subscription_model
+    
+    Permission = get_permission_model()
+    
+    # 1. Buscar assinatura ativa
+    Subscription = get_subscription_model()
+    subscription = Subscription.objects.valid_for_organization_and_system(
+        organization_id,
+        system_id
+    )
+    
+    if not subscription:
+        return Permission.objects.none()
+    
+    # 2. Buscar plano
+    plan = subscription.plan
+    if not plan:
+        return Permission.objects.none()
+    
+    # 3. Buscar grupos de permissões do plano
+    group_permissions = plan.group_permissions.all()
+    
+    # 4. Coletar todas as permissões dos grupos
+    permission_ids = []
+    for group in group_permissions:
+        permission_ids.extend(
+            group.permissions.values_list('id', flat=True)
+        )
+    
+    # 5. Retornar permissões únicas
+    return Permission.objects.filter(id__in=set(permission_ids))
+
+
+def get_organization_permission_codenames(organization_id, system_id):
+    """
+    Retorna lista de codenames de permissões do plano da organização.
+    
+    Args:
+        organization_id: ID da organização
+        system_id: ID do sistema
+    
+    Returns:
+        List[str]: Lista de codenames
+    
+    Usage:
+        from shared_auth.permissions_helpers import get_organization_permission_codenames
+        
+        codenames = get_organization_permission_codenames(1, 2)
+    """
+    permissions = get_organization_permissions(organization_id, system_id)
+    return list(permissions.values_list('codename', flat=True))
+
+
+def user_has_any_permission(user_id, organization_id, permission_codenames, system_id):
+    """
+    Verifica se usuário tem pelo menos uma das permissões.
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        permission_codenames: Lista de codenames
+        system_id: ID do sistema
+    
+    Returns:
+        bool: True se tem pelo menos uma permissão
+    
+    Usage:
+        from shared_auth.permissions_helpers import user_has_any_permission
+        
+        if user_has_any_permission(5, 1, ['view_reports', 'create_reports'], 2):
+            # Usuário pode ver ou criar relatórios
+            pass
+    """
+    for codename in permission_codenames:
+        if user_has_permission(user_id, organization_id, codename, system_id):
+            return True
+    return False
+
+
+def user_has_all_permissions(user_id, organization_id, permission_codenames, system_id):
+    """
+    Verifica se usuário tem todas as permissões.
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        permission_codenames: Lista de codenames
+        system_id: ID do sistema
+    
+    Returns:
+        bool: True se tem todas as permissões
+    
+    Usage:
+        from shared_auth.permissions_helpers import user_has_all_permissions
+        
+        if user_has_all_permissions(5, 1, ['create_invoices', 'edit_invoices'], 2):
+            # Usuário pode criar E editar faturas
+            pass
+    """
+    for codename in permission_codenames:
+        if not user_has_permission(user_id, organization_id, codename, system_id):
+            return False
+    return True

shared_auth/router.py

@@ -0,0 +1,22 @@
+class SharedAuthRouter:
+    """
+    Direciona queries dos models compartilhados para o banco correto
+    """
+
+    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:
+            return "auth_db"
+        return None
+
+    def db_for_write(self, model, **hints):
+        if model._meta.app_label in self.route_app_labels:
+            return "auth_db"
+        return None
+
+    def allow_migrate(self, db, app_label, model_name=None, **hints):
+        """Bloqueia migrations"""
+        if app_label in self.route_app_labels:
+            return False
+        return None

shared_auth/serializers.py

@@ -0,0 +1,439 @@
+"""
+Serializers compartilhados para DRF
+
+Separação de responsabilidades:
+- CreateSerializerMixin: apenas para criação (seta IDs do request)
+- SerializerMixin: listagem com dados aninhados + criação (compatibilidade com código existente)
+
+Se quiser usar separadamente:
+- Use apenas *CreateSerializerMixin para create
+- Use apenas *SerializerMixin para listagem
+- Ou herde ambos se precisar
+"""
+
+from rest_framework import serializers
+
+from .utils import get_organization_model, get_organization_serializer, get_user_model
+
+
+class OrganizationCreateSerializerMixin(serializers.ModelSerializer):
+    """
+    Mixin APENAS para criação.
+    Automaticamente seta organization_id no create a partir do request context.
+
+    Usage:
+        class RascunhoCreateSerializer(OrganizationCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                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(
+            self.context["request"], "organization_id"
+        ):
+            validated_data["organization_id"] = self.context["request"].organization_id
+        return super().create(validated_data)
+
+
+class OrganizationSerializerMixin(serializers.ModelSerializer):
+    """
+    Mixin para serializers que incluem dados de organização como objeto aninhado
+    e automaticamente setam organization_id no create a partir do request context.
+
+    Retorna:
+        {
+            "id": 1,
+            "titulo": "Teste",
+            "organization": {
+                "id": 123,
+                "name": "Empresa XYZ",
+                "cnpj": "12.345.678/0001-90",
+                "email": "contato@xyz.com",
+                "is_active": true
+            }
+        }
+
+    Usage:
+        class RascunhoSerializer(OrganizationSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+
+        # Ou apenas para listagem (sem create):
+        class RascunhoListSerializer(OrganizationSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+
+        # Ou combinar com create:
+        class RascunhoFullSerializer(OrganizationSerializerMixin, OrganizationCreateSerializerMixin):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+    """
+
+    organization = serializers.SerializerMethodField()
+
+    def get_organization(self, obj):
+        req = self.context.get("request")
+        org = getattr(req, "_orgs_dict", {}).get(obj.organization_id) if req else None
+        if org:
+            return self._serialize_org(org)
+        return self._serialize_org(obj.organization)
+
+    def _serialize_org(self, org):
+        return {
+            "id": org.pk,
+            "name": org.name,
+            "fantasy_name": org.fantasy_name,
+            "image_organization": org.image_organization.url
+            if org.image_organization
+            else None,
+            "cnpj": org.cnpj,
+            "email": org.email,
+            "telephone": org.telephone,
+            "cellphone": org.cellphone,
+            "is_branch": org.is_branch,
+            "is_active": org.is_active(),
+        }
+
+
+class OrganizationListCreateSerializerMixin(
+    OrganizationSerializerMixin, OrganizationCreateSerializerMixin
+):
+    """
+    Mixin COMPLETO pronto para usar: listagem + criação.
+    Combina OrganizationSerializerMixin + OrganizationCreateSerializerMixin.
+
+    Usage:
+        class RascunhoSerializer(OrganizationListCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+    """
+
+    pass
+
+
+class OrganizationSerializer(get_organization_serializer()):
+    """
+    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 = None  # Será definido dinamicamente no __init__
+        fields = "__all__"
+
+
+class UserCreateSerializerMixin(serializers.ModelSerializer):
+    """
+    Mixin APENAS para criação.
+    Automaticamente seta user_id no create a partir do request context.
+
+    Usage:
+        class RascunhoCreateSerializer(UserCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                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"):
+            validated_data["user_id"] = self.context["request"].user.id
+        return super().create(validated_data)
+
+
+class UserSerializerMixin(serializers.ModelSerializer):
+    """
+    Mixin para serializers que incluem dados de usuário como objeto aninhado
+    e automaticamente setam user_id no create a partir do request context.
+
+    Retorna:
+        {
+            "id": 1,
+            "titulo": "Teste",
+            "user": {
+                "id": 456,
+                "username": "joao",
+                "email": "joao@xyz.com",
+                "full_name": "João Silva",
+                "is_active": true
+            }
+        }
+
+    Usage:
+        class RascunhoSerializer(UserSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+
+        # Ou apenas para listagem (sem create):
+        class RascunhoListSerializer(UserSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+
+        # Ou combinar com create:
+        class RascunhoFullSerializer(UserSerializerMixin, UserCreateSerializerMixin):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+    """
+
+    user = serializers.SerializerMethodField()
+
+    def get_user(self, obj):
+        """Retorna dados do usuário como objeto"""
+        try:
+            user = obj.user
+            return {
+                "id": user.pk,
+                "username": user.username,
+                "email": user.email,
+                "avatar": user.avatar.url if user.avatar else None,
+                "first_name": user.first_name,
+                "last_name": user.last_name,
+                "full_name": user.get_full_name(),
+                "is_active": user.is_active,
+            }
+        except Exception:
+            return None
+
+
+class UserListCreateSerializerMixin(UserSerializerMixin, UserCreateSerializerMixin):
+    """
+    Mixin COMPLETO pronto para usar: listagem + criação.
+    Combina UserSerializerMixin + UserCreateSerializerMixin.
+
+    Usage:
+        class RascunhoSerializer(UserListCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+    """
+
+    pass
+
+
+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 = None  # Será definido dinamicamente no __init__
+        fields = [
+            "id",
+            "username",
+            "first_name",
+            "last_name",
+            "email",
+            "is_active",
+            "is_staff",
+            "is_superuser",
+            "date_joined",
+            "last_login",
+        ]
+
+
+class OrganizationUserCreateSerializerMixin(serializers.ModelSerializer):
+    """
+    Mixin APENAS para criação com organization + user.
+    Automaticamente seta organization_id e user_id no create a partir do request context.
+
+    Usage:
+        class RascunhoCreateSerializer(OrganizationUserCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                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"):
+            request = self.context["request"]
+            if hasattr(request, "organization_id"):
+                validated_data["organization_id"] = request.organization_id
+            if hasattr(request, "user"):
+                validated_data["user_id"] = request.user.id
+        return super().create(validated_data)
+
+
+class OrganizationUserSerializerMixin(OrganizationSerializerMixin, UserSerializerMixin):
+    """
+    Mixin combinado com organization e user como objetos aninhados
+    e automaticamente seta organization_id e user_id no create a partir do request context.
+
+    Retorna:
+        {
+            "id": 1,
+            "titulo": "Teste",
+            "organization": {
+                "id": 123,
+                "name": "Empresa XYZ",
+                ...
+            },
+            "user": {
+                "id": 456,
+                "username": "joao",
+                ...
+            }
+        }
+
+    Usage:
+        class RascunhoSerializer(OrganizationUserSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'conteudo', 'organization', 'user']
+
+        # Ou apenas para listagem (sem create):
+        class RascunhoListSerializer(OrganizationUserSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization', 'user']
+
+        # Ou combinar com create:
+        class RascunhoFullSerializer(OrganizationUserSerializerMixin, OrganizationUserCreateSerializerMixin):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization', 'user']
+    """
+
+    pass
+
+
+class OrganizationUserListCreateSerializerMixin(
+    OrganizationUserSerializerMixin, OrganizationUserCreateSerializerMixin
+):
+    """
+    Mixin COMPLETO pronto para usar: listagem + criação com organization + user.
+    Combina OrganizationUserSerializerMixin + OrganizationUserCreateSerializerMixin.
+
+    Usage:
+        class RascunhoSerializer(OrganizationUserListCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization', 'user']
+    """
+
+    pass
+
+
+class OrganizationSimpleSerializerMixin(serializers.ModelSerializer):
+    """
+    Versão simplificada que retorna apenas campos essenciais da organização
+    e automaticamente seta organization_id no create a partir do request context.
+
+    Usage:
+        # Para listagem:
+        class RascunhoListSerializer(OrganizationSimpleSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+
+        # Para criar com organization:
+        class RascunhoCreateSerializer(OrganizationSimpleSerializerMixin, OrganizationCreateSerializerMixin):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+    """
+
+    organization = serializers.SerializerMethodField()
+
+    def get_organization(self, obj):
+        try:
+            org = obj.organization
+            return {
+                "id": org.pk,
+                "name": org.name,
+                "cnpj": org.cnpj,
+            }
+        except Exception:
+            return None
+
+
+class OrganizationSimpleListCreateSerializerMixin(
+    OrganizationSimpleSerializerMixin, OrganizationCreateSerializerMixin
+):
+    """
+    Versão simplificada COMPLETA pronta para usar: listagem + criação.
+    Retorna apenas campos essenciais da organização.
+
+    Usage:
+        class RascunhoSerializer(OrganizationSimpleListCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'organization']
+    """
+
+    pass
+
+
+class UserSimpleSerializerMixin(serializers.ModelSerializer):
+    """
+    Versão simplificada que retorna apenas campos essenciais do usuário
+    e automaticamente seta user_id no create a partir do request context.
+
+    Usage:
+        # Para listagem:
+        class RascunhoListSerializer(UserSimpleSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+
+        # Para criar com user:
+        class RascunhoCreateSerializer(UserSimpleSerializerMixin, UserCreateSerializerMixin):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+    """
+
+    user = serializers.SerializerMethodField()
+
+    def get_user(self, obj):
+        try:
+            user = obj.user
+            return {
+                "id": user.pk,
+                "email": user.email,
+                "full_name": user.get_full_name(),
+            }
+        except Exception:
+            return None
+
+
+class UserSimpleListCreateSerializerMixin(
+    UserSimpleSerializerMixin, UserCreateSerializerMixin
+):
+    """
+    Versão simplificada COMPLETA pronta para usar: listagem + criação.
+    Retorna apenas campos essenciais do usuário.
+
+    Usage:
+        class RascunhoSerializer(UserSimpleListCreateSerializerMixin, serializers.ModelSerializer):
+            class Meta:
+                model = Rascunho
+                fields = ['id', 'titulo', 'user']
+    """
+
+    pass