refactor: renamed built_in_modules into modules

models/__init__.py

@@ -3,10 +3,10 @@ from sqlalchemy.orm import configure_mappers
 from modules.fulfillment_base.models import *  # noqa: F401
 from .base import BaseModel as BaseModel
 from .board import Board as Board
-from .built_in_module import (  # noqa: F401
+from .module import (  # noqa: F401
-    BuiltInModule as BuiltInModule,
+    Module as Module,
-    project_built_in_module as project_built_in_module,
+    project_module as project_module,
-    built_in_module_dependencies as built_in_module_dependencies,
+    module_dependencies as module_dependencies,
 )
 from .deal import Deal as Deal
 from .deal_group import DealGroup as DealGroup

models/built_in_module.py

@@ -1,79 +0,0 @@
-import enum
-from typing import TYPE_CHECKING
-
-from sqlalchemy import Table, Column, ForeignKey
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-
-from models.base import BaseModel
-
-if TYPE_CHECKING:
-    from models import Project
-
-project_built_in_module = Table(
-    "project_built_in_module",
-    BaseModel.metadata,
-    Column("project_id", ForeignKey("projects.id"), primary_key=True),
-    Column("module_id", ForeignKey("built_in_modules.id"), primary_key=True),
-)
-
-
-built_in_module_dependencies = Table(
-    "built_in_module_dependencies",
-    BaseModel.metadata,
-    Column("module_id", ForeignKey("built_in_modules.id"), primary_key=True),
-    Column("depends_on_id", ForeignKey("built_in_modules.id"), primary_key=True),
-)
-
-
-class BuiltInModule(BaseModel):
-    __tablename__ = "built_in_modules"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    key: Mapped[str] = mapped_column(unique=True)
-    label: Mapped[str] = mapped_column()
-    description: Mapped[str] = mapped_column()
-    is_deleted: Mapped[bool] = mapped_column(default=False)
-
-    depends_on: Mapped[list["BuiltInModule"]] = relationship(
-        secondary=built_in_module_dependencies,
-        primaryjoin="BuiltInModule.id == built_in_module_dependencies.c.module_id",
-        secondaryjoin="BuiltInModule.id == built_in_module_dependencies.c.depends_on_id",
-        back_populates="depended_on_by",
-        lazy="immediate",
-    )
-
-    depended_on_by: Mapped[list["BuiltInModule"]] = relationship(
-        secondary="built_in_module_dependencies",
-        primaryjoin="BuiltInModule.id == built_in_module_dependencies.c.depends_on_id",
-        secondaryjoin="BuiltInModule.id == built_in_module_dependencies.c.module_id",
-        back_populates="depends_on",
-        lazy="noload",
-    )
-
-    projects: Mapped[list["Project"]] = relationship(
-        uselist=True,
-        secondary="project_built_in_module",
-        back_populates="built_in_modules",
-        lazy="noload",
-    )
-
-    tabs: Mapped[list["BuiltInModuleTab"]] = relationship(
-        lazy="immediate", backref="module", cascade="all, delete-orphan"
-    )
-
-
-class DeviceType(enum.StrEnum):
-    MOBILE = "mobile"
-    DESKTOP = "desktop"
-    BOTH = "both"
-
-
-class BuiltInModuleTab(BaseModel):
-    __tablename__ = "built_in_module_tab"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    key: Mapped[str] = mapped_column(unique=True)
-    label: Mapped[str] = mapped_column()
-    icon_name: Mapped[str] = mapped_column()
-    module_id: Mapped[int] = mapped_column(ForeignKey("built_in_modules.id"))
-    device: Mapped[DeviceType] = mapped_column(default=DeviceType.BOTH)

models/module.py

@@ -0,0 +1,79 @@
+import enum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Table, Column, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from models.base import BaseModel
+
+if TYPE_CHECKING:
+    from models import Project
+
+project_module = Table(
+    "project_module",
+    BaseModel.metadata,
+    Column("project_id", ForeignKey("projects.id"), primary_key=True),
+    Column("module_id", ForeignKey("modules.id"), primary_key=True),
+)
+
+
+module_dependencies = Table(
+    "module_dependencies",
+    BaseModel.metadata,
+    Column("module_id", ForeignKey("modules.id"), primary_key=True),
+    Column("depends_on_id", ForeignKey("modules.id"), primary_key=True),
+)
+
+
+class Module(BaseModel):
+    __tablename__ = "modules"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    key: Mapped[str] = mapped_column(unique=True)
+    label: Mapped[str] = mapped_column()
+    description: Mapped[str] = mapped_column()
+    is_deleted: Mapped[bool] = mapped_column(default=False)
+
+    depends_on: Mapped[list["Module"]] = relationship(
+        secondary=module_dependencies,
+        primaryjoin="Module.id == module_dependencies.c.module_id",
+        secondaryjoin="Module.id == module_dependencies.c.depends_on_id",
+        back_populates="depended_on_by",
+        lazy="immediate",
+    )
+
+    depended_on_by: Mapped[list["Module"]] = relationship(
+        secondary="module_dependencies",
+        primaryjoin="Module.id == module_dependencies.c.depends_on_id",
+        secondaryjoin="Module.id == module_dependencies.c.module_id",
+        back_populates="depends_on",
+        lazy="noload",
+    )
+
+    projects: Mapped[list["Project"]] = relationship(
+        uselist=True,
+        secondary="project_module",
+        back_populates="modules",
+        lazy="noload",
+    )
+
+    tabs: Mapped[list["ModuleTab"]] = relationship(
+        lazy="immediate", backref="module", cascade="all, delete-orphan"
+    )
+
+
+class DeviceType(enum.StrEnum):
+    MOBILE = "mobile"
+    DESKTOP = "desktop"
+    BOTH = "both"
+
+
+class ModuleTab(BaseModel):
+    __tablename__ = "module_tab"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    key: Mapped[str] = mapped_column(unique=True)
+    label: Mapped[str] = mapped_column()
+    icon_name: Mapped[str] = mapped_column()
+    module_id: Mapped[int] = mapped_column(ForeignKey("modules.id"))
+    device: Mapped[DeviceType] = mapped_column(default=DeviceType.BOTH)

models/project.py

@@ -6,7 +6,7 @@ from models.base import BaseModel
 from models.mixins import SoftDeleteMixin, CreatedAtMixin, IdMixin
 
 if TYPE_CHECKING:
-    from models import Board, BuiltInModule, DealTag
+    from models import Board, Module, DealTag
 
 
 class Project(BaseModel, IdMixin, SoftDeleteMixin, CreatedAtMixin):
@@ -19,11 +19,11 @@ class Project(BaseModel, IdMixin, SoftDeleteMixin, CreatedAtMixin):
         lazy="noload",
     )
 
