Raid v2 improvments

app/modules/raid/coredata_raid.py

@@ -13,6 +13,7 @@ class RaidInformation(core_data.BaseCoreData):
     president: EmergencyContact | None = None
     volunteer_responsible: EmergencyContact | None = None
     security_responsible: EmergencyContact | None = None
+    course_responsible: EmergencyContact | None = None
     rescue: EmergencyContact | None = None
     raid_rules_id: str | None = None
     raid_information_id: str | None = None
@@ -22,4 +23,6 @@ class RaidPrice(core_data.BaseCoreData):
     student_price: int | None = None
     partner_price: int | None = None
     external_price: int | None = None
+    scholarship_price: int | None = None
     t_shirt_price: int | None = None
+    volunteer_price: int | None = None

app/modules/raid/cruds_raid.py

@@ -13,33 +13,32 @@
     RaidRegistrationStatus,
 )
 
+PARTICIPANT_DATA_TO_SELECT = [
+    models_raid.RaidParticipant.id_card,
+    models_raid.RaidParticipant.medical_certificate,
+    models_raid.RaidParticipant.student_card,
+    models_raid.RaidParticipant.raid_rules,
+    models_raid.RaidParticipant.parent_authorization,
+    models_raid.RaidParticipant.school_authorization,
+    models_raid.RaidParticipant.user,
+]
+
+TEAM_DATA_TO_SELECT = [
+    selectinload(models_raid.RaidTeam.captain).selectinload(attribute)
+    for attribute in PARTICIPANT_DATA_TO_SELECT
+] + [
+    selectinload(models_raid.RaidTeam.second).selectinload(attribute)
+    for attribute in PARTICIPANT_DATA_TO_SELECT
+]
+
 
 async def create_participant(
     participant: schemas_raid.RaidParticipantCreate,
     db: AsyncSession,
 ) -> None:
     db.add(
         models_raid.RaidParticipant(
-            user_id=participant.user_id,
-            edition_id=participant.edition_id,
-            status=participant.status,
-            address=participant.address,
-            bike_size=participant.bike_size,
-            t_shirt_size=participant.t_shirt_size,
-            situation=participant.situation,
-            other_school=participant.other_school,
-            company=participant.company,
-            diet=participant.diet,
-            id_card_id=participant.id_card_id,
-            medical_certificate_id=participant.medical_certificate_id,
-            security_file_id=participant.security_file_id,
-            student_card_id=participant.student_card_id,
-            raid_rules_id=participant.raid_rules_id,
-            parent_authorization_id=participant.parent_authorization_id,
-            attestation_on_honour=participant.attestation_on_honour,
-            payment=participant.payment,
-            t_shirt_payment=participant.t_shirt_payment,
-            is_minor=participant.is_minor,
+            **participant.model_dump(),
         ),
     )
     await db.flush()
@@ -49,18 +48,24 @@ async def get_all_participants(
     edition_id: UUID,
     db: AsyncSession,
     status: RaidRegistrationStatus | None = None,
-) -> list[schemas_raid.RaidParticipant]:
+) -> list[schemas_raid.RaidParticipantRestricted]:
     stmt = (
         select(models_raid.RaidParticipant)
         .where(models_raid.RaidParticipant.edition_id == edition_id)
-        .options(selectinload("*"))
+        .options(
+            *[selectinload(data) for data in PARTICIPANT_DATA_TO_SELECT],
+        )
     )
     if status is not None:
         stmt = stmt.where(models_raid.RaidParticipant.status == status)
     participants = await db.execute(stmt)
+
+    # Remove security_file from the participants list to avoid including it in the response.
+    found_participants = participants.scalars().all()
+
     return [
-        schemas_raid.RaidParticipant.model_validate(p)
-        for p in participants.scalars().all()
+        schemas_raid.RaidParticipantRestricted.model_validate(participant)
+        for participant in found_participants
     ]
 
 
@@ -146,24 +151,83 @@ async def get_team_by_participant_id(
                 models_raid.RaidTeam.second_id == user_id,
             ),
         )
-        .options(selectinload("*")),
+        .options(
+            *TEAM_DATA_TO_SELECT,
+        ),
     )
     model = team.scalars().first()
     return schemas_raid.RaidTeam.model_validate(model) if model else None
 
 
