feat(phonebook): use modular association groupements (#759)

### Description

Please explain the changes you made here.

### Checklist

- [ ] Created tests which fail without the change (if possible)
- [ ] All tests passing
- [ ] Extended the documentation, if necessary

Author: Rotheem

app/modules/phonebook/cruds_phonebook.py

@@ -1,79 +1,92 @@
 import random
 import uuid
 
+from faker import Faker
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.core.groups.factory_groups import CoreGroupsFactory
 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]
+    depends_on = [CoreUsersFactory, CoreGroupsFactory]
 
     @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",
+                manager_group_id=CoreGroupsFactory.groups_ids[0],
             ),
             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",
+                manager_group_id=CoreGroupsFactory.groups_ids[0],
             ),
             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",
+                manager_group_id=CoreGroupsFactory.groups_ids[1],
             ),
             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):

app/modules/phonebook/endpoints_phonebook.py

@@ -1,10 +1,10 @@
 from typing import TYPE_CHECKING
+from uuid import UUID
 
 from sqlalchemy import ForeignKey
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from app.modules.phonebook.types_phonebook import Kinds
-from app.types.sqlalchemy import Base
+from app.types.sqlalchemy import Base, PrimaryKey
 
 if TYPE_CHECKING:
     from app.core.groups.models_groups import CoreGroup
@@ -31,13 +31,24 @@ class Membership(Base):
     member_order: Mapped[int]
 
 
+class AssociationGroupement(Base):
+    __tablename__ = "phonebook_association_groupement"
+
+    id: Mapped[PrimaryKey]
+    manager_group_id: Mapped[str] = mapped_column(ForeignKey("core_group.id"))
+    name: Mapped[str] = mapped_column(index=True, unique=True)
+
+
 class Association(Base):
     __tablename__ = "phonebook_association"
 
     id: Mapped[str] = mapped_column(primary_key=True, index=True)
     name: Mapped[str] = mapped_column(index=True)
     description: Mapped[str | None]
-    kind: Mapped[Kinds]
+    groupement_id: Mapped[UUID] = mapped_column(
+        ForeignKey("phonebook_association_groupement.id"),
+        index=True,
+    )
     mandate_year: Mapped[int]
     deactivated: Mapped[bool]
     associated_groups: Mapped[list["CoreGroup"]] = relationship(

app/modules/phonebook/factory_phonebook.py

@@ -1,7 +1,8 @@
+from uuid import UUID
+
 from pydantic import BaseModel, ConfigDict
 
 from app.core.users.schemas_users import CoreUserSimple
-from app.modules.phonebook.types_phonebook import Kinds
 
 
 class RoleTagsReturn(BaseModel):
@@ -19,7 +20,7 @@ class RoleTagsBase(BaseModel):
 
 class AssociationBase(BaseModel):
     name: str
-    kind: Kinds
+    groupement_id: UUID
     mandate_year: int
     description: str | None = None
     associated_groups: list[str] = []  # Should be a list of ids
@@ -34,7 +35,7 @@ class AssociationComplete(AssociationBase):
 
 class AssociationEdit(BaseModel):
     name: str | None = None
-    kind: Kinds | None = None
+    groupement_id: UUID | None = None
     description: str | None = None
     mandate_year: int | None = None
 
@@ -48,7 +49,7 @@ class MembershipBase(BaseModel):
     association_id: str
     mandate_year: int
     role_name: str
-    role_tags: str | None = None  # "roletag1;roletag2;..."
+    role_tags: str = ""  # "roletag1;roletag2;..."
     member_order: int
 
     model_config = ConfigDict(from_attributes=True)
@@ -80,5 +81,14 @@ class MemberComplete(MemberBase):
     model_config = ConfigDict(from_attributes=True)
 
 
-class KindsReturn(BaseModel):
-    kinds: list[Kinds]
+class AssociationGroupementBase(BaseModel):
+    name: str
+    manager_group_id: str
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class AssociationGroupement(AssociationGroupementBase):
+    id: UUID
+
+    model_config = ConfigDict(from_attributes=True)

app/modules/phonebook/models_phonebook.py

@@ -7,12 +7,3 @@ class RoleTags(Enum):
     treso = "Trez'"
     resp_co = "Respo Com'"
     resp_part = "Respo Partenariats"
-
-
-class Kinds(Enum):
-    comity = "Comité"
-    section_ae = "Section AE"
-    club_ae = "Club AE"
-    section_use = "Section USE"
-    club_use = "Club USE"
-    association_independant = "Asso indé"