add support for nominee info

EarthenSky · EarthenSky · commit 822c0dc03a59 · 2025-04-11T17:07:22.000-07:00
diff --git a/src/alembic/versions/243190df5588_create_election_tables.py b/src/alembic/versions/243190df5588_create_election_tables.py
@@ -36,11 +36,11 @@ def upgrade() -> None:
         "election_nominee_info",
         sa.Column("computing_id", sa.String(length=32), nullable=False),
         sa.Column("full_name", sa.String(length=64), nullable=False),
-        sa.Column("facebook", sa.String(length=128), nullable=True),
+        sa.Column("linked_in", sa.String(length=128), nullable=True),
         sa.Column("instagram", sa.String(length=128), nullable=True),
         sa.Column("email", sa.String(length=64), nullable=True),
-        sa.Column("discord", sa.String(length=32), nullable=True),
-        sa.Column("discord_id", sa.String(length=32), nullable=True),
+        #sa.Column("discord", sa.String(length=32), nullable=True),
+        #sa.Column("discord_id", sa.String(length=32), nullable=True),
         sa.Column("discord_username", sa.String(length=32), nullable=True),
         sa.PrimaryKeyConstraint("computing_id")
     )
diff --git a/src/elections/crud.py b/src/elections/crud.py
@@ -3,7 +3,7 @@
 import sqlalchemy
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from elections.tables import Election, NomineeApplication
+from elections.tables import Election, NomineeApplication, NomineeInfo
 
 _logger = logging.getLogger(__name__)
 
@@ -50,6 +50,8 @@ async def delete_election(db_session: AsyncSession, slug: str) -> None:
         .where(Election.slug == slug)
     )
 
+# ------------------------------------------------------- #
+
 # TODO: switch to only using one of application or registration
 async def get_all_registrations(
     db_session: AsyncSession,
@@ -66,6 +68,19 @@ async def get_all_registrations(
     )).all()
     return registrations
 
+async def get_all_registrations_in_election(
+    db_session: AsyncSession,
+    election_slug: str,
+) -> list[NomineeApplication] | None:
+    registrations = (await db_session.scalars(
+        sqlalchemy
+        .select(NomineeApplication)
+        .where(
+            NomineeApplication.election_slug == election_slug
+        )
+    )).all()
+    return registrations
+
 async def add_registration(
     db_session: AsyncSession,
     initial_application: NomineeApplication
@@ -102,3 +117,32 @@ async def delete_registration(
             and NomineeApplication.position == position
         )
     )
+
+# ------------------------------------------------------- #
+
+async def get_nominee_info(
+    db_session: AsyncSession,
+    computing_id: str,
+) -> NomineeInfo | None:
+    return await db_session.scalar(
+        sqlalchemy
+        .select(NomineeInfo)
+        .where(NomineeInfo.computing_id == computing_id)
+    )
+
+async def create_nominee_info(
+    db_session: AsyncSession,
+    info: NomineeInfo,
+):
+    db_session.add(info)
+
+async def update_nominee_info(
+    db_session: AsyncSession,
+    info: NomineeInfo,
+):
+    await db_session.execute(
+        sqlalchemy
+        .update(NomineeInfo)
+        .where(NomineeInfo.computing_id == info.computing_id)
+        .values(info.to_update_dict())
+    )
diff --git a/src/elections/tables.py b/src/elections/tables.py
@@ -122,13 +122,39 @@ class NomineeInfo(Base):
 
     computing_id = Column(String(COMPUTING_ID_LEN), primary_key=True)
     full_name = Column(String(64), nullable=False)
-    facebook = Column(String(128))
+    linked_in = Column(String(128))
     instagram = Column(String(128))
     email = Column(String(64))
-    discord = Column(String(DISCORD_NAME_LEN))
-    discord_id = Column(String(DISCORD_ID_LEN))
+    #discord = Column(String(DISCORD_NAME_LEN))
+    #discord_id = Column(String(DISCORD_ID_LEN))
     discord_username = Column(String(DISCORD_NICKNAME_LEN))
 
+    def to_update_dict(self) -> dict:
+        return {
+            "computing_id": self.computing_id,
+            "full_name": self.full_name,
+
+            "linked_in": self.linked_in,
+            "instagram": self.instagram,
+            "email": self.email,
+            "discord_username": self.discord_username,
+        }
+
+    def as_serializable(self) -> dict:
+        # NOTE: this function is currently the same as to_update_dict since the contents
+        # have a different invariant they're upholding, which may cause them to change if a
+        # new property is introduced. For example, dates must be converted into strings
+        # to be serialized, but must not for update dictionaries.
+        return {
+            "computing_id": self.computing_id,
+            "full_name": self.full_name,
+
+            "linked_in": self.linked_in,
+            "instagram": self.instagram,
+            "email": self.email,
+            "discord_username": self.discord_username,
+        }
+
 class NomineeApplication(Base):
     __tablename__ = "election_nominee_application"
 
diff --git a/src/elections/urls.py b/src/elections/urls.py
@@ -8,7 +8,7 @@
 import database
 import elections
 import elections.tables
-from elections.tables import Election, NomineeApplication, election_types
+from elections.tables import Election, NomineeApplication, NomineeInfo, election_types
 from officers.constants import OfficerPosition
 from permission.types import ElectionOfficer, WebsiteAdmin
 from utils.urls import is_logged_in
