Core refacto: move core's schemas and models to groups and users specific files (#673)

### 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/app.py

@@ -22,12 +22,14 @@
 from sqlalchemy.orm import Session
 
 from app import api
-from app.core.config import Settings
 from app.core.core_endpoints import coredata_core, models_core
 from app.core.google_api.google_api import GoogleAPI
+from app.core.groups import models_groups
 from app.core.groups.groups_type import GroupType
-from app.core.log import LogConfig
+from app.core.schools import models_schools
 from app.core.schools.schools_type import SchoolType
+from app.core.utils.config import Settings
+from app.core.utils.log import LogConfig
 from app.dependencies import (
     get_db,
     get_redis_client,
@@ -176,7 +178,7 @@ def initialize_groups(
             exists = initialization.get_group_by_id_sync(group_id=group_type, db=db)
             # We don't want to recreate the groups if they already exist
             if not exists:
-                group = models_core.CoreGroup(
+                group = models_groups.CoreGroup(
                     id=group_type,
                     name=group_type.name,
                     description="Group type",
@@ -202,7 +204,7 @@ def initialize_schools(
             exists = initialization.get_school_by_id_sync(school_id=school.value, db=db)
             # We don't want to recreate the groups if they already exist
             if not exists:
-                db_school = models_core.CoreSchool(
+                db_school = models_schools.CoreSchool(
                     id=school.value,
                     name=school.name,
                     email_regex="null",

app/core/auth/endpoints_auth.py

@@ -20,18 +20,17 @@
 from fastapi.templating import Jinja2Templates
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.core import security
 from app.core.auth import cruds_auth, models_auth, schemas_auth
-from app.core.config import Settings
-from app.core.core_endpoints import models_core
-from app.core.security import (
+from app.core.users import cruds_users, models_users
+from app.core.utils.config import Settings
+from app.core.utils.security import (
     authenticate_user,
     create_access_token,
     create_access_token_RS256,
     generate_token,
     jws_algorithm,
+    jwt_algorithm,
 )
-from app.core.users import cruds_users
 from app.dependencies import (
     get_db,
     get_request_id,
@@ -1024,7 +1023,7 @@ def introspect_access_token(
         payload = jwt.decode(
             access_token,
             settings.ACCESS_TOKEN_SECRET_KEY,
-            algorithms=[security.jwt_algorithm],
+            algorithms=[jwt_algorithm],
         )
         # We want to validate the structure of the payload
         _ = schemas_auth.TokenData(**payload)
@@ -1060,7 +1059,7 @@ async def introspect_refresh_token(
     status_code=200,
 )
 async def auth_get_userinfo(
-    user: models_core.CoreUser = Depends(
+    user: models_users.CoreUser = Depends(
         get_user_from_token_with_scopes([[ScopeType.openid], [ScopeType.profile]]),
     ),
     token_data: schemas_auth.TokenData = Depends(get_token_data),

app/core/core_endpoints/cruds_core.py

@@ -6,10 +6,11 @@
 
 from app.core.core_endpoints import models_core
 from app.core.groups.groups_type import AccountType
+from app.core.users import models_users
 
 
 async def get_modules_by_user(
-    user: models_core.CoreUser,
+    user: models_users.CoreUser,
     db: AsyncSession,
 ) -> list[str]:
     """Return the modules a user has access to"""

app/core/core_endpoints/endpoints_core.py

@@ -6,9 +6,10 @@
 from fastapi.responses import FileResponse
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.core.config import Settings
 from app.core.core_endpoints import cruds_core, models_core, schemas_core
 from app.core.groups.groups_type import AccountType, GroupType
+from app.core.users import models_users
+from app.core.utils.config import Settings
 from app.dependencies import (
     get_db,
     get_settings,
@@ -169,7 +170,7 @@ async def get_favicon():
 )
 async def get_module_visibility(
     db: AsyncSession = Depends(get_db),
-    user: models_core.CoreUser = Depends(is_user_in(GroupType.admin)),
+    user: models_users.CoreUser = Depends(is_user_in(GroupType.admin)),
 ):
     """
     Get all existing module_visibility.
@@ -205,7 +206,7 @@ async def get_module_visibility(
 )
 async def get_user_modules_visibility(
     db: AsyncSession = Depends(get_db),
-    user: models_core.CoreUser = Depends(is_user()),
+    user: models_users.CoreUser = Depends(is_user()),
 ):
     """
     Get group user accessible root
@@ -223,7 +224,7 @@ async def get_user_modules_visibility(
 async def add_module_visibility(
     module_visibility: schemas_core.ModuleVisibilityCreate,
     db: AsyncSession = Depends(get_db),
-    user: models_core.CoreUser = Depends(is_user_in(GroupType.admin)),
+    user: models_users.CoreUser = Depends(is_user_in(GroupType.admin)),
 ):
     """
     Add a new group or account type to a module
@@ -277,7 +278,7 @@ async def delete_module_group_visibility(
     root: str,
     group_id: str,
     db: AsyncSession = Depends(get_db),
-    user: models_core.CoreUser = Depends(is_user_in(GroupType.admin)),
+    user: models_users.CoreUser = Depends(is_user_in(GroupType.admin)),
 ):
     await cruds_core.delete_module_group_visibility(
         root=root,
@@ -294,7 +295,7 @@ async def delete_module_account_type_visibility(
     root: str,
     account_type: AccountType,
     db: AsyncSession = Depends(get_db),
-    user: models_core.CoreUser = Depends(is_user_in(GroupType.admin)),
+    user: models_users.CoreUser = Depends(is_user_in(GroupType.admin)),
 ):
     await cruds_core.delete_module_account_type_visibility(
         root=root,

app/core/core_endpoints/models_core.py

@@ -1,138 +1,15 @@
 """Common model files for all core in order to avoid circular import due to bidirectional relationship"""
 
-from datetime import date, datetime
-from uuid import UUID
+from datetime import date
 
-from sqlalchemy import ForeignKey, String
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
 
 from app.core.groups.groups_type import AccountType
-from app.types.floors_type import FloorsType
 from app.types.membership import AvailableAssociationMembership
 from app.types.sqlalchemy import Base, PrimaryKey
 
 
-class CoreMembership(Base):
-    __tablename__ = "core_membership"
-
-    user_id: Mapped[str] = mapped_column(ForeignKey("core_user.id"), primary_key=True)
-    group_id: Mapped[str] = mapped_column(ForeignKey("core_group.id"), primary_key=True)
-    # A description can be added to the membership
-    # This can be used to note why a user is in a given group
-    description: Mapped[str | None]
-
-
-class CoreUser(Base):
-    __tablename__ = "core_user"
-
-    id: Mapped[str] = mapped_column(
-        primary_key=True,
-        index=True,
-    )  # Use UUID later
-    email: Mapped[str] = mapped_column(unique=True, index=True)
-    school_id: Mapped[UUID] = mapped_column(ForeignKey("core_school.id"))
-    password_hash: Mapped[str]
-    # Depending on the account type, the user may have different rights and access to different features
-    # External users may exist for:
-    # - accounts meant to be used by external services based on Hyperion SSO or Hyperion backend
-    # - new users that need to do additional steps before being able to all features,
-    #   like using a specific email address, going through an inscription process or being manually validated
-    account_type: Mapped[AccountType]
-    name: Mapped[str]
-    firstname: Mapped[str]
-    nickname: Mapped[str | None]
-    birthday: Mapped[date | None]
-    promo: Mapped[int | None]
-    phone: Mapped[str | None]
-    floor: Mapped[FloorsType | None]
-    created_on: Mapped[datetime | None]
-
-    # We use list["CoreGroup"] with quotes as CoreGroup is only defined after this class
-    # Defining CoreUser after CoreGroup would cause a similar issue
-    groups: Mapped[list["CoreGroup"]] = relationship(
-        "CoreGroup",
-        secondary="core_membership",
-        back_populates="members",
-        lazy="selectin",
-        default_factory=list,
-    )
-    school: Mapped["CoreSchool"] = relationship(
-        "CoreSchool",
-        lazy="selectin",
-        init=False,
-    )
-
-
-class CoreUserUnconfirmed(Base):
-    __tablename__ = "core_user_unconfirmed"
-
-    id: Mapped[str] = mapped_column(primary_key=True)
-    # The email column should not be unique.
-    # Someone can indeed create more than one user creation request,
-    # for example after losing the previously received confirmation email.
-    # For each user creation request, a row will be added in this table with a new token
-    email: Mapped[str]
-    activation_token: Mapped[str]
-    created_on: Mapped[datetime]
-    expire_on: Mapped[datetime]
-
-
-class CoreUserRecoverRequest(Base):
-    __tablename__ = "core_user_recover_request"
-
-    # The email column should not be unique.
-    # Someone can indeed create more than one password reset request,
-    email: Mapped[str]
-    user_id: Mapped[str]
-    reset_token: Mapped[str] = mapped_column(primary_key=True)
-    created_on: Mapped[datetime]
-    expire_on: Mapped[datetime]
-
-
-class CoreUserEmailMigrationCode(Base):
-    """
-    The ECL changed the email format for student users, requiring them to migrate their email.
-    """
-
-    __tablename__ = "core_user_email_migration_code"
-
-    user_id: Mapped[str] = mapped_column(ForeignKey("core_user.id"), primary_key=True)
-    new_email: Mapped[str]
-    old_email: Mapped[str]
-
-    confirmation_token: Mapped[str] = mapped_column(
-        String,
-        nullable=False,
-        primary_key=True,
-    )
-
-    # If the user should become an external or a member user after the email change
-    make_user_external: Mapped[bool] = mapped_column(default=False)
-
-
-class CoreGroup(Base):
-    __tablename__ = "core_group"
-
-    id: Mapped[str] = mapped_column(primary_key=True, index=True)
-    name: Mapped[str] = mapped_column(index=True, unique=True)
-    description: Mapped[str | None]
-
-    members: Mapped[list["CoreUser"]] = relationship(
-        "CoreUser",
-        secondary="core_membership",
-        back_populates="groups",
-        default_factory=list,
-    )
-
-
-class CoreSchool(Base):
-    __tablename__ = "core_school"
-
-    id: Mapped[PrimaryKey]
-    name: Mapped[str] = mapped_column(unique=True)
-    email_regex: Mapped[str]
-
-
 class CoreAssociationMembership(Base):
     __tablename__ = "core_association_membership"