fix(projects): add project coordinator

Author: Mario G.

src/liceo/infra/adapters/migrations/20250915_initial_migration.sql

@@ -196,4 +196,39 @@ CREATE TABLE IF NOT EXISTS liceo_projects (
     last_updated_by TEXT,
     CONSTRAINT fk_projects_created_by FOREIGN KEY (created_by) REFERENCES liceo_users(id),
     CONSTRAINT fk_projects_last_updated_by FOREIGN KEY (last_updated_by) REFERENCES liceo_users(id)
-)
+);
+
+CREATE TABLE IF NOT EXISTS liceo_projects_members (
+    id TEXT PRIMARY KEY,
+    version INTEGER NOT NULL,
+    project_id TEXT NOT NULL,
+    person_id TEXT NOT NULL,
+    created_at TIMESTAMP NOT NULL,
+    created_by TEXT NOT NULL,
+    last_updated_at TIMESTAMP,
+    last_updated_by TEXT,
+    UNIQUE("project_id", "person_id"),
+    CONSTRAINT fk_projects_members_project_id FOREIGN KEY (project_id) REFERENCES liceo_projects(id),
+    CONSTRAINT fk_projects_members_person_id FOREIGN KEY (person_id) REFERENCES liceo_people(id),
+    CONSTRAINT fk_projects_members_created_by FOREIGN KEY (created_by) REFERENCES liceo_users(id),
+    CONSTRAINT fk_projects_members_last_updated_by FOREIGN KEY (last_updated_by) REFERENCES liceo_users(id)
+);
+
+CREATE TABLE IF NOT EXISTS liceo_projects_coordinators (
+    id TEXT PRIMARY KEY,
+    version INTEGER NOT NULL,
+    project_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    is_owner BOOLEAN,
+    created_at TIMESTAMP NOT NULL,
+    created_by TEXT NOT NULL,
+    last_updated_at TIMESTAMP,
+    last_updated_by TEXT,
+    UNIQUE("project_id", "user_id"),
+    CONSTRAINT fk_projects_coordinators_project_id FOREIGN KEY (project_id) REFERENCES liceo_projects(id),
+    CONSTRAINT fk_projects_coordinators_user_id FOREIGN KEY (user_id) REFERENCES liceo_users(id),
+    CONSTRAINT fk_projects_coordinators_created_by FOREIGN KEY (created_by) REFERENCES liceo_users(id),
+    CONSTRAINT fk_projects_coordinators_last_updated_by FOREIGN KEY (last_updated_by) REFERENCES liceo_users(id)
+);
+
+CREATE UNIQUE INDEX liceo_projects_coordinators_only_one_owner ON liceo_projects_coordinators (is_owner, project_id) WHERE is_owner = TRUE;

src/liceo/infra/adapters/migrations/20260103_initial_data.sql