+async def get_team_including_security_files_by_participant_id(
+    user_id: str,
+    edition_id: UUID,
+    db: AsyncSession,
+) -> schemas_raid.RaidTeamIncludingSecurityFile | None:
+    team = await db.execute(
+        select(models_raid.RaidTeam)
+        .where(
+            models_raid.RaidTeam.edition_id == edition_id,
+            or_(
+                models_raid.RaidTeam.captain_id == user_id,
+                models_raid.RaidTeam.second_id == user_id,
+            ),
+        )
+        .options(
+            *TEAM_DATA_TO_SELECT,
+            selectinload(models_raid.RaidTeam.captain).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+            selectinload(models_raid.RaidTeam.second).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+        ),
+    )
+    model = team.scalars().first()
+    return (
+        schemas_raid.RaidTeamIncludingSecurityFile.model_validate(model)
+        if model
+        else None
+    )
+
+
 async def get_all_teams(
     edition_id: UUID,
     db: AsyncSession,
 ) -> list[schemas_raid.RaidTeam]:
     teams = await db.execute(
         select(models_raid.RaidTeam)
         .where(models_raid.RaidTeam.edition_id == edition_id)
-        .options(selectinload("*")),
+        .options(
+            *TEAM_DATA_TO_SELECT,
+        ),
     )
     return [schemas_raid.RaidTeam.model_validate(t) for t in teams.scalars().all()]
 
 
+async def get_all_teams_including_security_files(
+    edition_id: UUID,
+    db: AsyncSession,
+) -> list[schemas_raid.RaidTeamIncludingSecurityFile]:
+    teams = await db.execute(
+        select(models_raid.RaidTeam)
+        .where(models_raid.RaidTeam.edition_id == edition_id)
+        .options(
+            *TEAM_DATA_TO_SELECT,
+            selectinload(models_raid.RaidTeam.captain).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+            selectinload(models_raid.RaidTeam.second).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+        ),
+    )
+    return [
+        schemas_raid.RaidTeamIncludingSecurityFile.model_validate(t)
+        for t in teams.scalars().all()
+    ]
+
+
 async def get_all_validated_teams(
     edition_id: UUID,
     db: AsyncSession,
@@ -196,7 +260,9 @@ async def get_all_validated_teams(
             Captain.c.status == RaidRegistrationStatus.validated,
             Second.c.status == RaidRegistrationStatus.validated,
         )
-        .options(selectinload("*"))
+        .options(
+            *TEAM_DATA_TO_SELECT,
+        )
     )
     teams = await db.execute(stmt)
     return [schemas_raid.RaidTeam.model_validate(t) for t in teams.scalars().all()]
