Admin Profile View (#77)

## Notion ticket link
<!-- Please replace with your ticket's URL -->
[Ticket
Name](https://www.notion.so/uwblueprintexecs/Task-Board-db95cd7b93f245f78ee85e3a8a6a316d)

## Implementation description
  * Replaced ad-hoc available_time records with recurring
`AvailabilityTemplate`s: new model + migrations, schema updates,
timezone
utilities, and service logic that creates/deletes template slots,
validates
  input, and projects active templates when Hydrating users/admin lists.
  * Added an admin `PATCH /users/{id}/user-data` flow backed by
`UserDataUpdateRequest`, expands `UserService` to materialize
treatments/
experiences/loved-one info, and ensures responses always include active
availability templates; extended seeds and helper scripts to
create/check/
  undo match data plus availability seeding docs.
  * Hardened `MatchService` to only attach suggestions for volunteers
  with templates and to compare template weekdays in the volunteer’s
  timezone before converting to UTC; added comprehensive unit
  coverage (`test_availability_service`, `test_match_service`,
  `test_match_service_timezone`, `test_user_data_update`).
* Built the admin user profile experience (`/admin/users/[id]`):
navigation
sidebar, profile summary card, editable cancer experience/loved-one
sections,
availability grid editor with drag-select, success messaging, and
supporting
hooks (`useUserProfile`, `useProfileEditing`, `useAvailabilityEditing`,
  `useIntakeOptions`) plus Chakra-based UI components.
* Updated the admin directory/header to route into the new profile view,
  expanded API clients/types/utilities to handle user-data patching +
availability templates, and added UI polish (single-select dropdown
upgrades,
user profile formatting helpers, date utilities, success banner, react-
  datepicker).

  ## Steps to test
1. `docker-compose up -d` then run `cd backend && pdm run alembic
upgrade
  head` to apply the availability template migrations.
2. `cd backend && pdm run dev` and `cd frontend && npm run dev`; sign in
to
  the admin portal.
3. Visit `/admin/directory`, open any volunteer, and verify the profile
page
renders summary, profile, cancer, loved-one, and availability sections
with
  existing data.
4. Click “Edit” in Profile Summary to update personal/demographic
fields,
save, and confirm the success toast plus persisted values via a hard
refresh;
  repeat for cancer and loved-one sections (including clearing dates).
5. Use “Edit Availability” to drag-select new slots, save, and confirm
the
grid + subsequent reload reflect the template changes (verify via
network tab
  hitting `/availability`).
  6. Optional back-end verification: run `cd backend && pdm run tests
  backend/tests/unit/test_availability_service.py backend/tests/unit/
test_match_service_timezone.py
backend/tests/unit/test_user_data_update.py`
  to exercise the new logic, and use the helper scripts
(`create_test_matches.py`, `check_matches.py`, `undo_test_changes.py`)
to
  inspect match suggestion behavior.


  ## What should reviewers focus on?
* **Migrations & data model:** ensure the `availability_templates`
migration,
seeds, and new helper scripts won’t clobber production data when rolled
out.
  * **User data patching:** confirm `UserService.update_user_data_by_id`
correctly hydrates treatments/experiences and returns availability
templates
  so the admin UI state stays consistent.
* **Matching/timezone logic:** double-check
`_attach_initial_suggested_times`
now uses volunteer-local weekdays and that suggested blocks remain
correct
  across timezones.
* **Admin UI flows:** exercise the new hooks/components for editing
profile
  sections and availability (loading states, drag interactions, and API
  payloads) for both happy paths and cancellations.
* **API client/type updates:** watch for any regressions in other
consumers
now that `UserResponse` carries availability templates and the auth API
  client maps the new schemas.

  ## Checklist
  - [ ] My PR name is descriptive and in imperative tense
- [ ] My commit messages are descriptive and in imperative tense. My
commits
are atomic and trivial commits are squashed or fixup'd into non-trivial
  commits
  - [ ] I have run the appropriate linter(s)
- [ ] I have requested a review from the PL, as well as other devs who
have
background knowledge on this PR or who will be building on top of this
PR

Author: YashK2005

.pre-commit-config.yaml

@@ -0,0 +1,30 @@
+# .pre-commit-config.yaml
+# Root-level config to handle both frontend and backend linting/formatting
+
+default_language_version:
+  python: python3.12
+
+default_stages: [pre-commit, pre-push]
+
+repos:
+  # Backend: Ruff linting and formatting
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.6.7
+    hooks:
+      - id: ruff
+        args: [--fix, --line-length=120]
+        files: ^backend/
+      - id: ruff-format
+        args: [--line-length=120]
+        files: ^backend/
+
+  # Frontend: Prettier formatting
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v4.0.0-alpha.8
+    hooks:
+      - id: prettier
+        files: ^frontend/.*\.(ts|tsx|js|jsx|json|css|md)$
+        exclude: ^frontend/(node_modules|\.next|out|build)/
+        types_or: [file]
+        additional_dependencies:
+          - [email protected]

backend/.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, Time
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+
+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/AvailabilityTemplate.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/TimeBlock.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/User.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/models/__init__.py

@@ -17,7 +17,7 @@
 # TODO: ADD RATE LIMITING
 @router.post("/register", response_model=UserCreateResponse)
 async def register_user(user: UserCreateRequest, user_service: UserService = Depends(get_user_service)):
-    allowed_Admins = ["[email protected]", "[email protected]"]
+    allowed_Admins = ["[email protected]", "[email protected]", "[email protected]"]
     if user.role == UserRole.ADMIN:
         if user.email not in allowed_Admins:
             raise HTTPException(status_code=403, detail="Access denied. Admin privileges required for admin portal")

backend/app/routes/auth.py

@@ -11,6 +11,7 @@
     UserRole,
     UserUpdateRequest,
 )
+from app.schemas.user_data import UserDataUpdateRequest
 from app.services.implementations.user_service import UserService
 from app.utilities.service_utils import get_user_service
 
@@ -89,6 +90,22 @@ async def update_user(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+# admin only update user_data (cancer experience, treatments, experiences, etc.)
+@router.patch("/{user_id}/user-data", response_model=UserResponse)
+async def update_user_data(
+    user_id: str,
+    user_data_update: UserDataUpdateRequest,
+    user_service: UserService = Depends(get_user_service),
+    authorized: bool = has_roles([UserRole.ADMIN]),
+):
+    try:
+        return await user_service.update_user_data_by_id(user_id, user_data_update)
+    except HTTPException as http_ex:
+        raise http_ex
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 # admin only delete user
 @router.delete("/{user_id}")
 async def delete_user(
@@ -110,6 +127,7 @@ async def delete_user(
 async def deactivate_user(
     user_id: str,
     user_service: UserService = Depends(get_user_service),
+    authorized: bool = has_roles([UserRole.ADMIN]),
 ):
     try:
         await user_service.soft_delete_user_by_id(user_id)
@@ -118,3 +136,19 @@ async def deactivate_user(
         raise http_ex
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+# reactivate user
+@router.post("/{user_id}/reactivate")
+async def reactivate_user(
+    user_id: str,
+    user_service: UserService = Depends(get_user_service),
+    authorized: bool = has_roles([UserRole.ADMIN]),
+):
+    try:
+        await user_service.reactivate_user_by_id(user_id)
+        return {"message": "User reactivated successfully"}
+    except HTTPException as http_ex:
+        raise http_ex
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/app/routes/user.py

@@ -1,14 +1,21 @@
+from datetime import time
 from typing import List
 from uuid import UUID
 
 from pydantic import BaseModel
 
-from app.schemas.time_block import TimeBlockEntity, TimeRange
+
+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 +29,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/availability.py

@@ -9,6 +9,10 @@
 
 from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
 
+from .availability import AvailabilityTemplateSlot
+from .user_data import UserDataResponse
+from .volunteer_data import VolunteerDataResponse
+
 # TODO:
 # confirm complexity rules for fields (such as password)
 
@@ -135,8 +139,12 @@ class UserResponse(BaseModel):
     role_id: int
     auth_id: str
     approved: bool
+    active: bool
     role: "RoleResponse"
     form_status: FormStatus
+    user_data: Optional[UserDataResponse] = None
+    volunteer_data: Optional[VolunteerDataResponse] = None
+    availability: List[AvailabilityTemplateSlot] = []
 
     model_config = ConfigDict(from_attributes=True)