@@ -97,6 +97,8 @@ INSERT INTO liceo_permissions (id, name, description) VALUES ('33Eccx9gpXqbE9mCB
 INSERT INTO liceo_permissions (id, name, description) VALUES ('mgewHChKbk5rAbbc5fAnQU', 'PROJECTS_CREATE', 'allows to create projects');
 INSERT INTO liceo_permissions (id, name, description) VALUES ('LGoiyMGdNGPFXhzVP7MXnf', 'PROJECTS_LIST', 'allows to list or filter projects');
 INSERT INTO liceo_permissions (id, name, description) VALUES ('KrMBkC2Qg5aBFo2GoTMe7z', 'PROJECTS_ADD_MEMBERSHIP', 'allows to add a person to the project');
+INSERT INTO liceo_permissions (id, name, description) VALUES ('8fvxbEm9GZ96gAmF67EExy', 'PROJECTS_ADD_COORDINATOR', 'allows to add a coordinator to the project');
+INSERT INTO liceo_permissions (id, name, description) VALUES ('JEaWqpg6guams3awBJ2QTb', 'PROJECTS_QUERY_COORDINATORS_BY_PROJECTS', 'allows to find coordinators in the projects passed');
 
 
 -- #######################
@@ -188,6 +190,10 @@ INSERT INTO liceo_roles_permissions (role_id, permission_id) VALUES ('rDCJKyPVeG
 INSERT INTO liceo_roles_permissions (role_id, permission_id) VALUES ('rDCJKyPVeGLfmboVS7PkXC', 'LGoiyMGdNGPFXhzVP7MXnf');
 -- ADMIN/PROJECTS_ADD_MEMBERSHIP
 INSERT INTO liceo_roles_permissions (role_id, permission_id) VALUES ('rDCJKyPVeGLfmboVS7PkXC', 'KrMBkC2Qg5aBFo2GoTMe7z');
+-- ADMIN/PROJECTS_ADD_COORDINATOR
+INSERT INTO liceo_roles_permissions (role_id, permission_id) VALUES ('rDCJKyPVeGLfmboVS7PkXC', '8fvxbEm9GZ96gAmF67EExy');
+-- ADMIN/PROJECTS_QUERY_COORDINATORS_BY_PROJECTS
+INSERT INTO liceo_roles_permissions (role_id, permission_id) VALUES ('rDCJKyPVeGLfmboVS7PkXC', 'JEaWqpg6guams3awBJ2QTb');
 
 
 -- #######################

src/liceo/labs/db/sql.py

@@ -144,7 +144,7 @@ def wrapper(self: SQLRepository, *args: Any, **kwargs: Any) -> A:
                 return mapper(all)
 
             if func.__name__.startswith("find_") or func.__name__.startswith("insert_"):
-                logger.debug("executing find___ query")
+                logger.debug(f"executing find___ query: {func.__name__}")
                 one = self._get_connection().one(sql=sql_content, params=kwargs)
                 return mapper(one)
 

src/liceo/people/projects/adapters/di.py

@@ -1,12 +1,13 @@
 from typing import Annotated
 from fastapi import Depends, Body, Query, Path
+from liceo.security.users.adapters.di import UsersServiceDependency
 from liceo.infra.adapters.di import ConnectionFactoryDependency, ConnectionManagerDependency, TransactionManagerDependency, EventStoreDependency
 from liceo.security.common.adapters.di import UserInfo
-from ..application.repository import ProjectRepository, ProjectMemberRepository
+from ..application.repository import ProjectRepository, ProjectMemberRepository, ProjectCoordinatorRepository
 from ..application.service import ProjectService
-from .repository import SQLProjectRepository, SQLProjectMemberRepository
+from .repository import SQLProjectRepository, SQLProjectMemberRepository, SQLProjectCoordinatorRepository
 from .service import DatabaseAwareProjectService
-from .requests import CreateProjectRequest, CreateProjectDetails, ListProjectsRequest, AddMemberToProjectRequest, AddMemberToProjectPath
+from .requests import CreateProjectRequest, CreateProjectDetails, ListProjectsRequest, AddMemberToProjectRequest, AddMemberToProjectPath, AddCoordinatorRequest, AddCoordinatorPayload, FindAllCoordinatorsByProjectsRequest
 
 # ------ REPOSITORIES
 
@@ -27,19 +28,30 @@ def create_project_members_repository(factory: ConnectionFactoryDependency) -> P
     create_project_members_repository)]
 
 