@@ -209,12 +275,39 @@ async def get_team_by_id(
     team = await db.execute(
         select(models_raid.RaidTeam)
         .where(models_raid.RaidTeam.id == team_id)
-        .options(selectinload("*")),
+        .options(
+            *TEAM_DATA_TO_SELECT,
+        ),
     )
     model = team.scalars().first()
     return schemas_raid.RaidTeam.model_validate(model) if model else None
 
 
+async def get_team_including_security_file_by_id(
+    team_id: str,
+    db: AsyncSession,
+) -> schemas_raid.RaidTeamIncludingSecurityFile | None:
+    team = await db.execute(
+        select(models_raid.RaidTeam)
+        .where(models_raid.RaidTeam.id == team_id)
+        .options(
+            *TEAM_DATA_TO_SELECT,
+            selectinload(models_raid.RaidTeam.captain).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+            selectinload(models_raid.RaidTeam.second).selectinload(
+                models_raid.RaidParticipant.security_file,
+            ),
+        ),
+    )
+    model = team.scalars().first()
+    return (
+        schemas_raid.RaidTeamIncludingSecurityFile.model_validate(model)
+        if model
+        else None
+    )
+
+
 async def create_team(
     team: schemas_raid.RaidTeamCreate,
     db: AsyncSession,
@@ -372,6 +465,8 @@ async def add_security_file(
             emergency_person_name=security_file.emergency_person_name,
             emergency_person_phone=security_file.emergency_person_phone,
             file_id=security_file.file_id,
+            consent_given=security_file.consent_given,
+            consent_given_at=security_file.consent_given_at,
         ),
     )
     await db.flush()
@@ -495,7 +590,7 @@ async def get_document_by_id(
 async def get_user_by_document_id(
     document_id: str,
     db: AsyncSession,
-) -> schemas_raid.RaidParticipant | None:
+) -> schemas_raid.RaidParticipantRestricted | None:
     document = await db.execute(
         select(models_raid.RaidParticipant)
         .where(
@@ -505,12 +600,17 @@ async def get_user_by_document_id(
                 models_raid.RaidParticipant.student_card_id == document_id,
                 models_raid.RaidParticipant.raid_rules_id == document_id,
                 models_raid.RaidParticipant.parent_authorization_id == document_id,
+                models_raid.RaidParticipant.school_authorization_id == document_id,
             ),
         )
-        .options(selectinload("*")),
+        .options(
+            *[selectinload(data) for data in PARTICIPANT_DATA_TO_SELECT],
+        ),
     )
     model = document.scalars().first()
-    return schemas_raid.RaidParticipant.model_validate(model) if model else None
+    return (
+        schemas_raid.RaidParticipantRestricted.model_validate(model) if model else None
+    )
 
 
 async def update_document(
@@ -570,6 +670,38 @@ async def confirm_t_shirt_payment(
     await db.flush()
 
 
+async def confirm_volunteer_payment(
+    user_id: str,
+    edition_id: UUID,
+    db: AsyncSession,
+) -> None:
+    await db.execute(
+        update(models_raid.RaidVolunteer)
+        .where(
+            models_raid.RaidVolunteer.user_id == user_id,
+            models_raid.RaidVolunteer.edition_id == edition_id,
+        )
+        .values(payment=True),
+    )
+    await db.flush()
+
+
+async def confirm_volunteer_t_shirt_payment(
+    user_id: str,
+    edition_id: UUID,
+    db: AsyncSession,
+) -> None:
+    await db.execute(
+        update(models_raid.RaidVolunteer)
+        .where(
+            models_raid.RaidVolunteer.user_id == user_id,
+            models_raid.RaidVolunteer.edition_id == edition_id,
+        )
+        .values(t_shirt_payment=True),
+    )
+    await db.flush()
+
+
 async def validate_attestation_on_honour(
     user_id: str,
     edition_id: UUID,
@@ -590,14 +722,40 @@ async def get_participant_by_user_id(
     user_id: str,
     edition_id: UUID,
     db: AsyncSession,
+) -> schemas_raid.RaidParticipantRestricted | None:
+
+    participant = await db.execute(
+        select(models_raid.RaidParticipant)
+        .where(
+            models_raid.RaidParticipant.user_id == user_id,
+            models_raid.RaidParticipant.edition_id == edition_id,
+        )
+        .options(
+            *[selectinload(data) for data in PARTICIPANT_DATA_TO_SELECT],
+        ),
+    )
+    model = participant.scalars().first()
+    return (
+        schemas_raid.RaidParticipantRestricted.model_validate(model) if model else None
+    )
+
+
+async def get_participant_complete_by_user_id(
+    user_id: str,
+    edition_id: UUID,
+    db: AsyncSession,
 ) -> schemas_raid.RaidParticipant | None:
+
     participant = await db.execute(
         select(models_raid.RaidParticipant)
         .where(
             models_raid.RaidParticipant.user_id == user_id,
             models_raid.RaidParticipant.edition_id == edition_id,
         )
-        .options(selectinload("*")),
+        .options(
+            *[selectinload(data) for data in PARTICIPANT_DATA_TO_SELECT],
+            selectinload(models_raid.RaidParticipant.security_file),
+        ),
     )
     model = participant.scalars().first()
     return schemas_raid.RaidParticipant.model_validate(model) if model else None
@@ -758,6 +916,34 @@ async def get_participant_checkout_by_checkout_id(
     return schemas_raid.RaidParticipantCheckout.model_validate(model) if model else None
 
 
+async def create_volunteer_checkout(
+    checkout: schemas_raid.RaidVolunteerCheckout,
+    db: AsyncSession,
+) -> None:
+    db.add(
+        models_raid.RaidVolunteerCheckout(
+            id=str(uuid.uuid4()),
+            volunteer_user_id=checkout.volunteer_user_id,
+            edition_id=checkout.edition_id,
+            checkout_id=checkout.checkout_id,
+        ),
+    )
+    await db.flush()
+
+
+async def get_volunteer_checkout_by_checkout_id(
+    checkout_id: str,
+    db: AsyncSession,
+) -> schemas_raid.RaidVolunteerCheckout | None:
+    checkout = await db.execute(
+        select(models_raid.RaidVolunteerCheckout).where(
+            models_raid.RaidVolunteerCheckout.checkout_id == checkout_id,
+        ),
+    )
+    model = checkout.scalars().first()
+    return schemas_raid.RaidVolunteerCheckout.model_validate(model) if model else None
+
+
 # --- Edition CRUDs ------------------------------------------------------
 
 
@@ -907,6 +1093,8 @@ async def create_volunteer(
             is_special_driver=volunteer.is_special_driver,
             is_utility_vehicle_driver=volunteer.is_utility_vehicle_driver,
             is_parcours_helper=volunteer.is_parcours_helper,
+            payment=volunteer.payment,
+            t_shirt_payment=volunteer.t_shirt_payment,
         ),
     )
     await db.flush()