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

oxutils/permissions/controllers.py

@@ -0,0 +1,344 @@
+from typing import List, Optional
+from django.conf import settings
+from django.http import HttpRequest
+from ninja_extra import (
+    api_controller,
+    ControllerBase,
+    http_get,
+    http_post,
+    http_put,
+    http_delete,
+    paginate,
+)
+from ninja_extra.permissions import IsAuthenticated
+from ninja_extra.pagination import PageNumberPaginationExtra, PaginatedResponseSchema
+from . import schemas
+from .models import Role, Group, RoleGrant, Grant
+from .services import PermissionService
+from .perms import access_manager
+from oxutils.exceptions import NotFoundException, ValidationException
+
+
+
+
+@api_controller(
+    "/access",
+    permissions=[
+        IsAuthenticated & access_manager('r')
+    ]
+)
+class PermissionController(ControllerBase):
+    """
+    Contrôleur pour la gestion des permissions, rôles et groupes.
+    """
+    service = PermissionService()
+
+    @http_get('/scopes', response=List[str])
+    def list_scopes(self):
+        return getattr(settings, 'ACCESS_SCOPES', [])
+
+    @http_get("/roles", response=PaginatedResponseSchema[schemas.RoleSchema])
+    @paginate(PageNumberPaginationExtra, page_size=20)
+    def list_roles(self):
+        """
+        Liste tous les rôles.
+        """
+        return self.service.get_roles()
+
+    @http_get("/roles/{role_slug}", response=schemas.RoleSchema)
+    def get_role(self, role_slug: str):
+        """
+        Récupère un rôle par son slug.
+        """
+        return self.service.get_role(role_slug)
+
+    # Groupes
+    @http_post(
+        "/groups", 
+        response=schemas.GroupSchema,
+        permissions=[
+            IsAuthenticated & access_manager('w')
+        ]
+    )
+    def create_group(self, group_data: schemas.GroupCreateSchema):
+        """
+        Crée un nouveau groupe de rôles.
+        """
+        return self.service.create_group(group_data)
+
+    @http_get(
+        "/groups", 
+        response=PaginatedResponseSchema[schemas.GroupSchema],
+    )
+    @paginate(PageNumberPaginationExtra, page_size=20)
+    def list_groups(self):
+        """
+        Liste tous les groupes de rôles.
+        """
+        return Group.objects.all()
+
+    @http_get(
+        "/groups/{group_slug}", 
+        response=schemas.GroupSchema,
+    )
+    def get_group(self, group_slug: str):
+        """
+        Récupère un groupe par son slug.
+        """
+        try:
+            return Group.objects.get(slug=group_slug)
+        except Group.DoesNotExist:
+            raise NotFoundException("Groupe non trouvé")
+
+    @http_put(
+        "/groups/{group_slug}", 
+        response=schemas.GroupSchema,
+        permissions=[
+            IsAuthenticated & access_manager('ru')
+        ]
+    )
+    def update_group(self, group_slug: str, group_data: schemas.GroupUpdateSchema):
+        """
+        Met à jour un groupe existant.
+        """
+        try:
+            group = Group.objects.get(slug=group_slug)
+            
+            # Mise à jour des champs simples
+            for field, value in group_data.dict(exclude_unset=True, exclude={"roles"}).items():
+                setattr(group, field, value)
+            
+            # Mise à jour des rôles si fournis
+            if group_data.roles is not None:
+                roles = Role.objects.filter(slug__in=group_data.roles)
+                group.roles.set(roles)
+            
+            group.save()
+            return group
+        except Group.DoesNotExist:
+            raise NotFoundException("Groupe non trouvé")
+        except Exception as e:
+            raise ValidationException(str(e))
+
+    @http_delete(
+        "/groups/{group_slug}", 
+        response={
+            "204": None
+        },
+        permissions=[
+            IsAuthenticated & access_manager('d')
+        ]
+    )
+    def delete_group(self, group_slug: str):
+        """
+        Supprime un groupe.
+        """
+        try:
+            group = Group.objects.get(slug=group_slug)
+            group.delete()
+            return None
+        except Group.DoesNotExist:
+            raise NotFoundException("Groupe non trouvé")
+
+    # Rôles des utilisateurs
+    @http_post(
+        "/users/assign-role",
+        response=schemas.RoleSchema,
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def assign_role_to_user(self, data: schemas.AssignRoleSchema, request: HttpRequest):
+        """
+        Assigne un rôle à un utilisateur.
+        """
+        return self.service.assign_role_to_user(
+            user_id=data.user_id,
+            role_slug=data.role,
+            by_user=request.user if request.user.is_authenticated else None
+        )
+
+    @http_post(
+        "/users/revoke-role", 
+        response={
+            "204": None
+        },
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def revoke_role_from_user(self, data: schemas.RevokeRoleSchema):
+        """
+        Révoque un rôle d'un utilisateur.
+        """
+        self.service.revoke_role_from_user(
+            user_id=data.user_id,
+            role_slug=data.role
+        )
+        return None
+
+    @http_post(
+        "/users/assign-group",
+        response=List[schemas.RoleSchema],
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def assign_group_to_user(self, data: schemas.AssignGroupSchema, request: HttpRequest):
+        """
+        Assigne un groupe de rôles à un utilisateur.
+        """
+        return self.service.assign_group_to_user(
+            user_id=data.user_id,
+            group_slug=data.group,
+            by_user=request.user if request.user.is_authenticated else None
+        )
+
+    @http_post(
+        "/users/revoke-group", 
+        response={
+            "204": None
+        },
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def revoke_group_from_user(self, data: schemas.RevokeGroupSchema):
+        """
+        Révoque un groupe de rôles d'un utilisateur.
+        """
+        self.service.revoke_group_from_user(
+            user_id=data.user_id,
+            group_slug=data.group
+        )
+        return None
+
+    @http_post(
+        "/groups/{group_slug}/sync", 
+        response=schemas.GroupSyncResponseSchema,
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def sync_group(self, group_slug: str):
+        """
+        Synchronise les grants de tous les utilisateurs d'un groupe.
+        À appeler après modification des RoleGrants ou des rôles du groupe.
+        """
+        return self.service.sync_group(group_slug)
+
+    # Grants
+    @http_post(
+        "/grants", 
+        response=schemas.GrantSchema,
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def create_grant(self, grant_data: schemas.GrantCreateSchema):
+        """
+        Crée une nouvelle permission personnalisée pour un utilisateur.
+        """
+        return self.service.create_grant(grant_data)
+
+    @http_get(
+        "/grants", 
+        response=PaginatedResponseSchema[schemas.GrantSchema],
+    )
+    @paginate(PageNumberPaginationExtra, page_size=20)
+    def list_grants(self, user_id: Optional[int] = None, role: Optional[str] = None):
+        """
+        Liste les grants, avec filtrage optionnel par utilisateur et/ou rôle.
+        """
+        queryset = Grant.objects.all()
+        if user_id:
+            queryset = queryset.filter(user_id=user_id)
+        if role:
+            queryset = queryset.filter(role__slug=role)
+        return queryset
+
+    @http_put(
+        "/grants/{grant_id}", 
+        response=schemas.GrantSchema,
+        permissions=[
+            IsAuthenticated & access_manager('ru')
+        ]
+    )
+    def update_grant(self, grant_id: int, grant_data: schemas.GrantUpdateSchema):
+        """
+        Met à jour une permission personnalisée.
+        """
+        return self.service.update_grant(grant_id, grant_data)
+
+    @http_delete(
+        "/grants/{grant_id}",
+        response={
+            "204": None
+        },
+        permissions=[
+            IsAuthenticated & access_manager('d')
+        ]
+    )
+    def delete_grant(self, grant_id: int):
+        """
+        Supprime une permission personnalisée.
+        """
+        self.service.delete_grant(grant_id)
+        return None
+
+    # Role Grants
+    @http_post(
+        "/role-grants", 
+        response=schemas.RoleGrantSchema,
+        permissions=[
+            IsAuthenticated & access_manager('rw')
+        ]
+    )
+    def create_role_grant(self, grant_data: schemas.RoleGrantCreateSchema):
+        """
+        Crée une nouvelle permission pour un rôle.
+        """
+        return self.service.create_role_grant(grant_data)
+
+    @http_get(
+        "/role-grants", 
+        response=PaginatedResponseSchema[schemas.RoleGrantSchema],
+    )
+    @paginate(PageNumberPaginationExtra, page_size=20)
+    def list_role_grants(self, role: Optional[str] = None):
+        """
+        Liste les permissions de rôles, avec filtrage optionnel par rôle.
+        """
+        queryset = RoleGrant.objects.select_related('role').all()
+        if role:
+            queryset = queryset.filter(role__slug=role)
+        return queryset
+
+    @http_put(
+        "/role-grants/{grant_id}", 
+        response=schemas.RoleGrantSchema,
+        permissions=[
+            IsAuthenticated & access_manager('ru')
+        ]
+    )
+    def update_role_grant(self, grant_id: int, grant_data: schemas.RoleGrantUpdateSchema):
+        """
+        Met à jour une permission de rôle.
+        """
+        return self.service.update_role_grant(grant_id, grant_data)
+
+    @http_delete(
+        "/role-grants/{grant_id}/", 
+        response={
+            "204": None
+        },
+        permissions=[
+            IsAuthenticated & access_manager('d')
+        ]
+    )
+    def delete_role_grant(self, grant_id: int):
+        """
+        Supprime une permission de rôle.
+        """
+        self.service.delete_role_grant(grant_id)
+        return None

oxutils/permissions/exceptions.py

@@ -0,0 +1,60 @@
+from django.utils.translation import gettext_lazy as _
+from oxutils.exceptions import (
+    APIException,
+    NotFoundException,
+    ValidationException,
+    DuplicateEntryException,
+    PermissionDeniedException,
+    ExceptionCode
+)
+
+
+class RoleNotFoundException(NotFoundException):
+    """Exception levée quand un rôle n'est pas trouvé."""
+    default_detail = _('Le rôle demandé n\'existe pas')
+
+
+class GroupNotFoundException(NotFoundException):
+    """Exception levée quand un groupe n'est pas trouvé."""
+    default_detail = _('Le groupe demandé n\'existe pas')
+
+
+class GrantNotFoundException(NotFoundException):
+    """Exception levée quand un grant n'est pas trouvé."""
+    default_detail = _('Le grant demandé n\'existe pas')
+
+
+class RoleGrantNotFoundException(NotFoundException):
+    """Exception levée quand un role grant n'est pas trouvé."""
+    default_detail = _('Le role grant demandé n\'existe pas')
+
+
+class RoleAlreadyAssignedException(DuplicateEntryException):
+    """Exception levée quand un rôle est déjà assigné à un utilisateur."""
+    default_detail = _('Ce rôle est déjà assigné à l\'utilisateur')
+
+
+class GroupAlreadyAssignedException(DuplicateEntryException):
+    """Exception levée quand un groupe est déjà assigné à un utilisateur."""
+    default_detail = _('Ce groupe est déjà assigné à l\'utilisateur')
+
+
+class InvalidActionsException(ValidationException):
+    """Exception levée quand des actions invalides sont fournies."""
+    default_detail = _('Les actions fournies sont invalides')
+
+
+class InsufficientPermissionsException(PermissionDeniedException):
+    """Exception levée quand l'utilisateur n'a pas les permissions suffisantes."""
+    default_code = ExceptionCode.INSUFFICIENT_PERMISSIONS
+    default_detail = _('Permissions insuffisantes pour effectuer cette action')
+
+
+class RoleGrantConflictException(DuplicateEntryException):
+    """Exception levée quand un role grant existe déjà pour ce rôle et scope."""
+    default_detail = _('Un role grant existe déjà pour ce rôle et ce scope')
+
+
+class GrantConflictException(DuplicateEntryException):
+    """Exception levée quand un grant existe déjà pour cet utilisateur et scope."""
+    default_detail = _('Un grant existe déjà pour cet utilisateur et ce scope')

oxutils/permissions/management/commands/load_permission_preset.py

@@ -0,0 +1,112 @@
+from typing import Any
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+
+from oxutils.permissions.utils import load_preset
+
+
+class Command(BaseCommand):
+    """
+    Commande de management Django pour charger un preset de permissions.
+    
+    Usage:
+        python manage.py load_permission_preset
+        python manage.py load_permission_preset --dry-run
+        python manage.py load_permission_preset --force
+        python manage.py load_permission_preset --dry-run --force
+    """
+    
+    help = "Charge un preset de permissions depuis settings.PERMISSION_PRESET"
+
+    def add_arguments(self, parser) -> None:
+        """
+        Ajoute les arguments de la commande.
+        
+        Args:
+            parser: ArgumentParser de Django
+        """
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Simule le chargement sans créer les objets en base de données',
+        )
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help='Force le chargement même si des rôles existent déjà en base',
+        )
+
+    @transaction.atomic
+    def handle(self, *args: Any, **options: Any) -> None:
+        """
+        Exécute la commande de chargement du preset.
+        
+        Args:
+            *args: Arguments positionnels
+            **options: Options de la commande
+            
+        Raises:
+            CommandError: Si le preset n'est pas défini ou est invalide
+        """
+        dry_run = options.get('dry_run', False)
+        force = options.get('force', False)
+        
+        if dry_run:
+            self.stdout.write(
+                self.style.WARNING('Mode DRY-RUN activé - Aucune modification ne sera effectuée')
+            )
+        
+        if force:
+            self.stdout.write(
+                self.style.WARNING('Mode FORCE activé - Les rôles existants seront ignorés')
+            )
+        
+        try:
+            # Charger le preset
+            self.stdout.write('Chargement du preset de permissions...')
+            
+            if dry_run:
+                # En mode dry-run, on utilise un savepoint pour rollback
+                sid = transaction.savepoint()
+            
+            stats = load_preset(force=force)
+            
+            if dry_run:
+                # Rollback en mode dry-run
+                transaction.savepoint_rollback(sid)
+            
+            # Afficher les statistiques
+            self.stdout.write(
+                self.style.SUCCESS('\n✓ Preset chargé avec succès!')
+            )
+            self.stdout.write(f"  • Rôles créés: {stats['roles']}")
+            self.stdout.write(f"  • Groupes créés: {stats['groups']}")
+            self.stdout.write(f"  • Role grants créés: {stats['role_grants']}")
+            
+            if dry_run:
+                self.stdout.write(
+                    self.style.WARNING('\nAucune modification effectuée (mode dry-run)')
+                )
+            
+        except AttributeError as e:
+            raise CommandError(
+                f"Erreur de configuration: {str(e)}\n"
+                "Assurez-vous que PERMISSION_PRESET est défini dans vos settings Django."
+            )
+        
+        except PermissionError as e:
+            raise CommandError(
+                f"{str(e)}\n"
+                "Utilisez --force pour forcer le chargement malgré les rôles existants."
+            )
+        
+        except (KeyError, ValueError) as e:
+            raise CommandError(
+                f"Erreur dans le preset: {str(e)}\n"
+                "Vérifiez la structure de votre PERMISSION_PRESET."
+            )
+        
+        except Exception as e:
+            raise CommandError(
+                f"Erreur inattendue lors du chargement du preset: {str(e)}"
+            )

oxutils/permissions/migrations/0001_initial.py

@@ -0,0 +1,112 @@
+# Generated by Django 5.2.9 on 2025-12-27 10:49
+
+import django.contrib.postgres.fields
+import django.contrib.postgres.indexes
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Role',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='Date and time when this record was created')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
+                ('slug', models.SlugField(primary_key=True, serialize=False, unique=True)),
+                ('name', models.CharField(max_length=100)),
+            ],
+            options={
+                'indexes': [models.Index(fields=['slug'], name='permissions_slug_ae4163_idx')],
+            },
+        ),
+        migrations.CreateModel(
+            name='Group',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='Date and time when this record was created')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
+                ('slug', models.SlugField(primary_key=True, serialize=False, unique=True)),
+                ('name', models.CharField(max_length=100)),
+                ('roles', models.ManyToManyField(related_name='groups', to='permissions.role')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='UserGroup',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='Date and time when this record was created')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
+                ('group', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_groups', to='permissions.group')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_groups', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Grant',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='Date and time when this record was created')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
+                ('scope', models.CharField(max_length=100)),
+                ('actions', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=5), size=None)),
+                ('context', models.JSONField(blank=True, default=dict)),
+                ('created_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='created_grants', to=settings.AUTH_USER_MODEL)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='grants', to=settings.AUTH_USER_MODEL)),
+                ('role', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='grants', to='permissions.role')),
+                ('user_group', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='grants', to='permissions.usergroup')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='RoleGrant',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('scope', models.CharField(max_length=100)),
+                ('actions', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=5), size=None)),
+                ('context', models.JSONField(blank=True, default=dict)),
+                ('group', models.ForeignKey(blank=True, help_text='Groupe optionnel pour des comportements spécifiques', null=True, on_delete=django.db.models.deletion.CASCADE, related_name='role_grants', to='permissions.group')),
+                ('role', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='grants', to='permissions.role')),
+            ],
+            options={
+                'indexes': [models.Index(fields=['role'], name='permissions_role_id_382ed4_idx'), models.Index(fields=['group'], name='permissions_group_i_465f8d_idx'), models.Index(fields=['role', 'group'], name='permissions_role_id_0818de_idx')],
+                'constraints': [models.UniqueConstraint(fields=('role', 'scope', 'group'), name='unique_role_scope_group')],
+            },
+        ),
+        migrations.AddIndex(
+            model_name='usergroup',
+            index=models.Index(fields=['user', 'group'], name='permissions_user_id_f1ff5d_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='usergroup',
+            constraint=models.UniqueConstraint(fields=('user', 'group'), name='unique_user_group'),
+        ),
+        migrations.AddIndex(
+            model_name='grant',
+            index=models.Index(fields=['user', 'scope'], name='permissions_user_id_8a615b_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grant',
+            index=models.Index(fields=['user_group'], name='permissions_user_gr_ec61ff_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grant',
+            index=django.contrib.postgres.indexes.GinIndex(fields=['actions'], name='permissions_actions_541150_gin'),
+        ),
+        migrations.AddIndex(
+            model_name='grant',
+            index=django.contrib.postgres.indexes.GinIndex(fields=['context'], name='permissions_context_7b1c0e_gin'),
+        ),
+        migrations.AddConstraint(
+            model_name='grant',
+            constraint=models.UniqueConstraint(fields=('user', 'scope', 'role', 'user_group'), name='unique_user_scope_role'),
+        ),
+    ]

oxutils/permissions/migrations/0002_alter_grant_role.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.9 on 2025-12-29 09:04
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('permissions', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='grant',
+            name='role',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='user_grants', to='permissions.role'),
+        ),
+    ]

oxutils/permissions/migrations/0003_alter_grant_options_alter_group_options_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 5.2.9 on 2025-12-29 13:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('permissions', '0002_alter_grant_role'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='grant',
+            options={'ordering': ['scope']},
+        ),
+        migrations.AlterModelOptions(
+            name='group',
+            options={'ordering': ['slug']},
+        ),
+        migrations.AlterModelOptions(
+            name='role',
+            options={'ordering': ['slug']},
+        ),
+        migrations.AlterModelOptions(
+            name='rolegrant',
+            options={'ordering': ['role__slug', 'group__slug']},
+        ),
+        migrations.AddIndex(
+            model_name='group',
+            index=models.Index(fields=['slug'], name='permissions_slug_ed0901_idx'),
+        ),
+    ]