added AvailabilityTemplate table to store volunteer general availabilities with days of week, added unit tests, updated other parts to use new table

Author: YashK2005

backend/app/models/AvailabilityTemplate.py

@@ -0,0 +1,35 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, Time
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from sqlalchemy import DateTime
+
+from .Base import Base
+
+
+class AvailabilityTemplate(Base):
+    """
+    Stores recurring weekly availability patterns for volunteers.
+    Each template represents a time slot on a specific day of the week.
+    These templates are projected forward to create specific TimeBlocks for matches.
+    """
+    __tablename__ = "availability_templates"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+
+    # Day of week: 0=Monday, 1=Tuesday, ..., 6=Sunday
+    day_of_week = Column(Integer, nullable=False)
+
+    # Time of day (just time, no date)
+    start_time = Column(Time, nullable=False)  # e.g., 14:00:00
+    end_time = Column(Time, nullable=False)    # e.g., 16:00:00
+
+    # Optional: for future enhancements (e.g., temporarily disable a template)
+    is_active = Column(Boolean, default=True)
+
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    user = relationship("User", back_populates="availability_templates")
+

backend/app/models/TimeBlock.py

@@ -14,6 +14,3 @@ class TimeBlock(Base):
 
     # suggested matches
     suggested_matches = relationship("Match", secondary="suggested_times", back_populates="suggested_time_blocks")
-
-    # the availability that the timeblock is a part of for a given user
-    users = relationship("User", secondary="available_times", back_populates="availability")

backend/app/models/User.py

@@ -45,8 +45,8 @@ class User(Base):
 
     role = relationship("Role")
 
-    # time blocks in an availability for a user
-    availability = relationship("TimeBlock", secondary="available_times", back_populates="users")
+    # recurring availability templates (day of week + time)
+    availability_templates = relationship("AvailabilityTemplate", back_populates="user")
 
     participant_matches = relationship("Match", back_populates="participant", foreign_keys=[Match.participant_id])
 

backend/app/models/__init__.py

@@ -5,10 +5,9 @@
 
 from app.utilities.constants import LOGGER_NAME
 
-from .AvailableTime import available_times
-
 # Make sure all models are here to reflect all current models
 # when autogenerating new migration
+from .AvailabilityTemplate import AvailabilityTemplate
 from .Base import Base
 from .Experience import Experience
 from .Form import Form
@@ -35,8 +34,8 @@
     "Match",
     "MatchStatus",
     "User",
-    "available_times",
     "suggested_times",
+    "AvailabilityTemplate",
     "UserData",
     "Treatment",
     "Experience",

backend/app/schemas/availability.py

@@ -1,14 +1,22 @@
 from typing import List
 from uuid import UUID
+from datetime import time
 
 from pydantic import BaseModel
 
-from app.schemas.time_block import TimeBlockEntity, TimeRange
+from app.schemas.time_block import TimeBlockEntity
+
+
+class AvailabilityTemplateSlot(BaseModel):
+    """Represents a single availability template slot (day of week + time range)"""
+    day_of_week: int  # 0=Monday, 1=Tuesday, ..., 6=Sunday
+    start_time: time  # e.g., 14:00:00
+    end_time: time    # e.g., 16:00:00
 
 
 class CreateAvailabilityRequest(BaseModel):
     user_id: UUID
-    available_times: List[TimeRange]
+    templates: List[AvailabilityTemplateSlot]
 
 
 class CreateAvailabilityResponse(BaseModel):
@@ -22,17 +30,15 @@ class GetAvailabilityRequest(BaseModel):
 
 class AvailabilityEntity(BaseModel):
     user_id: UUID
-    available_times: List[TimeBlockEntity]
+    templates: List[AvailabilityTemplateSlot]
 
 
 class DeleteAvailabilityRequest(BaseModel):
     user_id: UUID
-    delete: list[TimeRange] = []
+    templates: List[AvailabilityTemplateSlot] = []
 
 
 class DeleteAvailabilityResponse(BaseModel):
     user_id: UUID
     deleted: int
-
-    # return the user’s availability after the update
-    availability: List[TimeBlockEntity]
+    templates: List[AvailabilityTemplateSlot]  # remaining templates after deletion

backend/app/schemas/user.py

@@ -12,6 +12,7 @@
 from .time_block import TimeBlockEntity
 from .user_data import UserDataResponse
 from .volunteer_data import VolunteerDataResponse
+from .availability import AvailabilityTemplateSlot
 
 # TODO:
 # confirm complexity rules for fields (such as password)
@@ -143,7 +144,7 @@ class UserResponse(BaseModel):
     form_status: FormStatus
     user_data: Optional[UserDataResponse] = None
     volunteer_data: Optional[VolunteerDataResponse] = None
-    availability: List[TimeBlockEntity] = []
+    availability: List[AvailabilityTemplateSlot] = []
 
     model_config = ConfigDict(from_attributes=True)
 

backend/app/seeds/users.py

@@ -15,6 +15,7 @@
 from app.models.FormSubmission import FormSubmission
 from app.models.Task import Task
 from app.models.SuggestedTime import suggested_times
+from app.models.AvailabilityTemplate import AvailabilityTemplate
 from app.utilities.form_constants import ExperienceId, TreatmentId
 from sqlalchemy import delete
 
@@ -360,10 +361,8 @@ def seed_users(session: Session) -> None:
             if existing_user.volunteer_data:
                 session.delete(existing_user.volunteer_data)
 
-            # Clear availability relationships (delete time blocks)
-            if existing_user.availability:
-                for time_block in list(existing_user.availability):
-                    session.delete(time_block)
+            # Clear availability templates
+            session.query(AvailabilityTemplate).filter_by(user_id=existing_user.id).delete()
 
             # Now delete the user
             session.delete(existing_user)