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

shared_auth/permissions.py

@@ -0,0 +1,266 @@
+"""
+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):
+    """
+    Verifica se usuário está autenticado via SharedToken
+    """
+
+    message = "Autenticação necessária."
+
+    def has_permission(self, request, view):
+        return bool(
+            request.user and hasattr(request.user, "pk") and request.user.is_active
+        )
+
+
+class HasActiveOrganization(permissions.BasePermission):
+    """
+    Verifica se usuário tem organização ativa
+    """
+
+    message = "Organização ativa necessária."
+
+    def has_permission(self, request, view):
+        if not request.user or not hasattr(request, "organization_id"):
+            return False
+
+        if not request.organization_id:
+            return False
+
+        # Verificar se organização está ativa
+        Organization = get_organization_model()
+
+        try:
+            org = Organization.objects.get(pk=request.organization_id)
+            return org.is_active()
+        except Organization.DoesNotExist:
+            return False
+
+
+class IsSameOrganization(permissions.BasePermission):
+    """
+    Verifica se o objeto pertence à mesma organização do usuário
+
+    O model deve ter organization_id
+    """
+
+    message = "Você não tem permissão para acessar este recurso."
+
+    def has_object_permission(self, request, view, obj):
+        if not hasattr(request, "organization_id"):
+            return False
+
+        if not hasattr(obj, "organization_id"):
+            return True  # Se objeto não tem org, permite
+
+        # Verifica se o usuário é membro da organização do objeto
+        if not get_member(request.user.pk, obj.organization_id):
+            return False
+
+        return obj.organization_id == request.organization_id
+
+
+class IsOwnerOrSameOrganization(permissions.BasePermission):
+    """
+    Verifica se é o dono do objeto OU da mesma organização
+
+    O model deve ter user_id e/ou organization_id
+    """
+
+    message = "Você não tem permissão para acessar este recurso."
+
+    def has_object_permission(self, request, view, obj):
+        # Verificar se é o dono
+        if hasattr(obj, "user_id") and obj.user_id == request.user.pk:
+            return True
+
+        # Verificar se é da mesma organização
+        if hasattr(obj, "organization_id") and hasattr(request, "organization_id"):
+            # Verifica se o usuário é membro da organização do objeto
+            if get_member(request.user.pk, obj.organization_id):
+                return obj.organization_id == request.organization_id
+
+        return False
+
+
+class HasSystemPermission(permissions.BasePermission):
+    """
+    Verifica se usuário tem permissão específica no sistema.
+    
+    Usage:
+        class MyViewSet(viewsets.ModelViewSet):
+            permission_classes = [HasSystemPermission]
+            required_permission = 'create_invoices'
+    """
+    
+    message = "Você não tem permissão para realizar esta ação."
+    
+    def has_permission(self, request, view):
+        """Verifica permissão no nível da view"""
+        from django.conf import settings
+        from shared_auth.permissions_helpers import user_has_permission
+        
+        # Pegar permissão requerida
+        permission_codename = getattr(view, 'required_permission', None)
+        
+        if not permission_codename:
+            # Se não tem permissão definida, permite
+            return True
+        
+        # Verificar autenticação
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        # Pegar organização
+        organization_id = getattr(request, 'organization_id', None)
+        if not organization_id:
+            return False
+        
+        # Pegar sistema
+        system_id = getattr(settings, 'SYSTEM_ID', None)
+        if not system_id:
+            # Tentar pegar do header
+            header_value = request.headers.get('X-System-ID')
+            if header_value:
+                try:
+                    system_id = int(header_value)
+                except (ValueError, TypeError):
+                    return False
+            else:
+                return False
+        
+        # Verificar permissão
+        return user_has_permission(
+            request.user.id,
+            organization_id,
+            permission_codename,
+            system_id,
+            request=request
+        )
+
+
+class HasAnyPermission(permissions.BasePermission):
+    """
+    Verifica se usuário tem pelo menos uma das permissões.
+    
+    Usage:
+        class MyViewSet(viewsets.ModelViewSet):
+            permission_classes = [HasAnyPermission]
+            required_permissions = ['view_reports', 'create_reports']
+    """
+    
+    message = "Você não tem nenhuma das permissões necessárias."
+    
+    def has_permission(self, request, view):
+        """Verifica se tem pelo menos uma permissão"""
+        from django.conf import settings
+        from shared_auth.permissions_helpers import user_has_permission
+        
+        # Pegar permissões requeridas
+        permission_codenames = getattr(view, 'required_permissions', [])
+        
+        if not permission_codenames:
+            # Se não tem permissões definidas, permite
+            return True
+        
+        # Verificar autenticação
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        # Pegar organização
+        organization_id = getattr(request, 'organization_id', None)
+        if not organization_id:
+            return False
+        
+        # Pegar sistema
+        system_id = getattr(settings, 'SYSTEM_ID', None)
+        if not system_id:
+            # Tentar pegar do header
+            header_value = request.headers.get('X-System-ID')
+            if header_value:
+                try:
+                    system_id = int(header_value)
+                except (ValueError, TypeError):
+                    return False
+            else:
+                return False
+        
+        # Verificar se tem pelo menos uma permissão
+        return any(
+            user_has_permission(
+                request.user.id,
+                organization_id,
+                perm,
+                system_id,
+                request=request
+            )
+            for perm in permission_codenames
+        )
+
+
+class HasAllPermissions(permissions.BasePermission):
+    """
+    Verifica se usuário tem todas as permissões.
+    
+    Usage:
+        class MyViewSet(viewsets.ModelViewSet):
+            permission_classes = [HasAllPermissions]
+            required_permissions = ['create_invoices', 'edit_invoices']
+    """
+    
+    message = "Você não tem todas as permissões necessárias."
+    
+    def has_permission(self, request, view):
+        """Verifica se tem todas as permissões"""
+        from django.conf import settings
+        from shared_auth.permissions_helpers import user_has_permission
+        
+        # Pegar permissões requeridas
+        permission_codenames = getattr(view, 'required_permissions', [])
+        
+        if not permission_codenames:
+            # Se não tem permissões definidas, permite
+            return True
+        
+        # Verificar autenticação
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        # Pegar organização
+        organization_id = getattr(request, 'organization_id', None)
+        if not organization_id:
+            return False
+        
+        # Pegar sistema
+        system_id = getattr(settings, 'SYSTEM_ID', None)
+        if not system_id:
+            # Tentar pegar do header
+            header_value = request.headers.get('X-System-ID')
+            if header_value:
+                try:
+                    system_id = int(header_value)
+                except (ValueError, TypeError):
+                    return False
+            else:
+                return False
+        
+        # Verificar se tem todas as permissões
+        return all(
+            user_has_permission(
+                request.user.id,
+                organization_id,
+                perm,
+                system_id,
+                request=request
+            )
+            for perm in permission_codenames
+        )
+

shared_auth/permissions_cache.py

@@ -0,0 +1,249 @@
+"""
+Sistema de cache de permissões por request.
+Elimina queries duplicadas durante verificação de permissões.
+"""
+
+from threading import local
+
+# Thread-local storage para cache quando não há request disponível
+_thread_local = local()
+
+
+def _get_cache_dict(request=None):
+    """
+    Obtém o dicionário de cache de permissões.
+    
+    Args:
+        request: Request object (opcional)
+        
+    Returns:
+        dict: Dicionário de cache
+    """
+    if request and hasattr(request, '_permissions_cache'):
+        return request._permissions_cache
+    
+    # Fallback para thread-local (útil em contextos sem request)
+    if not hasattr(_thread_local, 'permissions_cache'):
+        _thread_local.permissions_cache = {}
+    return _thread_local.permissions_cache
+
+
+def get_cached_member(user_id, organization_id, request=None):
+    """
+    Busca e cacheia Member para o par (user_id, organization_id).
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        request: Request object (opcional)
+        
+    Returns:
+        Member instance ou None
+    """
+    from .utils import get_member_model
+    
+    cache = _get_cache_dict(request)
+    cache_key = f'member_{user_id}_{organization_id}'
+    
+    if cache_key in cache:
+        return cache[cache_key]
+    
+    Member = get_member_model()
+    member = Member.objects.filter(
+        user_id=user_id,
+        organization_id=organization_id
+    ).first()
+    
+    cache[cache_key] = member
+    return member
+
+
+def get_cached_member_group(member_id, system_id, request=None):
+    """
+    Busca e cacheia MemberSystemGroup para o par (member_id, system_id).
+    
+    Args:
+        member_id: ID do membro
+        system_id: ID do sistema
+        request: Request object (opcional)
+        
+    Returns:
+        MemberSystemGroup instance ou None
+    """
+    from .utils import get_member_system_group_model
+    
+    cache = _get_cache_dict(request)
+    cache_key = f'member_group_{member_id}_{system_id}'
+    
+    if cache_key in cache:
+        return cache[cache_key]
+    
+    MemberSystemGroup = get_member_system_group_model()
+    member_group = MemberSystemGroup.objects.get_group_for_member_and_system(
+        member_id,
+        system_id
+    )
+    
+    cache[cache_key] = member_group
+    return member_group
+
+
+def get_cached_group_permissions(group_id, system_id, request=None):
+    """
+    Busca e cacheia GroupOrganizationPermissions com suas permissões.
+    
+    Args:
+        group_id: ID do grupo de permissões
+        system_id: ID do sistema
+        request: Request object (opcional)
+        
+    Returns:
+        GroupOrganizationPermissions instance ou None
+    """
+    from .utils import get_group_organization_permissions_model
+    
+    cache = _get_cache_dict(request)
+    cache_key = f'group_perms_{group_id}_{system_id}'
+    
+    if cache_key in cache:
+        return cache[cache_key]
+    
+    GroupOrgPermissions = get_group_organization_permissions_model()
+    try:
+        # Busca o grupo sem prefetch ainda
+        group = GroupOrgPermissions.objects.get(pk=group_id)
+    except GroupOrgPermissions.DoesNotExist:
+        cache[cache_key] = None
+        return None
+    
+    cache[cache_key] = group
+    return group
+
+
+def get_cached_permission_codenames(group_id, system_id, request=None):
+    """
+    Busca e cacheia SET de codenames de permissões do grupo.
+    
+    Args:
+        group_id: ID do grupo de permissões
+        system_id: ID do sistema
+        request: Request object (opcional)
+        
+    Returns:
+        set: Set de codenames de permissões
+    """
+    cache = _get_cache_dict(request)
+    cache_key = f'perm_codenames_{group_id}_{system_id}'
+    
+    if cache_key in cache:
+        return cache[cache_key]
+    
+    group = get_cached_group_permissions(group_id, system_id, request)
+    if not group:
+        cache[cache_key] = set()
+        return set()
+    
+    # Buscar todos os codenames de uma vez
+    codenames = set(
+        group.permissions.filter(system_id=system_id)
+        .values_list('codename', flat=True)
+    )
+    
+    cache[cache_key] = codenames
+    return codenames
+
+
+def get_cached_all_permissions(group_id, system_id, request=None):
+    """
+    Busca e cacheia lista de Permission objects do grupo.
+    
+    Args:
+        group_id: ID do grupo de permissões
+        system_id: ID do sistema
+        request: Request object (opcional)
+        
+    Returns:
+        list: Lista de Permission objects
+    """
+    cache = _get_cache_dict(request)
+    cache_key = f'all_perms_{group_id}_{system_id}'
+    
+    if cache_key in cache:
+        return cache[cache_key]
+    
+    group = get_cached_group_permissions(group_id, system_id, request)
+    if not group:
+        cache[cache_key] = []
+        return []
+    
+    # Buscar todas as permissões de uma vez e converter para lista
+    permissions = list(group.permissions.filter(system_id=system_id))
+    
+    cache[cache_key] = permissions
+    return permissions
+
+
+def warmup_permissions_cache(user_id, organization_id, system_id, request=None):
+    """
+    Pré-carrega (warm-up) todas as permissões do usuário no cache.
+    Reduz 4 queries para apenas as necessárias no início da request.
+    
+    Esta função deve ser chamada pelo middleware após autenticação.
+    
+    Args:
+        user_id: ID do usuário
+        organization_id: ID da organização
+        system_id: ID do sistema
+        request: Request object
+        
+    Returns:
+        bool: True se conseguiu fazer warm-up, False caso contrário
+    """
+    # 1. Buscar e cachear member
+    member = get_cached_member(user_id, organization_id, request)
+    if not member:
+        return False
+    
+    # 2. Buscar e cachear member group
+    member_group = get_cached_member_group(member.id, system_id, request)
+    if not member_group:
+        return False
+    
+    # 3. Buscar e cachear group permissions
+    group = get_cached_group_permissions(member_group.group_id, system_id, request)
+    if not group:
+        return False
+    
+    # 4. OTIMIZAÇÃO PRINCIPAL: Carregar TODAS as permissões e codenames de uma vez
+    # Isso faz com que verificações subsequentes sejam O(1) em memória
+    get_cached_permission_codenames(member_group.group_id, system_id, request)
+    get_cached_all_permissions(member_group.group_id, system_id, request)
+    
+    return True
+
+
+def clear_permissions_cache(request=None):
+    """
+    Limpa o cache de permissões.
+    Útil para testes ou quando necessário forçar reload.
+    
+    Args:
+        request: Request object (opcional)
+    """
+    if request and hasattr(request, '_permissions_cache'):
+        request._permissions_cache.clear()
+    
+    if hasattr(_thread_local, 'permissions_cache'):
+        _thread_local.permissions_cache.clear()
+
+
+def init_permissions_cache(request):
+    """
+    Inicializa o cache de permissões no request.
+    Chamado pelo middleware no início de cada request.
+    
+    Args:
+        request: Request object
+    """
+    if not hasattr(request, '_permissions_cache'):
+        request._permissions_cache = {}