-    built_in_modules: Mapped[list["BuiltInModule"]] = relationship(
+    modules: Mapped[list["Module"]] = relationship(
-        secondary="project_built_in_module",
+        secondary="project_module",
         back_populates="projects",
         lazy="selectin",
-        order_by="asc(BuiltInModule.id)",
+        order_by="asc(Module.id)",
     )
 
     tags: Mapped[list["DealTag"]] = relationship(

repositories/__init__.py

@@ -1,5 +1,5 @@
 from .board import BoardRepository as BoardRepository
-from .built_in_module import BuiltInModuleRepository as BuiltInModuleRepository
+from .module import ModuleRepository as ModuleRepository
 from .deal import DealRepository as DealRepository
 from .deal_group import DealGroupRepository as DealGroupRepository
 from .deal_tag import DealTagRepository as DealTagRepository

repositories/built_in_module.py

@@ -1,18 +0,0 @@
-from models import Board, BuiltInModule
-from repositories.mixins import *
-
-
-class BuiltInModuleRepository(
-    BaseRepository,
-    RepGetAllMixin[BuiltInModule],
-):
-    entity_class = BuiltInModule
-
-    def _process_get_all_stmt_with_args(self, stmt: Select, *args) -> Select:
-        project_id = args[0]
-        return stmt.where(Board.project_id == project_id).order_by(Board.lexorank)
-
-    async def get_by_ids(self, ids: list[int]) -> list[BuiltInModule]:
-        stmt = select(BuiltInModule).where(BuiltInModule.id.in_(ids))
-        built_in_modules = await self.session.scalars(stmt)
-        return built_in_modules.all()

repositories/module.py

@@ -0,0 +1,18 @@
+from models import Board, Module
+from repositories.mixins import *
+
+
+class ModuleRepository(
+    BaseRepository,
+    RepGetAllMixin[Module],
+):
+    entity_class = Module
+
+    def _process_get_all_stmt_with_args(self, stmt: Select, *args) -> Select:
+        project_id = args[0]
+        return stmt.where(Board.project_id == project_id).order_by(Board.lexorank)
+
+    async def get_by_ids(self, ids: list[int]) -> list[Module]:
+        stmt = select(Module).where(Module.id.in_(ids))
+        modules = await self.session.scalars(stmt)
+        return modules.all()

repositories/project.py

@@ -2,7 +2,7 @@ from sqlalchemy.orm import selectinload
 
 from models import DealTag
 from models.project import Project
-from repositories.built_in_module import BuiltInModuleRepository
+from repositories.module import ModuleRepository
 from repositories.mixins import *
 from schemas.project import CreateProjectSchema, UpdateProjectSchema
 
@@ -26,10 +26,10 @@ class ProjectRepository(
         return self._apply_options(stmt)
 
     async def update(self, project: Project, data: UpdateProjectSchema) -> Project:
-        if data.built_in_modules is not None:
+        if data.modules is not None:
-            built_in_modules = data.built_in_modules
+            modules = data.modules
-            module_ids = [module.id for module in built_in_modules]
+            module_ids = [module.id for module in modules]
-            data.built_in_modules = await BuiltInModuleRepository(
+            data.modules = await ModuleRepository(
                 self.session
             ).get_by_ids(module_ids)
 

routers/crm/v1/module.py

@@ -1,18 +1,18 @@
 from fastapi import APIRouter
 
 from backend.dependecies import SessionDependency
-from schemas.module import GetAllBuiltInModulesResponse
+from schemas.module import GetAllModulesResponse
-from services.built_in_module import BuiltInModuleService
+from services.module import ModuleService
 
 router = APIRouter(tags=["modules"])
 
 
 @router.get(
     "/built-in/",
-    response_model=GetAllBuiltInModulesResponse,
+    response_model=GetAllModulesResponse,
-    operation_id="get_built_in_modules",
+    operation_id="get_modules",
 )
-async def get_built_in_modules(
+async def get_modules(
     session: SessionDependency,
 ):
-    return await BuiltInModuleService(session).get_all()
+    return await ModuleService(session).get_all()

schemas/module.py

@@ -3,7 +3,7 @@ from schemas.base import BaseSchema
 # region Entity
 
 
-class BuiltInModuleTabSchema(BaseSchema):
+class ModuleTabSchema(BaseSchema):
     id: int
     key: str
     label: str
@@ -11,13 +11,13 @@ class BuiltInModuleTabSchema(BaseSchema):
     device: str
 
 
-class BuiltInModuleSchema(BaseSchema):
+class ModuleSchema(BaseSchema):
     id: int
     key: str
     label: str
     description: str
-    depends_on: list["BuiltInModuleSchema"]
+    depends_on: list["ModuleSchema"]
-    tabs: list[BuiltInModuleTabSchema]
+    tabs: list[ModuleTabSchema]
 
 
 # endregion
@@ -25,8 +25,8 @@ class BuiltInModuleSchema(BaseSchema):
 # region Response
 
 
-class GetAllBuiltInModulesResponse(BaseSchema):
+class GetAllModulesResponse(BaseSchema):
-    items: list[BuiltInModuleSchema]
+    items: list[ModuleSchema]
 
 
 # endregion

schemas/project.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from schemas.base import BaseSchema, BaseResponse
 from schemas.deal_tag import DealTagSchema
-from schemas.module import BuiltInModuleSchema
+from schemas.module import ModuleSchema
 
 
 # region Entity
@@ -11,7 +11,7 @@ from schemas.module import BuiltInModuleSchema
 class ProjectSchema(BaseSchema):
     id: int
     name: str
-    built_in_modules: list[BuiltInModuleSchema]
+    modules: list[ModuleSchema]
     tags: list[DealTagSchema]
 
 
@@ -21,7 +21,7 @@ class CreateProjectSchema(BaseSchema):
 
 class UpdateProjectSchema(BaseSchema):
     name: Optional[str] = None
-    built_in_modules: list[BuiltInModuleSchema] = None
+    modules: list[ModuleSchema] = None
 
 
 # endregion

services/built_in_module.py

@@ -1,11 +0,0 @@
-from models import BuiltInModule
-from repositories import BuiltInModuleRepository
-from schemas.module import BuiltInModuleSchema
-from services.mixins import *
-
-
-class BuiltInModuleService(ServiceGetAllMixin[BuiltInModule, BuiltInModuleSchema]):
-    schema_class = BuiltInModuleSchema
-
-    def __init__(self, session: AsyncSession):
-        self.repository = BuiltInModuleRepository(session)

services/module.py

@@ -0,0 +1,11 @@
+from models import Module
+from repositories import ModuleRepository
+from schemas.module import ModuleSchema
+from services.mixins import *
+
+
+class ModuleService(ServiceGetAllMixin[Module, ModuleSchema]):
+    schema_class = ModuleSchema
+
+    def __init__(self, session: AsyncSession):
+        self.repository = ModuleRepository(session)