fastapi-forge-cli 0.1.0__py3-none-any.whl

fastapi_forge/templates/with_rbac/app/api/v1/users/repository.py

@@ -0,0 +1,181 @@
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy import and_, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.db.models import Permission, Role, User
+from app.helper.pagination_helper import apply_pagination
+from app.helper.search import text_search_filter
+from app.repositories.base import BaseRepository
+from app.helper.sorting import sort_expressions
+
+from .schema import Permission as PermissionSchema
+
+
+class UserRepository(BaseRepository[User]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(User, session)
+
+    async def get_by_email(self, email: str) -> Optional[User]:
+        return await self.get_by_field("email", email.lower())
+
+    async def get_by_username(self, username: str) -> Optional[User]:
+        return await self.get_by_field("username", username.lower())
+
+    async def get_with_permissions(
+        self,
+        user_id: UUID,
+    ) -> Optional[User]:
+        q = (
+            select(User)
+            .where(
+                User.id == user_id,
+                User.is_deleted == False,
+                User.is_active == True,
+            )
+            .options(
+                selectinload(User.roles).selectinload(Role.permissions),
+                selectinload(User.extra_permissions),
+            )
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def get_all_with_permissions(
+        self,
+        page: int,
+        page_size: int,
+        pagination: bool = True,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> tuple[list[User], int]:
+        order = sort_expressions(User, sort_by, sort_order, (User.created_at.desc(),))
+        q = (
+            select(User)
+            .where(
+                User.is_deleted == False,
+                User.is_active == True,
+            )
+            .options(
+                selectinload(User.roles).selectinload(Role.permissions),
+                selectinload(User.extra_permissions),
+            )
+            .order_by(*order)
+        )
+        search_filter = text_search_filter(
+            User,
+            search,
+            [User.email, User.username, User.full_name],
+        )
+        if search_filter is not None:
+            q = q.where(search_filter)
+        count_q = select(func.count()).select_from(q.subquery())
+        total = (await self.session.execute(count_q)).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+        result = await self.session.execute(q)
+        return list(result.scalars().all()), total
+
+    async def exists_for_other_user(
+        self, field: str, value: str, user_id: UUID
+    ) -> bool:
+        q = select(User).where(
+            and_(
+                getattr(User, field) == value,
+                User.id != user_id,
+                User.is_deleted == False,
+            )
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none() is not None
+
+    def collect_permissions(self, user: User) -> list[PermissionSchema]:
+        permissions: dict[UUID, PermissionSchema] = {}
+        for permission in self.collect_role_permissions(user):
+            permissions[permission.id] = permission
+        for permission in self.collect_extra_permissions(user):
+            permissions[permission.id] = permission
+        role = self.get_role(user)
+        if user.is_superuser or (role and role.name.upper() == "SUPER ADMIN"):
+            permissions[UUID("00000000-0000-0000-0000-000000000000")] = (
+                PermissionSchema(
+                    id=UUID("00000000-0000-0000-0000-000000000000"),
+                    code="*",
+                )
+            )
+        return sorted(
+            permissions.values(),
+            key=lambda permission: str(permission.id),
+        )
+
+    def get_role(self, user: User) -> Role | None:
+        for role in user.roles:
+            if not role.is_deleted and role.is_active:
+                return role
+        return None
+
+    def collect_role_permissions(self, user: User) -> list[PermissionSchema]:
+        role = self.get_role(user)
+        if not role:
+            return []
+
+        permissions = [
+            PermissionSchema(
+                id=permission.id,
+                code=permission.code,
+            )
+            for permission in role.permissions
+            if not permission.is_deleted and permission.is_active
+        ]
+        return sorted(
+            permissions,
+            key=lambda permission: str(permission.id),
+        )
+
+    def collect_extra_permissions(self, user: User) -> list[PermissionSchema]:
+        permissions = [
+            PermissionSchema(
+                id=permission.id,
+                code=permission.code,
+            )
+            for permission in user.extra_permissions
+            if not permission.is_deleted and permission.is_active
+        ]
+        return sorted(
+            permissions,
+            key=lambda permission: str(permission.id),
+        )
+
+    def collect_role_name(self, user: User) -> str | None:
+        role = self.get_role(user)
+        return role.name if role else None
+
+    async def get_active_role(self, role_id: UUID) -> Role | None:
+        result = await self.session.execute(
+            select(Role)
+            .where(
+                Role.id == role_id,
+                Role.is_deleted == False,
+                Role.is_active == True,
+            )
+            .options(selectinload(Role.permissions))
+        )
+        return result.scalar_one_or_none()
+
+    async def list_active_permissions_by_ids(
+        self,
+        permission_ids: list[UUID],
+    ) -> list[Permission]:
+        if not permission_ids:
+            return []
+        result = await self.session.execute(
+            select(Permission).where(
+                Permission.id.in_(permission_ids),
+                Permission.is_deleted == False,
+                Permission.is_active == True,
+            )
+        )
+        return list(result.scalars().all())

fastapi_forge/templates/with_rbac/app/api/v1/users/router.py

@@ -0,0 +1,146 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.v1.users.schema import UserCreate, UserUpdate
+from app.api.v1.users.service import UserService
+from app.api.v1.schema import DeleteNoteRequest
+from app.core.exceptions import ForbiddenException
+from app.core.dependencies import (
+    get_async_db,
+    get_current_user_payload,
+    require_any_permission,
+)
+from app.helper.pagination_helper import PaginationParams
+from app.core.responses import paginated_response, success_response
+
+router = APIRouter()
+
+_read = Depends(require_any_permission("admin:write", "users:read"))
+_create = Depends(require_any_permission("admin:write", "users:create"))
+_update = Depends(require_any_permission("admin:write", "users:update"))
+_soft_delete = Depends(require_any_permission("admin:write", "users:soft_delete"))
+_hard_delete = Depends(require_any_permission("admin:write", "users:hard_delete"))
+
+
+@router.get("", dependencies=[_read], summary="List users")
+async def list_users(
+    pagination: PaginationParams = Depends(),
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = UserService(db)
+    data, total = await svc.list_users(
+        pagination.page,
+        pagination.page_size,
+        pagination.pagination,
+        search=pagination.search,
+        sort_by=pagination.sort_by,
+        sort_order=pagination.sort_order,
+    )
+    items = [item.model_dump() for item in data]
+    if not pagination.pagination:
+        return success_response(data=items)
+    return paginated_response(
+        items,
+        total,
+        pagination.page,
+        pagination.page_size,
+    )
+
+
+@router.get("/deleted", dependencies=[_read], summary="List soft-deleted users")
+async def list_deleted_users(
+    pagination: PaginationParams = Depends(),
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = UserService(db)
+    data, total = await svc.list_deleted_users(
+        pagination.page,
+        pagination.page_size,
+        pagination.pagination,
+        search=pagination.search,
+        sort_by=pagination.sort_by,
+        sort_order=pagination.sort_order,
+    )
+    items = [item.model_dump() for item in data]
+    if not pagination.pagination:
+        return success_response(data=items)
+    return paginated_response(items, total, pagination.page, pagination.page_size)
+
+
+@router.post(
+    "",
+    dependencies=[_create],
+    status_code=status.HTTP_201_CREATED,
+    summary="Create a user",
+)
+async def create_user(
+    body: UserCreate,
+    db: AsyncSession = Depends(get_async_db),
+    payload: dict = Depends(get_current_user_payload),
+):
+    svc = UserService(db)
+    user = await svc.create_user(body, payload.get("role"))
+    return success_response(data=user.model_dump(), message="User created")
+
+
+@router.get("/{user_id}", dependencies=[_read], summary="Get a user")
+async def get_user(
+    user_id: UUID,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = UserService(db)
+    user = await svc.get_user(
+        user_id,
+    )
+    return success_response(data=user.model_dump())
+
+
+@router.patch("/{user_id}", dependencies=[_update], summary="Update a user")
+async def update_user(
+    user_id: UUID,
+    body: UserUpdate,
+    db: AsyncSession = Depends(get_async_db),
+    payload: dict = Depends(get_current_user_payload),
+):
+    if str(user_id) == payload.get("sub"):
+        raise ForbiddenException("You cannot update your own user account.")
+
+    svc = UserService(db)
+    user = await svc.update_user(
+        user_id,
+        body,
+        current_role_name=payload.get("role"),
+    )
+    return success_response(data=user.model_dump(), message="User updated")
+
+
+@router.delete(
+    "/{user_id}",
+    dependencies=[_soft_delete],
+    summary="Soft delete a user",
+)
+async def soft_delete_user(
+    user_id: UUID,
+    body: DeleteNoteRequest,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = UserService(db)
+    await svc.soft_delete_user(user_id, body.note)
+    return success_response(message="User soft deleted")
+
+
+@router.delete(
+    "/{user_id}/hard",
+    dependencies=[_hard_delete],
+    summary="Hard delete a user",
+)
+async def hard_delete_user(
+    user_id: UUID,
+    body: DeleteNoteRequest,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = UserService(db)
+    await svc.hard_delete_user(user_id, body.note)
+    return success_response(message="User hard deleted")

fastapi_forge/templates/with_rbac/app/api/v1/users/schema.py

@@ -0,0 +1,112 @@
+import re
+from typing import List, Optional
+from uuid import UUID
+
+from pydantic import EmailStr, Field, field_validator
+
+from app.utils.casing import CamelModel
+
+
+class UserBase(CamelModel):
+    email: EmailStr
+    username: str = Field(..., min_length=3, max_length=50)
+    full_name: str = Field(..., min_length=1, max_length=255)
+    is_active: bool = True
+    is_superuser: bool = False
+    is_verified: bool = False
+    role_id: UUID
+    extra_permission_ids: List[UUID] = Field(default_factory=list)
+
+    @field_validator("username")
+    @classmethod
+    def validate_username(cls, value: str) -> str:
+        if not re.match(r"^[a-zA-Z0-9_]+$", value):
+            raise ValueError(
+                "Username may only contain letters, digits, and underscores"
+            )
+        return value.lower()
+
+
+class UserCreate(UserBase):
+    password: str = Field(..., min_length=8, max_length=128)
+
+    @field_validator("password")
+    @classmethod
+    def validate_password_strength(cls, value: str) -> str:
+        errors = []
+        if not re.search(r"[A-Z]", value):
+            errors.append("at least one uppercase letter")
+        if not re.search(r"[a-z]", value):
+            errors.append("at least one lowercase letter")
+        if not re.search(r"\d", value):
+            errors.append("at least one digit")
+        if not re.search(r"[!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>/?]", value):
+            errors.append("at least one special character")
+        if errors:
+            raise ValueError(f"Password must contain {', '.join(errors)}")
+        return value
+
+
+class UserUpdate(CamelModel):
+    email: Optional[EmailStr] = None
+    username: Optional[str] = Field(default=None, min_length=3, max_length=50)
+    full_name: Optional[str] = Field(default=None, min_length=1, max_length=255)
+    # password: Optional[str] = Field(default=None, min_length=8, max_length=128)
+    is_active: Optional[bool] = None
+    is_superuser: Optional[bool] = None
+    is_verified: Optional[bool] = None
+    role_id: Optional[UUID] = None
+    extra_permission_ids: Optional[List[UUID]] = None
+
+    @field_validator("username")
+    @classmethod
+    def validate_username(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return value
+        if not re.match(r"^[a-zA-Z0-9_]+$", value):
+            raise ValueError(
+                "Username may only contain letters, digits, and underscores"
+            )
+        return value.lower()
+
+    # @field_validator("password")
+    # @classmethod
+    # def validate_password_strength(cls, value: Optional[str]) -> Optional[str]:
+    #     if value is None:
+    #         return value
+    #     errors = []
+    #     if not re.search(r"[A-Z]", value):
+    #         errors.append("at least one uppercase letter")
+    #     if not re.search(r"[a-z]", value):
+    #         errors.append("at least one lowercase letter")
+    #     if not re.search(r"\d", value):
+    #         errors.append("at least one digit")
+    #     if not re.search(r"[!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>/?]", value):
+    #         errors.append("at least one special character")
+    #     if errors:
+    #         raise ValueError(f"Password must contain {', '.join(errors)}")
+    #     return value
+
+
+class Permission(CamelModel):
+    id: UUID
+    code: str
+
+
+class UserResponse(CamelModel):
+    id: str
+    email: str
+    username: str
+    full_name: str
+    is_active: bool
+    is_superuser: bool
+    is_verified: bool
+    last_login_at: Optional[str] = None
+    is_deleted: bool = False
+    deleted_at: Optional[str] = None
+    deletion_note: Optional[str] = None
+    role_id: Optional[str] = None
+    role: Optional[str] = None
+    role_permissions: List[Permission] = Field(default_factory=list)
+    extra_permissions: List[Permission] = Field(default_factory=list)
+    permissions: List[Permission] = Field(default_factory=list)