@@ -32,6 +32,7 @@ async def _validate_user(
     if not logged_in:
         return False, None, None
 
+    # where valid means elections officer or website admin
     has_permission = await ElectionOfficer.has_permission(db_session, computing_id)
     if not has_permission:
         has_permission = await WebsiteAdmin.has_permission(db_session, computing_id)
@@ -65,7 +66,11 @@ async def list_elections(
 
 @router.get(
     "/by_name/{name:str}",
-    description="Retrieves the election data for an election by name. Returns private details when the time is allowed."
+    description="""
+    Retrieves the election data for an election by name.
+    Returns private details when the time is allowed.
+    If user is an admin or elections officer, returns computing ids for each candidate as well.
+    """
 )
 async def get_election(
     request: Request,
@@ -80,16 +85,45 @@ async def get_election(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"election with slug {_slugify(name)} does not exist"
         )
-    elif current_time >= election.datetime_start_voting:
-        # after the voting period starts, all election data becomes public
-        return JSONResponse(election.private_details(current_time))
-
-    # TODO: include nominees and speeches
-    # TODO: ignore any empty mappings
 
     is_valid_user, _, _ = await _validate_user(request, db_session)
-    if is_valid_user:
+    if current_time >= election.datetime_start_voting or is_valid_user:
+
         election_json = election.private_details(current_time)
+        all_nominations = elections.crud.get_all_registrations_in_election(db_session, _slugify(name))
+        election_json["candidates"] = []
+
+        avaliable_positions_list = election.avaliable_positions.split(",")
+        for nomination in all_nominations:
+            if nomination.position not in avaliable_positions_list:
+                # ignore any positions that are **no longer** active
+                continue
+
+            # NOTE: if a nominee does not input their legal name, they are not considered a nominee
+            nominee_info = elections.crud.get_nominee_info(db_session, nomination.computing_id)
+            if nominee_info is None:
+                print("unreachable")
+                continue
+
+            candidate_entry = {
+                "position": nomination.position,
+                "full_name": nominee_info.full_name,
+                "linked_in": nominee_info.linked_in,
+                "instagram": nominee_info.instagram,
+                "email": nominee_info.email,
+                "discord_username": nominee_info.discord_username,
+                "speech": (
+                    "No speech provided by this candidate"
+                    if nomination.speech is None
+                    else nomination.speech
+                ),
+            }
+            if is_valid_user:
+                candidate_entry["computing_id"] = nomination.computing_id
+            election_json["candidates"].append(candidate_entry)
+
+        # after the voting period starts, all election data becomes public
+        return JSONResponse()
     else:
         election_json = election.public_details(current_time)
 
@@ -353,6 +387,13 @@ async def register_in_election(
             detail=f"invalid position {position}"
         )
 
+    if await elections.crud.get_nominee_info(db_session, computing_id) is None:
+        # ensure that the user has a nominee info entry before allowing registration to occur.
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="must have submitted nominee info before registering"
+        )
+
     current_time = datetime.now()
     election_slug = _slugify(election_name)
     election = await elections.crud.get_election(db_session, election_slug)
@@ -388,6 +429,7 @@ async def register_in_election(
         position=position,
         speech=None
     ))
+    await db_session.commit()
 
 @router.patch(
     "/register/{election_name:str}",
@@ -437,6 +479,7 @@ async def update_registration(
         position=position,
         speech=speech
     ))
+    await db_session.commit()
 
 @router.delete(
     "/register/{election_name:str}",
@@ -480,3 +523,68 @@ async def delete_registration(
         )
 
     await elections.crud.delete_registration(db_session, computing_id, election_slug, position)
+    await db_session.commit()
+
+# nominee info ------------------------------------------------------------- #
+
+@router.get(
+    "/nominee_info",
+    description="Nominee info is always publically tied to elections, so be careful!"
+)
+async def get_nominee_info(
+    request: Request,
+    db_session: database.DBSession,
+):
+    logged_in, _, computing_id = await is_logged_in(request, db_session)
+    if not logged_in:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="must be logged in to get your nominee info"
+        )
+
+    nominee_info = await elections.crud.get_nominee_info(db_session, computing_id)
+    if nominee_info is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="You don't have any nominee info yet"
+        )
+
+    return JSONResponse(nominee_info.as_serializable())
+
+@router.patch(
+    "/nominee_info",
+    description="Will create or update nominee info. Returns an updated copy of their nominee info."
+)
+async def provide_nominee_info(
+    request: Request,
+    db_session: database.DBSession,
+    full_name: str,
+    linked_in: str | None,
+    instagram: str | None,
+    email: str | None,
+    discord_username: str | None,
+):
+    logged_in, _, computing_id = await is_logged_in(request, db_session)
+    if not logged_in:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="must be logged in to update nominee info"
+        )
+
+    pending_nominee_info = NomineeInfo(
+        computing_id = computing_id,
+        full_name = full_name,
+        linked_in = linked_in,
+        instagram = instagram,
+        email = email,
+        discord_username = discord_username,
+    )
+    if await elections.crud.get_nominee_info(db_session, computing_id) is None:
+        await elections.crud.create_nominee_info(db_session, pending_nominee_info)
+    else:
+        await elections.crud.update_nominee_info(db_session, pending_nominee_info)
+
+    await db_session.commit()
+
+    new_nominee_info = await elections.crud.get_nominee_info(db_session, computing_id)
+    return JSONResponse(new_nominee_info.as_serializable())