+def create_project_coordinators_repository(factory: ConnectionFactoryDependency) -> ProjectCoordinatorRepository:
+    return SQLProjectCoordinatorRepository(factory=factory)
+
+
+ProjectCoordinatorRepositoryDependency = Annotated[ProjectCoordinatorRepository, Depends(
+    create_project_coordinators_repository)]
+
 # ------ SERVICES
 
 
 def create_project_service(
         projects: ProjectRepositoryDependency,
+        users: UsersServiceDependency,
         project_members: ProjectMemberRepositoryDependency,
+        project_coordinators: ProjectCoordinatorRepositoryDependency,
         transaction_manager_factory: TransactionManagerDependency,
         connection_manager_factory: ConnectionManagerDependency,
         event_store: EventStoreDependency
 ) -> ProjectService:
     return DatabaseAwareProjectService(
         projects=projects,
+        users=users,
         project_members=project_members,
+        project_coordinators=project_coordinators,
         transaction_manager_factory=transaction_manager_factory,
         connection_manager_factory=connection_manager_factory,
         event_store=event_store
@@ -74,3 +86,26 @@ def created_add_project_member_request(
 
 AddMemberToProjectRequestDependency = Annotated[AddMemberToProjectRequest, Depends(
     created_add_project_member_request)]
+
+
+def create_add_cordinator_payload(
+        id: str = Path(),
+        user_id: str = Path()
+):
+    return AddCoordinatorPayload(id=id, user_id=user_id)
+
+
+def create_add_coordinator_request(
+        user_info: UserInfo,
+        is_owner: bool = Body(),
+        payload: AddCoordinatorPayload = Depends(create_add_cordinator_payload)
+):
+    return AddCoordinatorRequest(added_by=user_info, details=payload, is_owner=is_owner)
+
+
+AddCoordinatorRequestDependency = Annotated[AddCoordinatorRequest, Depends(
+    create_add_coordinator_request)]
+
+
+FindAllCoordinatorsByProjectsRequestDependency = Annotated[FindAllCoordinatorsByProjectsRequest, Body(
+)]

src/liceo/people/projects/adapters/endpoints.py

@@ -39,7 +39,7 @@ def create(
 
 
 @router.post(
-    path="/{id}/membership/{person_id}",
+    path="/{id}/memberships/{person_id}",
     summary="Adds a person membership to the project",
     dependencies=[has_permission(permissions.PROJECTS_ADD_MEMBERSHIP)],
     openapi_extra={**open_api_permissions([permissions.PROJECTS_ADD_MEMBERSHIP])}
@@ -49,3 +49,32 @@ def add_member(
     service: di.ProjectServiceDependency
 ) -> responses.ProjectMembershipResponse | None:
     return responses.ProjectMembershipResponse.from_project_membership(service.add_new_member(request.to_dto()))
+
+
+@router.post(
+    path="/{id}/coordinators/{user_id}",
+    summary="Adds a coordinator to the project",
+    dependencies=[has_permission(permissions.PROJECTS_ADD_COORDINATOR)],
+    openapi_extra={**open_api_permissions([permissions.PROJECTS_ADD_COORDINATOR])}
+)
+def add_coordinator(
+    request: di.AddCoordinatorRequestDependency,
+    service: di.ProjectServiceDependency
+) -> responses.ProjectCoordinatorResponse | None:
+    return responses.ProjectCoordinatorResponse.from_coordinator(service.add_coordinator(request.to_dto()))
+
+
+@router.post(
+    path="/query/coordinators-by-projects",
+    summary="Query to get a distinct limited number of coordinators in the projects passed",
+    dependencies=[has_permission(permissions.PROJECTS_QUERY_COORDINATORS_BY_PROJECTS)],
+    openapi_extra={
+        **open_api_permissions([permissions.PROJECTS_QUERY_COORDINATORS_BY_PROJECTS])}
+)
+def find_all_coordinators_by_project_ids(
+    request: di.FindAllCoordinatorsByProjectsRequestDependency,
+    service: di.ProjectServiceDependency
+) -> responses.ListProjectsCoordinatorsResponse:
+    return responses.ListProjectsCoordinatorsResponse.from_paged(
+        service.find_all_coordinators_by_project_ids(request.to_dto())
+    )

src/liceo/people/projects/adapters/mappers.py

@@ -2,11 +2,25 @@
 from ..domain import entities, vo
 
 
-def from_row_to_project(row: dict) -> entities.Project:
+def from_row_to_project(row: dict) -> entities.Project | None:
+    print(row)
+    if not row:
+        return
     project = entities.Project(vo.ProjectId(row["id"]))
     project._version = row["version"]
     project.name = row["name"]
     project.description = row["description"]
     project.audit = AuditInfo(created_by=vo.UserId(row["created_by"]))
     project.audit.created_at = row["created_at"]
     return project
+
+
+def from_row_to_project_coordinator(row: dict) -> entities.ProjectCoordinator:
+    coordinator = entities.ProjectCoordinator(vo.ProjectCoordinatorId(row["id"]))
+    coordinator._version = row["version"]
+    coordinator.project = vo.ProjectId(row["project_id"])
+    coordinator.user = vo.UserId(row["user_id"])
+    coordinator.is_owner = row["is_owner"]
+    coordinator.audit = AuditInfo(created_by=vo.UserId(row["created_by"]))
+    coordinator.audit.created_at = row["created_at"]
+    return coordinator

src/liceo/people/projects/adapters/permissions.py

@@ -1,3 +1,7 @@
 PROJECTS_CREATE: str = "PROJECTS_CREATE"
 PROJECTS_LIST: str = "PROJECTS_LIST"
 PROJECTS_ADD_MEMBERSHIP: str = "PROJECTS_ADD_MEMBERSHIP"
+PROJECTS_ADD_COORDINATOR: str = "PROJECTS_ADD_COORDINATOR"
+PROJECTS_QUERY_COORDINATORS_BY_PROJECTS: str = "PROJECTS_QUERY_COORDINATORS_BY_PROJECTS"
+# PROJECTS_LIST_COORDINATORS: str = "PROJECTS_LIST_COORDINATORS"
+# PROJECTS_LIST_MEMBERSHIPS: str = "PROJECTS_LIST_MEMBERSHIPS"

src/liceo/people/projects/adapters/repository.py

@@ -1,19 +1,19 @@
 from shortuuid import uuid
 from typing import override
 from liceo.infra.domain.vo import Paged, Pagination
-from liceo.people.projects.domain.entities import Project, ProjectMembership
+from liceo.people.projects.domain.entities import Project, ProjectCoordinator, ProjectMembership
 from liceo.labs.db.sql import SQLRepository, sql
-from liceo.people.projects.domain.vo import ProjectId, ProjectMembershipId
-from ..application.repository import ProjectRepository, ProjectMemberRepository
-from .mappers import from_row_to_project
+from liceo.people.projects.domain.vo import ProjectCoordinatorId, ProjectId, ProjectMembershipId
+from ..application.repository import ProjectRepository, ProjectMemberRepository, ProjectCoordinatorRepository
+from . import mappers
 
 
 class SQLProjectRepository(ProjectRepository, SQLRepository):
     @override
     def generate_id(self) -> ProjectId:
         return ProjectId(uuid())
 
-    @sql(from_row_to_project)
+    @sql(mappers.from_row_to_project)
     def find_project_by_id(self, id: str) -> Project | None:
         return None
 
@@ -47,19 +47,20 @@ def filter_projects_by_name(self, name: str | None, pagination: Pagination) -> P
             self.sql_optimize_params(sql, params),
             params
         )
+        transformed = list(map(mappers.from_row_to_project, result))
         return Paged(
             total=result[0]["total_count"] if result else 0,
-            data=list(map(from_row_to_project, result))
+            data=[t for t in transformed if t]
         )
 
 
 class SQLProjectMemberRepository(ProjectMemberRepository, SQLRepository):
     def generate_id(self) -> ProjectMembershipId:
         return ProjectMembershipId(uuid())
 
-    def save_membership(self, membership: ProjectMembership) -> ProjectMembership:
+    def save_project_membership(self, membership: ProjectMembership) -> ProjectMembership:
         self._get_connection().execute(
-            sql=self.resolve_sql(self.save_membership),
+            sql=self.resolve_sql(self.save_project_membership),
             params={
                 "id": membership.id,
                 "version": membership._version,
@@ -70,3 +71,45 @@ def save_membership(self, membership: ProjectMembership) -> ProjectMembership:
             }
         )
         return membership
+
+
+class SQLProjectCoordinatorRepository(ProjectCoordinatorRepository, SQLRepository):
+    def generate_id(self) -> ProjectCoordinatorId:
+        return ProjectCoordinatorId(uuid())
+
+    def save_project_coordinator(self, project_coordinator: ProjectCoordinator) -> ProjectCoordinator | None:
+        self._get_connection().execute(
+            sql=self.resolve_sql(self.save_project_coordinator),
+            params={
+                "id": project_coordinator.id.id,
+                "version": project_coordinator._version,
+                "project_id": project_coordinator.project.id,
+                "user_id": project_coordinator.user.id,
+                "is_owner": project_coordinator.is_owner,
+                "created_by": project_coordinator.created_by.id,
+                "created_at": project_coordinator.created_at
+            }
+        )
+        return project_coordinator
+
+    def find_all_coordinators_by_project_ids(self, project_ids: list[str]) -> Paged[ProjectCoordinator]:
+        sql = self.resolve_sql(self.find_all_coordinators_by_project_ids)
+        rows = self._get_connection().all(
+            sql=sql,
+            params={
+                "ids": project_ids
+            }
+        )
+
+        if not rows or len(rows) <= 0:
+            return Paged.empty()
+
+        return Paged(
+            total=rows[0]["total_count"],
+            data=list(
+                map(
+                    mappers.from_row_to_project_coordinator,
+                    rows
+                )
+            )
+        )

src/liceo/people/projects/adapters/requests.py

@@ -49,3 +49,29 @@ def to_dto(self) -> dtos.AddMemberToProjectDTO:
             person_id=self.details.person_id,
             created_by=self.created_by.id
         )
+
+
+class AddCoordinatorPayload(BaseModel):
+    id: str
+    user_id: str
+
+
+class AddCoordinatorRequest(BaseModel):
+    added_by: UserContextModel
+    is_owner: bool = Field(default=False)
+    details: AddCoordinatorPayload
+
+    def to_dto(self) -> dtos.AddCoordinatorToProjectDTO:
+        return dtos.AddCoordinatorToProjectDTO(
+            user_id=self.details.user_id,
+            project_id=self.details.id,
+            added_by=self.added_by.id,
+            is_owner=self.is_owner
+        )
+
+
+class FindAllCoordinatorsByProjectsRequest(BaseModel):
+    projects: list[str]
+
+    def to_dto(self) -> dtos.FindAllCoordinatorsByProjectIdsDTO:
+        return dtos.FindAllCoordinatorsByProjectIdsDTO(projects=self.projects)

src/liceo/people/projects/adapters/responses.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel
 from liceo.infra.domain.vo import Paged
-from ..domain.entities import Project, ProjectMembership
+from ..domain.entities import Project, ProjectMembership, ProjectCoordinator
 
 
 class MinimalProjectResponse(BaseModel):
@@ -56,3 +56,35 @@ def from_project_membership(membership: ProjectMembership | None):
                 person_id=membership.person.id,
                 project_id=membership.project.id
             )
+
+
+class ProjectCoordinatorResponse(BaseModel):
+    id: str
+    version: int
+    user: str
+    project: str
+    is_owner: bool
+
+    @staticmethod
+    def from_coordinator(coordinator: ProjectCoordinator | None):
+        if coordinator:
+            return ProjectCoordinatorResponse(
+                id=coordinator.id.id,
+                version=coordinator._version,
+                user=coordinator.user.id,
+                project=coordinator.project.id,
+                is_owner=coordinator.is_owner
+            )
+
+
+class ListProjectsCoordinatorsResponse(BaseModel):
+    data: list[ProjectCoordinatorResponse]
+    total: int
+
+    @staticmethod
+    def from_paged(paged: Paged[ProjectCoordinator]):
+        coordinators = map(ProjectCoordinatorResponse.from_coordinator, paged.data)
+        return ListProjectsCoordinatorsResponse(
+            data=[c for c in coordinators if c],
+            total=paged.total
+        )