Feat : Add base to allow factory setup (#375)

Co-authored-by: Warix <[email protected]>
Co-authored-by: cotanoine <[email protected]>

Author: 3 people

app/api.py

@@ -7,5 +7,5 @@
 api_router = APIRouter()
 
 
-for core_module in all_modules:
-    api_router.include_router(core_module.router)
+for module in all_modules:
+    api_router.include_router(module.router)

app/app.py

@@ -10,6 +10,7 @@
 import alembic.command as alembic_command
 import alembic.config as alembic_config
 import alembic.migration as alembic_migration
+import redis
 from calypsso import get_calypsso_app
 from fastapi import FastAPI, HTTPException, Request, Response, status
 from fastapi.encoders import jsonable_encoder
@@ -56,6 +57,8 @@
 if TYPE_CHECKING:
     import redis
 
+    from app.types.factory import Factory
+
 
 # NOTE: We can not get loggers at the top of this file like we do in other files
 # as the loggers are not yet initialized
@@ -226,6 +229,66 @@ def initialize_schools(
                     )
 
 
+async def run_factories(
+    db: AsyncSession,
+    settings: Settings,
+    hyperion_error_logger: logging.Logger,
+) -> None:
+    """Run the factories to create default data in the database"""
+    if not settings.USE_FACTORIES:
+        return
+
+    hyperion_error_logger.info("Startup: Factories enabled")
+    # Importing the core_factory at the beginning of the factories.
+    factories_list: list[Factory] = []
+    for module in all_modules:
+        if module.factory:
+            factories_list.append(module.factory)
+            hyperion_error_logger.info(
+                f"Module {module.root} declares a factory {module.factory.__class__.__name__} with dependencies {module.factory.depends_on}",
+            )
+        else:
+            hyperion_error_logger.warning(
+                f"Module {module.root} does not declare a factory. It won't provide any base data.",
+            )
+
+    # We have to run the factories in a specific order to make sure the dependencies are met
+    # For that reason, we will run the first factory that has no dependencies, after that we remove it from the list of the dependencies from the other factories
+    # And we loop until there are no more factories to run and we use a boolean to avoid infinite loops with circular dependencies
+    no_factory_run_during_last_loop = False
+    ran_factories: list[type[Factory]] = []
+    while len(factories_list) > 0 and not no_factory_run_during_last_loop:
+        no_factory_run_during_last_loop = True
+        for factory in factories_list:
+            if all(depend in ran_factories for depend in factory.depends_on):
+                no_factory_run_during_last_loop = False
+                # Check if the factory should be run
+                if await factory.should_run(db):
+                    hyperion_error_logger.info(
+                        f"Startup: Running factory {factory.__class__.__name__}",
+                    )
+                    try:
+                        await factory.run(db, settings)
+                    except Exception as error:
+                        hyperion_error_logger.fatal(
+                            f"Startup: Could not run factories: {error}",
+                        )
+                        raise
+                else:
+                    hyperion_error_logger.info(
+                        f"Startup: Factory {factory.__class__.__name__} is not necessary, skipping it",
+                    )
+                ran_factories.append(factory.__class__)
+                factories_list.remove(factory)
+                break
+        if no_factory_run_during_last_loop:
+            hyperion_error_logger.error(
+                "Factories are not correctly configured, some factories are not running.",
+            )
+            break
+    hyperion_error_logger.info("Startup: Factories have been run")
+
+
 def initialize_module_visibility(
     sync_engine: Engine,
     hyperion_error_logger: logging.Logger,
@@ -487,7 +550,18 @@ async def init_lifespan(
         get_db,
         get_db,
     )
-
+    # We need to run the factories only once across all the workers
+    async for db in get_db_dependency(state):
+        await initialization.use_lock_for_workers(
+            run_factories,
+            "run_factories",
+            redis_client,
+            number_of_workers,
+            hyperion_error_logger,
+            db=db,
+            settings=settings,
+            hyperion_error_logger=hyperion_error_logger,
+        )
     async for db in get_db_dependency(state):
         await initialization.use_lock_for_workers(
             init_google_API,

app/core/auth/endpoints_auth.py

@@ -50,6 +50,7 @@
     root="auth",
     tag="Auth",
     router=router,
+    factory=None,
 )
 
 templates = Jinja2Templates(directory="assets/templates")

app/core/core_endpoints/endpoints_core.py

@@ -1,4 +1,3 @@
-import logging
 from os import path
 from pathlib import Path
 
@@ -23,13 +22,12 @@
 router = APIRouter(tags=["Core"])
 
 core_module = CoreModule(
-    root="",
+    root="core",
     tag="Core",
     router=router,
+    factory=None,
 )
 
-hyperion_error_logger = logging.getLogger("hyperion.error")
-
 
 @router.get(
     "/information",

app/core/google_api/endpoints_google_api.py

@@ -17,6 +17,7 @@
     root="google-api",
     tag="GoogleAPI",
     router=router,
+    factory=None,
 )
 
 hyperion_error_logger = logging.getLogger("hyperion.error")

app/core/groups/endpoints_groups.py

@@ -11,6 +11,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.groups import cruds_groups, models_groups, schemas_groups
+from app.core.groups.factory_groups import CoreGroupsFactory
 from app.core.groups.groups_type import GroupType
 from app.core.notification.utils_notification import get_topics_restricted_to_group_id
 from app.core.users import cruds_users
@@ -30,6 +31,7 @@
     root="groups",
     tag="Groups",
     router=router,
+    factory=CoreGroupsFactory(),
 )
 
 hyperion_security_logger = logging.getLogger("hyperion.security")

app/core/groups/factory_groups.py

@@ -0,0 +1,58 @@
+import random
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.groups import cruds_groups
+from app.core.groups.groups_type import GroupType
+from app.core.groups.models_groups import CoreGroup, CoreMembership
+from app.core.users.factory_users import CoreUsersFactory
+from app.core.utils.config import Settings
+from app.types.factory import Factory
+
+
+class CoreGroupsFactory(Factory):
+    groups_ids = [
+        str(uuid.uuid4()),
+        str(uuid.uuid4()),
+    ]
+
+    depends_on = [CoreUsersFactory]
+
+    @classmethod
+    async def create_core_groups(cls, db: AsyncSession):
+        groups = ["Oui", "Pixels"]
+        descriptions = ["Groupe de test", "Groupe de test 2"]
+        for i in range(len(groups)):
+            await cruds_groups.create_group(
+                db=db,
+                group=CoreGroup(
+                    id=cls.groups_ids[i],
+                    name=groups[i],
+                    description=descriptions[i],
+                ),
+            )
+
+    @classmethod
+    async def create_core_memberships(cls, db: AsyncSession):
+        for i in range(len(cls.groups_ids)):
+            users = random.sample(CoreUsersFactory.other_users_id, 10)
+
+            for user_id in users:
+                await cruds_groups.create_membership(
+                    db=db,
+                    membership=CoreMembership(
+                        group_id=cls.groups_ids[i],
+                        user_id=user_id,
+                        description=None,
+                    ),
+                )
+
+    @classmethod
+    async def run(cls, db: AsyncSession, settings: Settings) -> None:
+        await cls.create_core_groups(db=db)
+        await cls.create_core_memberships(db=db)
+
+    @classmethod
+    async def should_run(cls, db: AsyncSession):
+        return len(await cruds_groups.get_groups(db=db)) == len(GroupType)

app/core/memberships/cruds_memberships.py

@@ -79,7 +79,7 @@ async def get_association_membership_by_id(
     )
 
 
-def create_association_membership(
+async def create_association_membership(
     db: AsyncSession,
     membership: schemas_memberships.MembershipSimple,
 ):
@@ -347,7 +347,7 @@ async def get_user_membership_by_id(
     )
 
 
-def create_user_membership(
+async def create_user_membership(
     db: AsyncSession,
     user_membership: schemas_memberships.UserMembershipSimple,
 ):

app/core/memberships/endpoints_memberships.py

@@ -7,7 +7,11 @@
 
 from app.core.groups import cruds_groups
 from app.core.groups.groups_type import GroupType
-from app.core.memberships import cruds_memberships, schemas_memberships
+from app.core.memberships import (
+    cruds_memberships,
+    schemas_memberships,
+)
+from app.core.memberships.factory_memberships import CoreMembershipsFactory
 from app.core.memberships.utils_memberships import validate_user_new_membership
 from app.core.users import cruds_users, models_users, schemas_users
 from app.dependencies import (
@@ -25,6 +29,7 @@
     root="memberships",
     tag="Memberships",
     router=router,
+    factory=CoreMembershipsFactory(),
 )
 
 
@@ -128,7 +133,7 @@ async def create_association_membership(
         id=uuid.uuid4(),
     )
 
-    cruds_memberships.create_association_membership(
+    await cruds_memberships.create_association_membership(
         db=db,
         membership=db_association_membership,
     )
@@ -305,7 +310,10 @@ async def create_user_membership(
     )
     await validate_user_new_membership(db_user_membership, db)
 
-    cruds_memberships.create_user_membership(db=db, user_membership=db_user_membership)
+    await cruds_memberships.create_user_membership(
+        db=db,
+        user_membership=db_user_membership,
+    )
 
     await db.flush()
 
@@ -369,7 +377,7 @@ async def add_batch_membership(
             end_date=detail.end_date,
         )
         if len(stored_memberships) == 0:
-            cruds_memberships.create_user_membership(
+            await cruds_memberships.create_user_membership(
                 db=db,
                 user_membership=schemas_memberships.UserMembershipSimple(
                     id=uuid.uuid4(),

app/core/memberships/factory_memberships.py

@@ -0,0 +1,91 @@
+import datetime
+import random
+from uuid import uuid4
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.groups.groups_type import GroupType
+from app.core.memberships import cruds_memberships
+from app.core.memberships.schemas_memberships import (
+    MembershipSimple,
+    UserMembershipSimple,
+)
+from app.core.users.factory_users import CoreUsersFactory
+from app.core.utils.config import Settings
+from app.types.factory import Factory
+
+
+class CoreMembershipsFactory(Factory):
+    memberships_ids = [
+        uuid4(),
+        uuid4(),
+    ]
+    memberships_names = [
+        "AEECL",
+        "USEECL",
+    ]
+    memberships_manager_group_id = [
+        GroupType.BDE.value,
+        GroupType.BDS.value,
+    ]
+
+    depends_on = [CoreUsersFactory]
+
+    @classmethod
+    async def run(cls, db: AsyncSession, settings: Settings) -> None:
+        for i in range(len(cls.memberships_ids)):
+            await cruds_memberships.create_association_membership(
+                db,
+                MembershipSimple(
+                    id=cls.memberships_ids[i],
+                    name=cls.memberships_names[i],
+                    manager_group_id=cls.memberships_manager_group_id[i],
+                ),
+            )
+
+            members = random.sample(
+                CoreUsersFactory.other_users_id,
+                20,
+            )
+            for user_id in members:
+                await cruds_memberships.create_user_membership(
+                    db=db,
+                    user_membership=UserMembershipSimple(
+                        id=uuid4(),
+                        user_id=user_id,
+                        association_membership_id=cls.memberships_ids[i],
+                        start_date=datetime.datetime(
+                            random.randint(2020, 2023),  # noqa: S311
+                            random.randint(1, 12),  # noqa: S311
+                            random.randint(1, 28),  # noqa: S311
+                            tzinfo=datetime.UTC,
+                        ),
+                        end_date=datetime.datetime(
+                            random.randint(2025, 2027),  # noqa: S311
+                            random.randint(1, 12),  # noqa: S311
+                            random.randint(1, 28),  # noqa: S311
+                            tzinfo=datetime.UTC,
+                        ),
+                    ),
+                )
+        await db.commit()
+
+    @classmethod
+    async def should_run(cls, db: AsyncSession):
+        result = (
+            len(
+                await cruds_memberships.get_association_memberships(
+                    db=db,
+                ),
+            )
+            == 0
+        )
+        if not result:
+            registered_memberships = (
+                await cruds_memberships.get_association_memberships(
+                    db=db,
+                )
+            )
+            cls.memberships_ids = [
+                membership.id for membership in registered_memberships
+            ]