Merge pull request #34 from GenerateNU/28-registration-and-unregistration

28 registration and unregistration

Author: adammotts

app/api/endpoints/registration.py

@@ -1,12 +1,12 @@
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 
 from app.api.endpoints.user import get_current_user
 from app.models.registration import registration_model
 from app.models.volunteer import volunteer_model
 from app.schemas.event import Event
-from app.schemas.registration import Registration, RegistrationStatus
+from app.schemas.registration import CreateRegistrationRequest, Registration, RegistrationStatus
 from app.schemas.user import User, UserType
 
 router = APIRouter()
@@ -21,7 +21,9 @@ async def get_volunteers_by_event(event_id: str) -> list[Registration]:
 @router.get("/events/{volunteer_id}", response_model=list[Event])
 async def get_events_by_volunteer(
     volunteer_id: str,
-    status: Annotated[RegistrationStatus | None, Query(description="Filter by status")] = None,
+    registration_status: Annotated[
+        RegistrationStatus | None, Query(description="Filter by status")
+    ] = None,
     current_user: Annotated[User, Depends(get_current_user)] = None,
 ) -> list[Event]:
     volunteer = await volunteer_model.get_volunteer_by_id(volunteer_id)
@@ -37,4 +39,43 @@ async def get_events_by_volunteer(
     elif current_user.user_type != UserType.ADMIN:
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Access denied")
 
-    return await registration_model.get_events_by_volunteer(volunteer_id, status)
+    return await registration_model.get_events_by_volunteer(volunteer_id, registration_status)
+
+
+@router.post("/new", response_model=Registration)
+async def create_registrion(
+    registration: Annotated[CreateRegistrationRequest, Body(...)],
+    current_user: Annotated[User, Depends(get_current_user)],
+) -> Registration:
+    if current_user.user_type != UserType.VOLUNTEER:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Only volunteers can register for events"
+        )
+
+    if current_user.entity_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="You must be associated with a volunteer profile to register for an event",
+        )
+
+    return await registration_model.create_registration(registration, current_user.entity_id)
+
+
+@router.put("/unregister/{registration_id}", response_model=Registration)
+async def unregister_registration(
+    registration_id: str,
+    current_user: Annotated[User, Depends(get_current_user)],
+) -> Registration:
+    if current_user.user_type != UserType.VOLUNTEER:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only volunteers can unregister from events",
+        )
+
+    if current_user.entity_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="You must be associated with a volunteer profile to unregister from an event",
+        )
+
+    return await registration_model.unregister_registration(registration_id, current_user.entity_id)

app/models/registration.py

@@ -1,11 +1,13 @@
+from datetime import datetime
+
 from bson import ObjectId
 from fastapi import HTTPException, status
 from motor.motor_asyncio import AsyncIOMotorCollection  # noqa: TCH002
 
 from app.database.mongodb import db
 from app.models.event import event_model
 from app.schemas.event import Event
-from app.schemas.registration import Registration, RegistrationStatus
+from app.schemas.registration import CreateRegistrationRequest, Registration, RegistrationStatus
 
 
 class RegistrationModel:
@@ -70,10 +72,71 @@ async def get_events_by_volunteer(
         event_docs = await self.registrations.aggregate(pipeline).to_list(length=None)
         return [event_model.to_event(event) for event in event_docs]
 
-    def _to_volunteer(self, doc) -> Registration:
+    async def create_registration(
+        self, registration: CreateRegistrationRequest, volunteer_id: str
+    ) -> Registration:
+        event_obj_id = ObjectId(registration.event_id)
+        volunteer_obj_id = ObjectId(volunteer_id)
+
+        existing = await self.registrations.find_one(
+            {"event_id": event_obj_id, "volunteer_id": volunteer_obj_id}
+        )
+
+        if existing:
+            await self.registrations.update_one(
+                {"_id": existing["_id"]},
+                {
+                    "$set": {
+                        "registration_status": RegistrationStatus.UPCOMING,
+                        "registered_at": datetime.now(),
+                    }
+                },
+            )
+            updated_doc = await self.registrations.find_one({"_id": existing["_id"]})
+            return self._to_registration(updated_doc)
+
+        registration_data = {
+            "event_id": event_obj_id,
+            "volunteer_id": volunteer_obj_id,
+            "registered_at": datetime.now(),
+            "registration_status": RegistrationStatus.UPCOMING,
+            "clocked_in": False,
+            "clocked_out": False,
+        }
+
+        result = await self.registrations.insert_one(registration_data)
+        inserted_doc = await self.registrations.find_one({"_id": result.inserted_id})
+
+        return self._to_registration(inserted_doc)
+
+    async def unregister_registration(
+        self, registration_id: str, volunteer_id: str
+    ) -> Registration:
+        registration = await self.registrations.find_one({"_id": ObjectId(registration_id)})
+
+        if not registration:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Registration not found"
+            )
+
+        if str(registration["volunteer_id"]) != volunteer_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Not authorized to unregister from this event",
+            )
+
+        await self.registrations.update_one(
+            {"_id": ObjectId(registration_id)},
+            {"$set": {"registration_status": RegistrationStatus.UNREGISTERED}},
+        )
+        updated_doc = await self.registrations.find_one({"_id": ObjectId(registration_id)})
+        return self._to_registration(updated_doc)
+
+    def _to_registration(self, doc) -> Registration:
         registration_data = doc.copy()
         registration_data["id"] = str(registration_data["_id"])
         registration_data["volunteer_id"] = str(registration_data["volunteer_id"])
+        registration_data["event_id"] = str(registration_data["event_id"])
         return Registration(**registration_data)
 
 

app/schemas/registration.py

@@ -8,6 +8,7 @@ class RegistrationStatus(str, Enum):
     UPCOMING = "upcoming"
     COMPLETED = "completed"
     INCOMPLETED = "incompleted"
+    UNREGISTERED = "unregistered"
 
 
 class Registration(BaseModel):
@@ -21,3 +22,7 @@ class Registration(BaseModel):
 
     class Config:
         from_attributes = True
+
+
+class CreateRegistrationRequest(BaseModel):
+    event_id: str