wip: add officer models and update GET current officer docs

Author: jbriones1

src/elections/urls.py

@@ -25,7 +25,7 @@
     tags=["election"],
 )
 
-async def get_user_permissions(
+async def get_election_permissions(
     request: Request,
     db_session: database.DBSession,
 ) -> tuple[bool, str | None, str | None]:
@@ -96,7 +96,7 @@ async def list_elections(
     request: Request,
     db_session: database.DBSession,
 ):
-    is_admin, _, _ = await get_user_permissions(request, db_session)
+    is_admin, _, _ = await get_election_permissions(request, db_session)
     election_list = await elections.crud.get_all_elections(db_session)
     if election_list is None or len(election_list) == 0:
         raise HTTPException(
@@ -145,7 +145,7 @@ async def get_election(
             detail=f"election with slug {slugified_name} does not exist"
         )
 
-    is_valid_user, _, _ = await get_user_permissions(request, db_session)
+    is_valid_user, _, _ = await get_election_permissions(request, db_session)
     if current_time >= election.datetime_start_voting or is_valid_user:
 
         election_json = election.private_details(current_time)
@@ -233,7 +233,7 @@ async def create_election(
         available_positions
     )
 
-    is_valid_user, _, _ = await get_user_permissions(request, db_session)
+    is_valid_user, _, _ = await get_election_permissions(request, db_session)
     if not is_valid_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -293,7 +293,7 @@ async def update_election(
     db_session: database.DBSession,
     election_name: str,
 ):
-    is_valid_user, _, _ = await get_user_permissions(request, db_session)
+    is_valid_user, _, _ = await get_election_permissions(request, db_session)
     if not is_valid_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -349,7 +349,7 @@ async def delete_election(
     election_name: str
 ):
     slugified_name = slugify(election_name)
-    is_valid_user, _, _ = await get_user_permissions(request, db_session)
+    is_valid_user, _, _ = await get_election_permissions(request, db_session)
     if not is_valid_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,

src/officers/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from officers.constants import OfficerPositionEnum
+
+
+class BaseOfficerModel(BaseModel):
+    # TODO (#71): compute this using SFU's API & remove from being uploaded
+    legal_name: str
+    position: OfficerPositionEnum
+    start_date: datetime
+    end_date: str | None = None
+    csss_email: str
+
+class PublicOfficerResponse(BaseOfficerModel):
+    """
+    Response when fetching public officer data
+    """
+    is_active: bool
+    nickname: str | None = None
+    discord_name: str | None = None
+    discord_nickname: int | None = None
+    biography: str | None = None
+
+class PrivateOfficerResponse(PublicOfficerResponse):
+    """
+    Response when fetching private officer data
+    """
+    computing_id: str
+    phone_number: str | None = None
+    github_username: str | None = None
+    google_drive_email: str | None = None
+
+class OfficerTermParams(BaseModel):
+    """
+    Create a new officer term
+    """
+    computing_id: str
+    position: OfficerPositionEnum
+    start_date: str

src/officers/urls.py

@@ -1,19 +1,17 @@
-import logging
-
 from fastapi import APIRouter, Body, HTTPException, Request
 from fastapi.responses import JSONResponse, PlainTextResponse
 
 import auth.crud
 import database
 import officers.crud
 import utils
+from elections.urls import get_election_permissions
+from officers.models import PrivateOfficerResponse, PublicOfficerResponse
 from officers.tables import OfficerInfo, OfficerTerm
 from officers.types import InitialOfficerInfo, OfficerInfoUpload, OfficerTermUpload
 from permission.types import OfficerPrivateInfo, WebsiteAdmin
 from utils.urls import logged_in_or_raise
 
-_logger = logging.getLogger(__name__)
-
 router = APIRouter(
     prefix="/officers",
     tags=["officers"],
@@ -25,32 +23,34 @@
 async def _has_officer_private_info_access(
     request: Request,
     db_session: database.DBSession
-) -> tuple[None | str, None | str, bool]:
+) -> tuple[bool, str | None,]:
     """determine if the user has access to private officer info"""
     session_id = request.cookies.get("session_id", None)
     if session_id is None:
-        return None, None, False
+        return False, None
 
     computing_id = await auth.crud.get_computing_id(db_session, session_id)
     if computing_id is None:
-        return session_id, None, False
+        return False, None
 
     has_private_access = await OfficerPrivateInfo.has_permission(db_session, computing_id)
-    return session_id, computing_id, has_private_access
+    return has_private_access, computing_id
 
 # ---------------------------------------- #
 # endpoints
 
 @router.get(
     "/current",
-    description="Get information about all the officers. More information is given if you're authenticated & have access to private executive data.",
+    description="Get information about the current officers. With no authorization, only get basic info.",
+    response_model=list[PrivateOfficerResponse] | list[PublicOfficerResponse],
+    operation_id="get_current_officers"
 )
 async def current_officers(
     # the request headers
     request: Request,
     db_session: database.DBSession,
 ):
-    _, _, has_private_access = await _has_officer_private_info_access(request, db_session)
+    has_private_access, _ = await _has_officer_private_info_access(request, db_session)
     current_officers = await officers.crud.current_officers(db_session, has_private_access)
     return JSONResponse({
         position: [
@@ -71,7 +71,7 @@ async def all_officers(
     # and may only be accessed by that officer and executives. All other officer terms are public.
     include_future_terms: bool = False,
 ):
-    _, computing_id, has_private_access = await _has_officer_private_info_access(request, db_session)
+    has_private_access, computing_id = await _has_officer_private_info_access(request, db_session)
     if include_future_terms:
         is_website_admin = (computing_id is not None) and (await WebsiteAdmin.has_permission(db_session, computing_id))
         if not is_website_admin: