zrb 1.0.0a21__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_client.py

@@ -0,0 +1,163 @@
+from abc import ABC, abstractmethod
+
+from my_app_name.schema.permission import (
+    MultiplePermissionResponse,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+from my_app_name.schema.role import (
+    MultipleRoleResponse,
+    RoleCreateWithAudit,
+    RoleResponse,
+    RoleUpdateWithAudit,
+)
+from my_app_name.schema.user import (
+    MultipleUserResponse,
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
+
+
+class AuthClient(ABC):
+
+    # Permission related methods
+
+    @abstractmethod
+    async def get_permission_by_id(self, permission_id: str) -> PermissionResponse:
+        """Get permission by id"""
+
+    @abstractmethod
+    async def get_permissions(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultiplePermissionResponse:
+        """Get permissions by filter and sort"""
+
+    @abstractmethod
+    async def create_permission(
+        self, data: PermissionCreateWithAudit
+    ) -> PermissionResponse:
+        """Create a new permission"""
+
+    @abstractmethod
+    async def create_permission(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[PermissionResponse]:
+        """Create new permissions"""
+
+    @abstractmethod
+    async def update_permission_bulk(
+        self, permission_ids: list[str], data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        """Update some permissions"""
+
+    @abstractmethod
+    async def update_permission(
+        self, permission_id: str, data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        """Update a permission"""
+
+    @abstractmethod
+    async def delete_permission_bulk(
+        self, permission_ids: str, deleted_by: str
+    ) -> PermissionResponse:
+        """Delete some permissions"""
+
+    @abstractmethod
+    async def delete_permission(
+        self, permission_id: str, deleted_by: str
+    ) -> PermissionResponse:
+        """Delete a permission"""
+
+    # Role related methods
+
+    @abstractmethod
+    async def get_role_by_id(self, role_id: str) -> RoleResponse:
+        """Get role by id"""
+
+    @abstractmethod
+    async def get_roles(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleRoleResponse:
+        """Get roles by filter and sort"""
+
+    @abstractmethod
+    async def create_role(self, data: RoleCreateWithAudit) -> RoleResponse:
+        """Create a new role"""
+
+    @abstractmethod
+    async def create_role(self, data: list[RoleCreateWithAudit]) -> list[RoleResponse]:
+        """Create new roles"""
+
+    @abstractmethod
+    async def update_role_bulk(
+        self, role_ids: list[str], data: RoleUpdateWithAudit
+    ) -> RoleResponse:
+        """Update some roles"""
+
+    @abstractmethod
+    async def update_role(
+        self, role_id: str, data: RoleUpdateWithAudit
+    ) -> RoleResponse:
+        """Update a role"""
+
+    @abstractmethod
+    async def delete_role_bulk(self, role_ids: str, deleted_by: str) -> RoleResponse:
+        """Delete some roles"""
+
+    @abstractmethod
+    async def delete_role(self, role_id: str, deleted_by: str) -> RoleResponse:
+        """Delete a role"""
+
+    # User related methods
+
+    @abstractmethod
+    async def get_user_by_id(self, user_id: str) -> UserResponse:
+        """Get user by id"""
+
+    @abstractmethod
+    async def get_users(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleUserResponse:
+        """Get users by filter and sort"""
+
+    @abstractmethod
+    async def create_user(self, data: UserCreateWithAudit) -> UserResponse:
+        """Create a new user"""
+
+    @abstractmethod
+    async def create_user(self, data: list[UserCreateWithAudit]) -> list[UserResponse]:
+        """Create new users"""
+
+    @abstractmethod
+    async def update_user_bulk(
+        self, user_ids: list[str], data: UserUpdateWithAudit
+    ) -> UserResponse:
+        """Update some users"""
+
+    @abstractmethod
+    async def update_user(
+        self, user_id: str, data: UserUpdateWithAudit
+    ) -> UserResponse:
+        """Update a user"""
+
+    @abstractmethod
+    async def delete_user_bulk(self, user_ids: str, deleted_by: str) -> UserResponse:
+        """Delete some users"""
+
+    @abstractmethod
+    async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
+        """Delete a user"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_client_factory.py

@@ -0,0 +1,9 @@
+from my_app_name.config import APP_COMMUNICATION
+from my_app_name.module.auth.client.auth_api_client import AuthAPIClient
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.client.auth_direct_client import AuthDirectClient
+
+if APP_COMMUNICATION == "direct":
+    auth_client: AuthClient = AuthDirectClient()
+elif APP_COMMUNICATION == "api":
+    auth_client: AuthClient = AuthAPIClient()

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_direct_client.py

@@ -0,0 +1,15 @@
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.role.role_service_factory import role_service
+from my_app_name.module.auth.service.user.user_service_factory import user_service
+
+
+class AuthDirectClient(
+    permission_service.as_direct_client(),
+    role_service.as_direct_client(),
+    user_service.as_direct_client(),
+    AuthClient,
+):
+    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/migration/versions/3093c7336477_add_auth_tables.py

@@ -0,0 +1,160 @@
+"""Add user table
+
+Revision ID: 3093c7336477
+Revises:
+Create Date: 2024-11-20 05:57:01.684118
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "3093c7336477"
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "permission",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_permission_name"), "permission", ["name"], unique=False)
+    op.create_index(
+        op.f("ix_permission_created_at"), "permission", ["created_at"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_created_by"), "permission", ["created_by"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_updated_at"), "permission", ["updated_at"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_updated_by"), "permission", ["updated_by"], unique=False
+    )
+
+    op.create_table(
+        "role",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_role_name"), "role", ["name"], unique=False)
+    op.create_index(op.f("ix_role_created_at"), "role", ["created_at"], unique=False)
+    op.create_index(op.f("ix_role_created_by"), "role", ["created_by"], unique=False)
+    op.create_index(op.f("ix_role_updated_at"), "role", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_role_updated_by"), "role", ["updated_by"], unique=False)
+
+    op.create_table(
+        "rolepermission",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("role_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("permission_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(
+        op.f("ix_rolepermission_permission_id"),
+        "rolepermission",
+        ["permission_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_rolepermission_role_id"), "rolepermission", ["role_id"], unique=False
+    )
+
+    op.create_table(
+        "user",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("username", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("password", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_user_username"), "user", ["username"], unique=False)
+    op.create_index(op.f("ix_user_created_at"), "user", ["created_at"], unique=False)
+    op.create_index(op.f("ix_user_created_by"), "user", ["created_by"], unique=False)
+    op.create_index(op.f("ix_user_updated_at"), "user", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_user_updated_by"), "user", ["updated_by"], unique=False)
+
+    op.create_table(
+        "userrole",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("user_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("role_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_userrole_role_id"), "userrole", ["role_id"], unique=False)
+    op.create_index(op.f("ix_userrole_user_id"), "userrole", ["user_id"], unique=False)
+
+    op.create_table(
+        "session",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("user_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("device", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("os", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("browser", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_session_user_id"), "session", ["user_id"], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_session_user_id"), table_name="session")
+    op.drop_table("session")
+
+    op.drop_index(op.f("ix_userrole_user_id"), table_name="userrole")
+    op.drop_index(op.f("ix_userrole_role_id"), table_name="userrole")
+    op.drop_table("userrole")
+
+    op.drop_index(op.f("ix_user_username"), table_name="user")
+    op.drop_index(op.f("ix_user_updated_by"), table_name="user")
+    op.drop_index(op.f("ix_user_updated_at"), table_name="user")
+    op.drop_index(op.f("ix_user_created_by"), table_name="user")
+    op.drop_index(op.f("ix_user_created_at"), table_name="user")
+    op.drop_table("user")
+
+    op.drop_index(op.f("ix_rolepermission_role_id"), table_name="rolepermission")
+    op.drop_index(op.f("ix_rolepermission_permission_id"), table_name="rolepermission")
+    op.drop_table("rolepermission")
+
+    op.drop_index(op.f("ix_role_name"), table_name="role")
+    op.drop_index(op.f("ix_role_updated_by"), table_name="role")
+    op.drop_index(op.f("ix_role_updated_at"), table_name="role")
+    op.drop_index(op.f("ix_role_created_by"), table_name="role")
+    op.drop_index(op.f("ix_role_created_at"), table_name="role")
+    op.drop_table("role")
+
+    op.drop_index(op.f("ix_permission_updated_by"), table_name="permission")
+    op.drop_index(op.f("ix_permission_updated_at"), table_name="permission")
+    op.drop_index(op.f("ix_permission_created_by"), table_name="permission")
+    op.drop_index(op.f("ix_permission_created_at"), table_name="permission")
+    op.drop_index(op.f("ix_permission_name"), table_name="permission")
+    op.drop_table("permission")
+    # ### end Alembic commands ###

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/migration_metadata.py

@@ -1,6 +1,23 @@
-from my_app_name.schema.user import User
+from my_app_name.schema.permission import Permission
+from my_app_name.schema.role import Role, RolePermission
+from my_app_name.schema.session import Session
+from my_app_name.schema.user import User, UserRole
 from sqlalchemy import MetaData
 
 metadata = MetaData()
+
+Permission.metadata = metadata
+Permission.__table__.tometadata(metadata)
+
+Role.metadata = metadata
+Role.__table__.tometadata(metadata)
+RolePermission.metadata = metadata
+RolePermission.__table__.tometadata(metadata)
+
 User.metadata = metadata
 User.__table__.tometadata(metadata)
+UserRole.metadata = metadata
+UserRole.__table__.tometadata(metadata)
+
+Session.metadata = metadata
+Session.__table__.tometadata(metadata)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/route.py

@@ -1,8 +1,11 @@
 from fastapi import FastAPI
-from my_app_name.common.app import app
+from my_app_name.common.app_factory import app
 from my_app_name.common.schema import BasicResponse
 from my_app_name.config import APP_MAIN_MODULE, APP_MODE, APP_MODULES
-from my_app_name.module.auth.service.user.user_usecase_factory import user_usecase
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.user.user_service_factory import user_service
 
 
 def serve_health_check(app: FastAPI):
@@ -31,7 +34,8 @@ def serve_route(app: FastAPI):
         serve_readiness_check(app)
 
     # Serve user endpoints for APIClient
-    user_usecase.serve_route(app)
+    user_service.serve_route(app)
+    permission_service.serve_route(app)
 
 
 serve_route(app)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service.py

@@ -0,0 +1,117 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+from my_app_name.schema.permission import (
+    MultiplePermissionResponse,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionService(BaseService):
+
+    def __init__(self, logger: Logger, permission_repository: PermissionRepository):
+        super().__init__(logger)
+        self.permission_repository = permission_repository
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["get"],
+        response_model=PermissionResponse,
+    )
+    async def get_permission_by_id(self, permission_id: str) -> PermissionResponse:
+        return await self.permission_repository.get_by_id(permission_id)
+
+    @BaseService.route(
+        "/api/v1/permissions",
+        methods=["get"],
+        response_model=MultiplePermissionResponse,
+    )
+    async def get_permissions(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultiplePermissionResponse:
+        permissions = await self.permission_repository.get(
+            page, page_size, filter, sort
+        )
+        count = await self.permission_repository.count(filter)
+        return MultiplePermissionResponse(data=permissions, count=count)
+
+    @BaseService.route(
+        "/api/v1/permissions/bulk",
+        methods=["post"],
+        response_model=list[PermissionResponse],
+    )
+    async def create_permission_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[PermissionResponse]:
+        permissions = await self.permission_repository.create_bulk(data)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions",
+        methods=["post"],
+        response_model=PermissionResponse,
+    )
+    async def create_permission(
+        self, data: PermissionCreateWithAudit
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.create(data)
+        return await self.permission_repository.get_by_id(permission.id)
+
+    @BaseService.route(
+        "/api/v1/permissions/bulk",
+        methods=["put"],
+        response_model=PermissionResponse,
+    )
+    async def update_permission_bulk(
+        self, permission_ids: list[str], data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        permissions = await self.permission_repository.update_bulk(permission_ids, data)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["put"],
+        response_model=PermissionResponse,
+    )
+    async def update_permission(
+        self, permission_id: str, data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.update(permission_id, data)
+        return await self.permission_repository.get_by_id(permission.id)
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["delete"],
+        response_model=PermissionResponse,
+    )
+    async def delete_permission_bulk(
+        self, permission_ids: list[str], deleted_by: str
+    ) -> PermissionResponse:
+        permissions = await self.permission_repository.delete_bulk(permission_ids)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["delete"],
+        response_model=PermissionResponse,
+    )
+    async def delete_permission(
+        self, permission_id: str, deleted_by: str
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.delete(permission_id)
+        return await self.permission_repository.get_by_id(permission.id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service_factory.py

@@ -0,0 +1,11 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.auth.service.permission.permission_service import (
+    PermissionService,
+)
+from my_app_name.module.auth.service.permission.repository.permission_repository_factory import (
+    permission_repository,
+)
+
+permission_service = PermissionService(
+    logger, permission_repository=permission_repository
+)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_db_repository.py

@@ -0,0 +1,26 @@
+from my_app_name.common.base_db_repository import BaseDBRepository
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+from my_app_name.schema.permission import (
+    Permission,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionDBRepository(
+    BaseDBRepository[
+        Permission,
+        PermissionResponse,
+        PermissionCreateWithAudit,
+        PermissionUpdateWithAudit,
+    ],
+    PermissionRepository,
+):
+    db_model = Permission
+    response_model = PermissionResponse
+    create_model = PermissionCreateWithAudit
+    update_model = PermissionUpdateWithAudit
+    entity_name = "permission"

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_repository.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+
+from my_app_name.schema.permission import (
+    Permission,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> PermissionResponse:
+        """Get permission by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> PermissionResponse:
+        """Get permissions by ids"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[Permission]:
+        """Get permissions by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count permissions by filter"""
+
+    @abstractmethod
+    async def create(self, data: PermissionCreateWithAudit) -> Permission:
+        """Create a new permission"""
+
+    @abstractmethod
+    async def create_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[Permission]:
+        """Create some permissions"""
+
+    @abstractmethod
+    async def delete(self, id: str) -> Permission:
+        """Delete a permission"""
+
+    @abstractmethod
+    async def delete_bulk(self, id_list: list[str]) -> list[Permission]:
+        """Delete some permissions"""
+
+    @abstractmethod
+    async def update(self, id: str, data: PermissionUpdateWithAudit) -> Permission:
+        """Update a permission"""
+
+    @abstractmethod
+    async def update_bulk(
+        self, id_list: list[str], data: PermissionUpdateWithAudit
+    ) -> list[Permission]:
+        """Update some permissions"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_repository_factory.py

@@ -0,0 +1,13 @@
+from my_app_name.common.db_engine_factory import db_engine
+from my_app_name.config import APP_REPOSITORY_TYPE
+from my_app_name.module.auth.service.permission.repository.permission_db_repository import (
+    PermissionDBRepository,
+)
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+
+if APP_REPOSITORY_TYPE == "db":
+    permission_repository: PermissionRepository = PermissionDBRepository(db_engine)
+else:
+    permission_repository: PermissionRepository = None