feat(coworking): operating hours editor

.devcontainer/devcontainer.json

@@ -8,6 +8,7 @@
         1561,
         1562
     ],
+
     "customizations": {
         "vscode": {
             "extensions": [

backend/api/coworking/__init__.py

@@ -0,0 +1,14 @@
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from backend.services.coworking.exceptions import OperatingHoursCannotOverlapException
+
+
+def _operating_hours_overlap_exception(
+    request: Request, e: OperatingHoursCannotOverlapException
+):
+    return JSONResponse(status_code=400, content={"message": str(e)})
+
+
+exception_handlers = [
+    (OperatingHoursCannotOverlapException, _operating_hours_overlap_exception)
+]

backend/api/coworking/operating_hours.py

@@ -5,12 +5,14 @@
 from datetime import datetime, timedelta
 from typing import Sequence
 from fastapi import APIRouter, Depends
+
+from backend.models.coworking.operating_hours import OperatingHoursDraft
 from ..authentication import registered_user
 from ...models import User
 from ...models.coworking import OperatingHours, TimeRange
 from ...services.coworking import OperatingHoursService
 
-__authors__ = ["Kris Jordan"]
+__authors__ = ["Kris Jordan", "Tobenna Okoli", "David Foss"]
 __copyright__ = "Copyright 2023"
 __license__ = "MIT"
 
@@ -35,23 +37,32 @@ def get_operating_hours(
 
 @api.post("", response_model=OperatingHours, tags=["Coworking"])
 def new_operating_hours(
-    operating_hours_range: TimeRange,
+    operating_hours: OperatingHoursDraft,
+    subject: User = Depends(registered_user),
+    operating_hours_svc: OperatingHoursService = Depends(),
+):
+    """Create new opening hours for the XL."""
+    return operating_hours_svc.create(subject, operating_hours)
+
+
+@api.put("", response_model=OperatingHours, tags=["Coworking"])
+def update_operating_hours(
+    operating_hours: OperatingHoursDraft,
+    cascade: bool = False,
     subject: User = Depends(registered_user),
     operating_hours_svc: OperatingHoursService = Depends(),
 ):
     """Create new opening hours for the XL."""
-    time_range = TimeRange(
-        start=operating_hours_range.start, end=operating_hours_range.end
-    )
-    return operating_hours_svc.create(subject, time_range)
+    return operating_hours_svc.update(subject, operating_hours, cascade)
 
 
 @api.delete("/{id}", tags=["Coworking"])
 def delete_operating_hours(
     id: int,
+    cascade: bool = False,
     subject: User = Depends(registered_user),
     operating_hours_svc: OperatingHoursService = Depends(),
 ):
     """Delete operating hours for the XL."""
     operating_hours = operating_hours_svc.get_by_id(id)
-    return operating_hours_svc.delete(subject, operating_hours)
+    return operating_hours_svc.delete(subject, operating_hours, cascade)

backend/entities/coworking/operating_hours_entity.py

@@ -1,14 +1,19 @@
 """Entity for Operating Hours.""" ""
 
-from sqlalchemy import Integer, DateTime, Index
+from sqlalchemy import ForeignKey, Integer, DateTime, Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from backend.entities.coworking.operating_hours_recurrence_entity import (
+    OperatingHoursRecurrenceEntity,
+)
+from backend.models.coworking.operating_hours import OperatingHoursDraft
 from ..entity_base import EntityBase
 from ...models.coworking import OperatingHours
 from datetime import datetime
 from typing import Self
 
-__authors__ = ["Kris Jordan"]
-__copyright__ = "Copyright 2023"
+__authors__ = ["Kris Jordan", "David Foss"]
+__copyright__ = "Copyright 2024"
 __license__ = "MIT"
 
 
@@ -24,12 +29,23 @@ class OperatingHoursEntity(EntityBase):
     start: Mapped[datetime] = mapped_column(DateTime, index=True)
     end: Mapped[datetime] = mapped_column(DateTime, index=True)
 
+    recurrence_id: Mapped[int] = mapped_column(
+        ForeignKey("coworking__operating_hours_recurrence.id"), nullable=True
+    )
+    recurrence: Mapped[OperatingHoursRecurrenceEntity] = relationship()
+
     def to_model(self) -> OperatingHours:
         """Converts the entity to a model.
 
         Returns:
             OperatingHours: The model representation of the entity."""
-        return OperatingHours(id=self.id, start=self.start, end=self.end)
+        return OperatingHours(
+            id=self.id,
+            start=self.start,
+            end=self.end,
+            recurrence_id=self.recurrence_id if self.recurrence_id else None,
+            recurrence=self.recurrence.to_model() if self.recurrence else None,
+        )
 
     @classmethod
     def from_model(cls, model: OperatingHours) -> Self:
@@ -40,4 +56,34 @@ def from_model(cls, model: OperatingHours) -> Self:
 
         Returns:
             Self: The entity (not yet persisted)."""
-        return cls(id=model.id, start=model.start, end=model.end)
+        return cls(
+            id=model.id,
+            start=model.start,
+            end=model.end,
+            recurrence_id=model.recurrence_id if model.recurrence_id else None,
+            recurrence=(
+                OperatingHoursRecurrenceEntity.from_model(model.recurrence)
+                if model.recurrence
+                else None
+            ),
+        )
+
+    @classmethod
+    def from_draft(cls, model: OperatingHoursDraft) -> Self:
+        """Create an OperatingHoursEntity from a OperatingHoursDraft model.
+
+        Args:
+            model (OperatingHoursDraft): The model to create the entity from.
+
+        Returns:
+            Self: The entity (not yet persisted)."""
+        return cls(
+            id=model.id,
+            start=model.start,
+            end=model.end,
+            recurrence=(
+                OperatingHoursRecurrenceEntity.from_model(model.recurrence)
+                if model.recurrence
+                else None
+            ),
+        )

backend/entities/coworking/operating_hours_recurrence_entity.py

@@ -0,0 +1,56 @@
+"""Entity for Operating Hours Recurrence.""" ""
+
+from sqlalchemy import Integer, DateTime, Index
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.models.coworking.operating_hours import (
+    OperatingHoursRecurrence,
+)
+from ..entity_base import EntityBase
+from ...models.coworking import OperatingHours
+from datetime import datetime
+from typing import Self
+
+__authors__ = ["David Foss"]
+__copyright__ = "Copyright 2024"
+__license__ = "MIT"
+
+
+class OperatingHoursRecurrenceEntity(EntityBase):
+    """Entity for Operating Hours Recurrence."""
+
+    __tablename__ = "coworking__operating_hours_recurrence"
+    __table_args__ = (
+        Index("coworking__operating_hours_recurrence_idx", "end_date", unique=False),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    end_date: Mapped[datetime] = mapped_column(DateTime(timezone=True), index=True)
+
+    # recurs_on saves the days the operating hours recurs on as a bitmask stored as an integer
+    # Starts with 0 being Monday, following python datetime convention
+    recurs_on: Mapped[int] = mapped_column(Integer)
+
+    def to_model(self) -> OperatingHoursRecurrence:
+        """Converts the entity to a model.
+
+        Returns:
+            OperatingHoursRecurrence: The model representation of the entity."""
+        return OperatingHoursRecurrence(
+            id=self.id, end_date=self.end_date, recurs_on=self.recurs_on
+        )
+
+    @classmethod
+    def from_model(cls, model: OperatingHoursRecurrence) -> Self:
+        """Create an OperatingHoursRecurrenceEntity from a OperatingHoursRecurrence model.
+
+        Args:
+            model (OperatingHoursRecurrence): The model to create the entity from.
+
+        Returns:
+            Self: The entity (not yet persisted)."""
+        return cls(
+            id=model.id,
+            end_date=model.end_date,
+            recurs_on=model.recurs_on,
+        )

backend/main.py

@@ -40,6 +40,8 @@
     CourseDataScrapingException,
 )
 
+from .services.coworking.exceptions import OperatingHoursCannotOverlapException
+
 __authors__ = ["Kris Jordan"]
 __copyright__ = "Copyright 2023"
 __license__ = "MIT"
@@ -153,9 +155,9 @@ def recurring_office_hour_event_exception(
 
 
 # Add feature-specific exception handling middleware
-from .api import events
+from .api import events, coworking
 
-feature_exception_handlers = [events.exception_handlers]
+feature_exception_handlers = [events.exception_handlers, coworking.exception_handlers]
 
 for feature_exception_handler in feature_exception_handlers:
     for exception, handler in feature_exception_handler:

backend/models/academics/my_courses.py

@@ -103,6 +103,13 @@ class OfficeHourStatisticsOverview(BaseModel):
     history: list[OfficeHourTicketOverview]
 
 
+class OfficeHourStatisticsOverview(BaseModel):
+    # add more
+    average_minutes: int
+    total_tickets_called: int
+    history: list[OfficeHourTicketOverview]
+
+
 class OfficeHourQueueOverview(BaseModel):
     id: int
     type: str

backend/models/coworking/operating_hours.py

@@ -1,15 +1,37 @@
 """Models open hours of the XL."""
 
-
 from pydantic import BaseModel
 from .time_range import TimeRange
+from datetime import datetime, date
 
 
-__authors__ = ["Kris Jordan, Yuvraj Jain"]
+__authors__ = ["Kris Jordan", "Yuvraj Jain", "David Foss"]
 __copyright__ = "Copyright 2024"
 __license__ = "MIT"
 
+
+class OperatingHoursRecurrence(BaseModel):
+    id: int | None = None
+
+    end_date: datetime
+
+    # Bitmask saved as an int
+    # Monday is 0, Sunday is 6 (following python datetime standard)
+    recurs_on: int
+
+
 class OperatingHours(TimeRange, BaseModel):
     """The operating hours of the XL."""
 
+    id: int
+
+    recurrence_id: int | None = None
+    recurrence: OperatingHoursRecurrence | None = None
+
+
+class OperatingHoursDraft(TimeRange, BaseModel):
+    """Data for an operating hours draft (for creation and editing)."""
+
     id: int | None = None
+
+    recurrence: OperatingHoursRecurrence | None = None

backend/models/office_hours/ticket.py

@@ -45,13 +45,11 @@ class OfficeHoursTicket(NewOfficeHoursTicket):
     caller_notes: str = ""
     caller_id: int | None
 
-
 class OfficeHoursTicketCsvRow(BaseModel):
     """
     Pydantic model to represent a user's ticket in CSV format, which is used for
     exporting ticket data to a CSV file in the ticket statistics feature.
     """
-
     student: str
     description: str
     type: str

backend/script/reset_demo.py

@@ -14,6 +14,9 @@
 import subprocess
 from sqlalchemy import text
 from sqlalchemy.orm import Session
+
+from backend.services.coworking.operating_hours import OperatingHoursService
+from backend.services.permission import PermissionService
 from ..database import engine
 from ..env import getenv
 from .. import entities
@@ -28,7 +31,7 @@
 from ..test.services.academics.hiring import hiring_data
 from ..test.services.articles import article_data
 
-__authors__ = ["Kris Jordan", "Ajay Gandecha"]
+__authors__ = ["Kris Jordan", "Ajay Gandecha", "David Foss"]
 __copyright__ = "Copyright 2023"
 __license__ = "MIT"
 
@@ -55,7 +58,9 @@
     permission_data.insert_fake_data(session)
     organization_demo_data.insert_fake_data(session)
     event_demo_data.insert_fake_data(session)
-    operating_hours_data.insert_fake_data(session, time)
+    operating_hours_data.insert_fake_data(
+        session, time, OperatingHoursService(session, PermissionService(session))
+    )
     seat_data.insert_fake_data(session)
     room_data.insert_fake_data(session)
     reservation_data.insert_fake_data(session, time)