Merge pull request #85 from georgejkaye/fix-new-db-stuff

Fix new db stuff

api/src/cookiebreaks/api/routers/claims.py

@@ -34,7 +34,7 @@ async def request_claims(
 @dataclass
 class BreakAndClaim:
     breaks: list[BreakExternal]
-    claims: list[ClaimExternal]
+    claim: ClaimExternal
 
 
 @router.post(
@@ -43,12 +43,12 @@ class BreakAndClaim:
 async def claim_break(
     current_user: Annotated[User, Depends(is_admin)], break_ids: list[int]
 ):
-    (updated_breaks, updated_claims) = claim_for_breaks(break_ids)
+    (updated_breaks, updated_claim) = claim_for_breaks(break_ids)
     external_breaks = list(
         map(lambda c: break_internal_to_external(c, current_user), updated_breaks)
     )
-    external_claims = list(map(claim_internal_to_external, updated_claims))
-    return BreakAndClaim(external_breaks, external_claims)
+    external_claim = claim_internal_to_external(updated_claim)
+    return BreakAndClaim(external_breaks, external_claim)
 
 
 @router.post(

api/src/cookiebreaks/api/routers/utils.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from decimal import Decimal
-from typing import Optional
+from typing import Literal, Optional
 
 from arrow import Arrow
 from cookiebreaks.core.database import get_break_objects, get_claim_objects
@@ -75,7 +75,7 @@ class ClaimExternal:
     id: int
     claim_date: datetime
     breaks_claimed: list[int]
-    claim_amount: Decimal
+    claim_amount: Decimal | Literal[0]
     claim_reimbursed: Optional[datetime]
 
 

api/src/cookiebreaks/core/database.py

@@ -60,7 +60,7 @@ def insert_breaks(breaks: list[tuple[Arrow, str, Optional[str]]]) -> list[Break]
         {
             "datetimes": list(map(lambda b: b[0].datetime, breaks)),
             "locations": list(map(lambda b: b[1], breaks)),
-            "hosts": list(map(lambda b: b[1], breaks)),
+            "hosts": list(map(lambda b: b[2], breaks)),
         },
     )
     rows = cur.fetchall()
@@ -336,30 +336,38 @@ def get_maybe_cost(b: Break) -> Decimal:
     return b.cost
 
 
-def claim_for_breaks(break_ids: list[int]) -> tuple[list[Break], list[Claim]]:
+def claim_for_breaks(break_ids: list[int]) -> tuple[list[Break], Claim]:
     (conn, cur) = connect()
     break_table_statement = f"""
-        UPDATE break
-        SET admin_claimed = DATE_TRUNC('minute', NOW()), break_host = NULL
+        UPDATE Break
+        SET break_host = NULL
         WHERE break_id IN (SELECT * FROM unnest(%(ids)s) AS ids)
-        RETURNING *
+        RETURNING break_id, break_host, break_datetime, break_location, holiday_text, break_announced, break_cost, host_reimbursed
     """
     cur.execute(break_table_statement, {"ids": break_ids})
     rows = cur.fetchall()
     updated_breaks = rows_to_breaks(rows)
     costs = list(map(lambda b: get_maybe_cost(b), updated_breaks))
     amount = sum(costs)
     claim_table_statement = f"""
-        INSERT INTO claim(claim_date, breaks_claimed, claim_amount)
-        VALUES(DATE_TRUNC('minute', NOW()), %(breaks)s, %(amount)s)
-        RETURNING *
+        INSERT INTO Claim(claim_date)
+        VALUES(DATE_TRUNC('minute', NOW()))
+        RETURNING claim_id, claim_date, claim_reimbursed
     """
     cur.execute(claim_table_statement, {"breaks": break_ids, "amount": amount})
-    rows = cur.fetchall()
-    updated_claims = rows_to_claims(rows)
+    row = cur.fetchall()[0]
+    updated_claim = Claim(row[0], arrow.get(row[1]), break_ids, amount, None)
+    claim_item_statement = f"""
+        INSERT INTO ClaimItem(claim_id, break_id) (
+            SELECT %(claim_id)s, unnest(%(break_ids)s)
+        )
+    """
+    cur.execute(
+        claim_item_statement, {"claim_id": updated_claim.id, "break_ids": break_ids}
+    )
     conn.commit()
     disconnect(conn, cur)
-    return (updated_breaks, updated_claims)
+    return (updated_breaks, updated_claim)
 
 
 def get_claim_objects(filters: ClaimFilters = ClaimFilters()) -> list[Claim]:
@@ -372,23 +380,27 @@ def get_claim_objects(filters: ClaimFilters = ClaimFilters()) -> list[Claim]:
         where_statement = f"WHERE claim_reimbursed IS{modifier} NULL"
     else:
         where_statement = ""
-    statement = f"""
-        SELECT  FROM claim
+    claims_statement = f"""
+        SELECT claim.claim_id, claim.claim_date, claim.claim_reimbursed, ARRAY_AGG(claimitem.break_id), SUM(break.break_cost)
+            FROM claim
+            INNER JOIN claimitem ON claim.claim_id = claimitem.claim_id
+            INNER JOIN break ON claimitem.break_id = break.break_id
+            GROUP BY claim.claim_id
         {where_statement}
-        ORDER BY claim_date ASC
+        ORDER BY claim.claim_date ASC
     """
-    cur.execute(statement)
+    cur.execute(claims_statement)
     rows = cur.fetchall()
-    disconnect(conn, cur)
     claims: list[Claim] = []
     for row in rows:
-        (claim_id, claim_date, breaks_claimed, claim_amount, claim_reimbursed) = row
+        (claim_id, claim_date, claim_reimbursed, breaks_claimed, claim_amount) = row
         if claim_reimbursed is not None:
             claim_reimbursed = arrow.get(claim_reimbursed)
-        claim_date = arrow.get(claim_date)
+        claim_arrow = arrow.get(claim_date)
         claims.append(
-            Claim(claim_id, claim_date, breaks_claimed, claim_amount, claim_reimbursed)
+            Claim(claim_id, claim_arrow, breaks_claimed, claim_amount, claim_reimbursed)
         )
+    disconnect(conn, cur)
     return claims
 
 

api/src/cookiebreaks/core/structs.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from decimal import Decimal
-from typing import Optional
+from typing import Literal, Optional
 from arrow import Arrow
 
 
@@ -58,7 +58,7 @@ class Claim:
     id: int
     claim_date: Arrow
     breaks_claimed: list[int]
-    claim_amount: Decimal
+    claim_amount: Decimal | Literal[0]
     claim_reimbursed: Optional[Arrow] = None
 
 

client/src/app/api.ts

@@ -250,9 +250,9 @@ export const submitClaim = async (
     )
     let responseData = response.data
     let updatedBreaks = responseData.breaks
-    let updatedClaims = responseData.claims
+    let updatedClaim = responseData.claim
     let breaks = updateBreaks(responseToBreaks(updatedBreaks), [])
-    updateClaims([responseToClaim(updatedClaims, breaks)], [])
+    updateClaims([responseToClaim(updatedClaim, breaks)], [])
     setTimeout(() => setLoadingCards(false), 1)
 }