feat(phonebook): use modular association groupements

app/modules/phonebook/endpoints_phonebook.py

@@ -13,11 +13,7 @@
     is_user_an_ecl_member,
     is_user_in,
 )
-from app.modules.phonebook import (
-    cruds_phonebook,
-    models_phonebook,
-    schemas_phonebook,
-)
+from app.modules.phonebook import cruds_phonebook, schemas_phonebook
 from app.modules.phonebook.factory_phonebook import PhonebookFactory
 from app.modules.phonebook.types_phonebook import RoleTags
 from app.types import standard_responses
@@ -51,19 +47,7 @@ async def get_all_associations(
     """
     Return all associations from database as a list of AssociationComplete schemas
     """
-    associations = await cruds_phonebook.get_all_associations(db)
-    return [
-        schemas_phonebook.AssociationComplete(
-            id=association.id,
-            name=association.name,
-            kind=association.kind,
-            mandate_year=association.mandate_year,
-            description=association.description,
-            associated_groups=[group.id for group in association.associated_groups],
-            deactivated=association.deactivated,
-        )
-        for association in associations
-    ]
+    return await cruds_phonebook.get_all_associations(db)
 
 
 @module.router.get(
@@ -72,7 +56,6 @@ async def get_all_associations(
     status_code=200,
 )
 async def get_all_role_tags(
-    db: AsyncSession = Depends(get_db),
     user: models_users.CoreUser = Depends(is_user_an_ecl_member),
 ):
     """
@@ -83,18 +66,142 @@ async def get_all_role_tags(
 
 
 @module.router.get(
-    "/phonebook/associations/kinds",
-    response_model=schemas_phonebook.KindsReturn,
+    "/phonebook/groupements/",
+    response_model=list[schemas_phonebook.AssociationGroupement],
     status_code=200,
 )
-async def get_all_kinds(
+async def get_all_groupements(
+    user: models_users.CoreUser = Depends(is_user_an_ecl_member),
+    db: AsyncSession = Depends(get_db),
+):
+    """
+    Return all groupements from database as a list of AssociationGroupement schemas
+    """
+    return await cruds_phonebook.get_all_groupements(db)
+
+
+@module.router.post(
+    "/phonebook/groupements/",
+    response_model=schemas_phonebook.AssociationGroupement,
+    status_code=201,
+)
+async def create_groupement(
+    groupement_base: schemas_phonebook.AssociationGroupementBase,
+    user: models_users.CoreUser = Depends(is_user_an_ecl_member),
+    db: AsyncSession = Depends(get_db),
+):
+    if not is_user_member_of_any_group(
+        user=user,
+        allowed_groups=[GroupType.CAA, GroupType.BDE],
+    ):
+        raise HTTPException(
+            status_code=403,
+            detail="You are not allowed to create association",
+        )
+    groupement_db = await cruds_phonebook.get_groupement_by_name(
+        groupement_name=groupement_base.name,
+        db=db,
+    )
+    if groupement_db is not None:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Groupement with name {groupement_base.name} already exists.",
+        )
+
+    groupement_id = str(uuid.uuid4())
+    groupement = schemas_phonebook.AssociationGroupement(
+        id=groupement_id,
+        name=groupement_base.name,
+    )
+    await cruds_phonebook.create_groupement(
+        groupement=groupement,
+        db=db,
+    )
+    return groupement
+
+
+@module.router.patch(
+    "/phonebook/groupements/{groupement_id}",
+    status_code=204,
+)
+async def update_groupement(
+    groupement_id: uuid.UUID,
+    groupement_edit: schemas_phonebook.AssociationGroupementBase,
+    user: models_users.CoreUser = Depends(is_user_an_ecl_member),
+    db: AsyncSession = Depends(get_db),
+):
+    """
+    Update a groupement
+
+    **This endpoint is only usable by CAA and BDE**
+    """
+    if not is_user_member_of_any_group(
+        user=user,
+        allowed_groups=[GroupType.CAA, GroupType.BDE],
+    ):
+        raise HTTPException(
+            status_code=403,
+            detail=f"You are not allowed to update groupement {groupement_id}",
+        )
+    groupement = await cruds_phonebook.get_groupement_by_id(
+        groupement_id=groupement_id,
+        db=db,
+    )
+    if groupement is None:
+        raise HTTPException(
+            status_code=404,
+            detail="Groupement not found.",
+        )
+    if groupement.name != groupement_edit.name:
+        existing_groupement = await cruds_phonebook.get_groupement_by_name(
+            groupement_name=groupement_edit.name,
+            db=db,
+        )
+        if existing_groupement is not None:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Groupement with name {groupement_edit.name} already exists.",
+            )
+
+    await cruds_phonebook.update_groupement(
+        groupement_id=groupement_id,
+        groupement_edit=groupement_edit,
+        db=db,
+    )
+
+
+@module.router.delete(
+    "/phonebook/groupements/{groupement_id}",
+    status_code=204,
+)
+async def delete_groupement(
+    groupement_id: uuid.UUID,
     user: models_users.CoreUser = Depends(is_user_an_ecl_member),
+    db: AsyncSession = Depends(get_db),
 ):
     """
-    Return all available kinds of from Kinds enum.
+    Delete a groupement
+
+    **This endpoint is only usable by CAA and BDE**
     """
-    kinds = await cruds_phonebook.get_all_kinds()
-    return schemas_phonebook.KindsReturn(kinds=kinds)
+    if not is_user_member_of_any_group(
+        user=user,
+        allowed_groups=[GroupType.CAA, GroupType.BDE],
+    ):
+        raise HTTPException(
+            status_code=403,
+            detail=f"You are not allowed to delete groupement {groupement_id}",
+        )
+    associations = await cruds_phonebook.get_associations_by_groupement_id(
+        groupement_id=groupement_id,
+        db=db,
+    )
+    if associations:
+        raise HTTPException(
+            status_code=400,
+            detail="You cannot delete a groupement that has associations linked to it.",
+        )
+    await cruds_phonebook.delete_groupement(groupement_id, db)
 
 
 @module.router.post(
@@ -123,11 +230,11 @@ async def create_association(
         )
 
     association_id = str(uuid.uuid4())
-    association_model = models_phonebook.Association(
+    association_model = schemas_phonebook.AssociationComplete(
         id=association_id,
         name=association.name,
         description=association.description,
-        kind=association.kind,
+        groupement_id=association.groupement_id,
         mandate_year=association.mandate_year,
         deactivated=association.deactivated,
     )
@@ -177,14 +284,11 @@ async def update_association(
             detail=f"You are not allowed to update association {association_id}",
         )
 
-    try:
-        await cruds_phonebook.update_association(
-            association_id=association_id,
-            association_edit=association_edit,
-            db=db,
-        )
-    except ValueError as error:
-        raise HTTPException(status_code=400, detail=str(error))
+    await cruds_phonebook.update_association(
+        association_id=association_id,
+        association_edit=association_edit,
+        db=db,
+    )
 
 
 @module.router.patch(
@@ -454,20 +558,25 @@ async def create_membership(
         )
 
     membershipId = str(uuid.uuid4())
-    membership_model = models_phonebook.Membership(
+    membership_model = schemas_phonebook.MembershipComplete(
         id=membershipId,
-        **membership.model_dump(),
+        user_id=membership.user_id,
+        association_id=membership.association_id,
+        mandate_year=membership.mandate_year,
+        role_name=membership.role_name,
+        role_tags=membership.role_tags,
+        member_order=membership.member_order,
     )
 
     await cruds_phonebook.create_membership(membership_model, db)
 
     user_groups_id = [group.id for group in user_added.groups]
-    for associated_group in association.associated_groups:
-        if associated_group.id not in user_groups_id:
+    for associated_group_id in association.associated_groups:
+        if associated_group_id not in user_groups_id:
             await cruds_groups.create_membership(
                 models_groups.CoreMembership(
                     user_id=membership.user_id,
-                    group_id=associated_group.id,
+                    group_id=associated_group_id,
                     description=None,
                 ),
                 db,

app/modules/phonebook/factory_phonebook.py

@@ -1,79 +1,88 @@
 import random
 import uuid
 
+from faker import Faker
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.users import cruds_users
 from app.core.users.factory_users import CoreUsersFactory
 from app.core.utils.config import Settings
-from app.modules.phonebook import cruds_phonebook, models_phonebook
-from app.modules.phonebook.types_phonebook import Kinds, RoleTags
+from app.modules.phonebook import cruds_phonebook, schemas_phonebook
+from app.modules.phonebook.types_phonebook import RoleTags
 from app.types.factory import Factory
 
+faker = Faker("fr_FR")
+
 
 class PhonebookFactory(Factory):
     depends_on = [CoreUsersFactory]
 
     @classmethod
-    async def create_association(cls, db: AsyncSession):
-        association_id_1 = str(uuid.uuid4())
-        await cruds_phonebook.create_association(
-            association=models_phonebook.Association(
-                id=association_id_1,
-                name="Eclair",
-                description="L'asso d'informatique la plus cool !",
-                deactivated=False,
-                kind=Kinds.section_ae,
-                mandate_year=2025,
+    async def create_association_groupement(cls, db: AsyncSession) -> list[uuid.UUID]:
+        groupement_ids = [uuid.uuid4() for _ in range(3)]
+        await cruds_phonebook.create_groupement(
+            schemas_phonebook.AssociationGroupement(
+                id=groupement_ids[0],
+                name="Section AE",
             ),
             db=db,
         )
-
-        await cruds_phonebook.create_membership(
-            membership=models_phonebook.Membership(
-                id=str(uuid.uuid4()),
-                user_id=CoreUsersFactory.demo_users_id[0],
-                association_id=association_id_1,
-                mandate_year=2025,
-                role_name="Prez",
-                role_tags=RoleTags.president.name,
-                member_order=1,
+        await cruds_phonebook.create_groupement(
+            schemas_phonebook.AssociationGroupement(
+                id=groupement_ids[1],
+                name="Club AE",
             ),
             db=db,
         )
-
-        association_id_2 = str(uuid.uuid4())
-        await cruds_phonebook.create_association(
-            association=models_phonebook.Association(
-                id=association_id_2,
-                name="Association 2",
-                description="Description de l'asso 2",
-                associated_groups=[],
-                deactivated=False,
-                kind=Kinds.section_use,
-                mandate_year=2025,
+        await cruds_phonebook.create_groupement(
+            schemas_phonebook.AssociationGroupement(
+                id=groupement_ids[2],
+                name="Section USE",
             ),
             db=db,
         )
-        users = await cruds_users.get_users(db=db)
-        tags = list(RoleTags)
-        for i, user in enumerate(random.sample(users, 10)):
-            await cruds_phonebook.create_membership(
-                membership=models_phonebook.Membership(
-                    id=str(uuid.uuid4()),
-                    user_id=user.id,
-                    association_id=association_id_2,
+        return groupement_ids
+
+    @classmethod
+    async def create_association(
+        cls,
+        db: AsyncSession,
+        groupement_ids: list[uuid.UUID],
+    ):
+        for i in range(5):
+            association_id = str(uuid.uuid4())
+            await cruds_phonebook.create_association(
+                association=schemas_phonebook.AssociationComplete(
+                    id=association_id,
+                    groupement_id=groupement_ids[i % len(groupement_ids)],
+                    name=faker.company(),
+                    description="Description de l'association",
+                    associated_groups=[],
+                    deactivated=False,
                     mandate_year=2025,
-                    role_name=f"VP {i}",
-                    role_tags=tags[i].name if i < len(tags) else "",
-                    member_order=i,
                 ),
                 db=db,
             )
+            users = await cruds_users.get_users(db=db)
+            tags = list(RoleTags)
+            for j, user in enumerate(random.sample(users, 10)):
+                await cruds_phonebook.create_membership(
+                    membership=schemas_phonebook.MembershipComplete(
+                        id=str(uuid.uuid4()),
+                        user_id=user.id,
+                        association_id=association_id,
+                        mandate_year=2025,
+                        role_name=f"VP {j}",
+                        role_tags=tags[j].name if j < len(tags) else "",
+                        member_order=j,
+                    ),
+                    db=db,
+                )
 
     @classmethod
     async def run(cls, db: AsyncSession, settings: Settings) -> None:
-        await cls.create_association(db)
+        groupement_ids = await cls.create_association_groupement(db=db)
+        await cls.create_association(db, groupement_ids=groupement_ids)
 
     @classmethod
     async def should_run(cls, db: AsyncSession):