🌟 feat: Category and Payment API

tomy0000000 · tomy0000000 · commit a24369f75fbc · 2022-06-05T16:17:15.000+08:00
diff --git a/k_backend/db.py b/k_backend/db.py
@@ -3,7 +3,7 @@
 from alembic import command
 from alembic.config import Config
 from loguru import logger
-from sqlmodel import create_engine
+from sqlmodel import Session, create_engine
 
 try:
     POSTGRES_USER = os.environ["POSTGRES_USER"]
@@ -23,3 +23,8 @@ def alembic_upgrade():
     alembic_cfg = Config("alembic.ini")
     command.upgrade(alembic_cfg, "head")
     logger.info("Alembic upgrade completed.")
+
+
+def get_session():
+    with Session(engine) as session:
+        yield session
diff --git a/k_backend/routers/__init__.py b/k_backend/routers/__init__.py
@@ -9,5 +9,7 @@
     auth_router,
     account_router,
     currency_router,
+    category_router,
+    payment_router,
     invoice_router,
 ]
diff --git a/k_backend/routers/category.py b/k_backend/routers/category.py
@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session, select
+
+from ..auth import get_client
+from ..db import engine
+from ..schemas.category import Category, CategoryCreate, CategoryRead
+
+TAG_NAME = "Category"
+tag = {
+    "name": TAG_NAME,
+    "description": "Create and manage payment entry categories",
+}
+
+category_router = APIRouter(
+    prefix="/category",
+    tags=[TAG_NAME],
+    dependencies=[Depends(get_client)],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@category_router.post("", response_model=CategoryRead, tags=[TAG_NAME])
+def create_category(category: CategoryCreate):
+    with Session(engine) as session:
+        db_category = Category.from_orm(category)
+        session.add(db_category)
+        session.commit()
+        session.refresh(db_category)
+        return db_category
+
+
+@category_router.get("", response_model=list[CategoryRead], tags=[TAG_NAME])
+def read_categories():
+    with Session(engine) as session:
+        categories = session.exec(select(Category)).all()
+        return categories
+
+
+@category_router.patch("", response_model=CategoryRead, tags=[TAG_NAME])
+def update_category(category: Category):
+    with Session(engine) as session:
+        session.merge(category)
+        session.commit()
+        session.refresh(category)
+        return category
+
+
+# TODO: Think about how this should work
+# @category_router.delete("/{id}", tags=[TAG_NAME])
+# def delete_category(id: int):
+#     with Session(engine) as session:
+#         category = session.query(Category).get(id)
+#         if category is None:
+#             raise HTTPException(status_code=404, detail="Category not found")
+#         session.delete(category)
+#         session.commit()
diff --git a/k_backend/routers/payment.py b/k_backend/routers/payment.py
@@ -0,0 +1,126 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session, select
+
+from ..auth import get_client
+from ..db import engine, get_session
+from ..schemas.payment import (
+    Payment,
+    PaymentCreate,
+    PaymentEntry,
+    PaymentEntryCreate,
+    PaymentRead,
+    PaymentReadWithEntries,
+)
+
+TAG_NAME = "Payment"
+tag = {
+    "name": TAG_NAME,
+    "description": "Create and edit payment records",
+}
+
+payment_router = APIRouter(
+    prefix="/payment",
+    tags=[TAG_NAME],
+    dependencies=[Depends(get_client)],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@payment_router.post(
+    "",
+    response_model=PaymentReadWithEntries,
+    tags=[TAG_NAME],
+    openapi_extra={
+        "requestBody": {
+            "content": {
+                "application/json": {
+                    "examples": {
+                        "Taipei with 3 entries": {
+                            "summary": "Taipei with 3 entries",
+                            "value": {
+                                "payment": {
+                                    "timestamp": "2022-09-08T08:07:08.000",
+                                    "timezone": "Asia/Taipei",
+                                    "description": "Some payment description",
+                                },
+                                "entries": [
+                                    {
+                                        "category_id": 1,
+                                        "amount": 20,
+                                        "quantity": 2,
+                                        "description": "First entry",
+                                    },
+                                    {
+                                        "category_id": 2,
+                                        "amount": 30,
+                                        "quantity": 2,
+                                        "description": "Second entry",
+                                    },
+                                    {
+                                        "category_id": 3,
+                                        "amount": 10,
+                                        "quantity": 1,
+                                        "description": "Third entry",
+                                    },
+                                ],
+                            },
+                        }
+                    }
+                }
+            }
+        }
+    },
+)
+def create_payment(
+    *,
+    session: Session = Depends(get_session),
+    payment: PaymentCreate,
+    entries: list[PaymentEntryCreate]
+):
+    # Calculate total
+    payment.total = sum([entry.amount * entry.quantity for entry in entries])
+
+    # Store payment
+    db_payment = Payment.from_orm(payment)
+    session.add(db_payment)
+    session.commit()
+    session.refresh(db_payment)
+
+    # Store entries
+    for entry in entries:
+        entry.payment_id = db_payment.id
+        db_entry = PaymentEntry.from_orm(entry)
+        session.add(db_entry)
+    session.commit()
+
+    new_payment = session.get(Payment, db_payment.id)
+    return new_payment
+
+
+@payment_router.get("", response_model=list[PaymentReadWithEntries], tags=[TAG_NAME])
+def read_payments(*, session: Session = Depends(get_session)):
+    payments = session.exec(select(Payment)).all()
+    return payments
+
+
+@payment_router.patch("", response_model=PaymentRead, tags=[TAG_NAME])
+def update_payment(*, session: Session = Depends(get_session), payment: Payment):
+    session.merge(payment)
+    session.commit()
+    session.refresh(payment)
+    return payment
+
+
+@payment_router.get("/{id}", response_model=PaymentReadWithEntries, tags=[TAG_NAME])
+def read_payment(*, session: Session = Depends(get_session), id: int):
+    payment = session.query(Payment).get(id)
+    return payment
+
+
+@payment_router.delete("/{id}", tags=[TAG_NAME])
+def delete_payment(*, session: Session = Depends(get_session), id: int):
+    payment = session.query(Payment).get(id)
+    if payment is None:
+        raise HTTPException(status_code=404, detail="Payment not found")
+    session.delete(payment)
+    session.commit()
diff --git a/k_backend/schemas/_custom_types.py b/k_backend/schemas/_custom_types.py
@@ -36,3 +36,28 @@ def validate(cls, v):
             except ZoneInfoNotFoundError:
                 raise ValueError(f"{v} is not a valid timezone")
         raise TypeError("zoneinfo.ZoneInfo or str required")
+
+
+def create_timestamp_validator(values):
+    try:
+        timestamp = values["timestamp"]
+        timezone = values["timezone"]
+        if timestamp.tzinfo is None:
+            values["timestamp"] = timestamp.replace(tzinfo=timezone)
+            return values
+        stamp_offset = timestamp.tzinfo.utcoffset(timestamp)
+        zone_offset = timezone.utcoffset(timestamp)
+        if stamp_offset != zone_offset:
+            raise ValueError(
+                f"Inconsistent timestamp offset ({stamp_offset}) and timezone offset ({zone_offset})"
+            )
+    except KeyError:
+        raise ValueError("Missing timestamp or timezone")
+    return values
+
+
+def tz_timestamp_reader(values):
+    timezone = values.get("timezone")
+    if timezone is not None:
+        values["timestamp"] = values["timestamp"].astimezone(timezone)
+    return values
diff --git a/k_backend/schemas/account.py b/k_backend/schemas/account.py
@@ -6,13 +6,13 @@
 class AccountBase(SQLModel):
     name: str
     currency_code: str = Field(foreign_key="currency.code", nullable=False)
-    currency: str = Relationship(back_populates="accounts")
-    transactions: List["Transaction"] = Relationship(back_populates="account")
 
 
 class Account(AccountBase, table=True):
     __tablename__ = "account"
     id: Optional[int] = Field(primary_key=True, nullable=False)
+    currency: "Currency" = Relationship(back_populates="accounts")
+    transactions: List["Transaction"] = Relationship(back_populates="account")
 
 
 class AccountCreate(AccountBase):
diff --git a/k_backend/schemas/category.py b/k_backend/schemas/category.py
@@ -6,12 +6,12 @@
 class CategoryBase(SQLModel):
     name: str
     description: str
-    entries: List["PaymentEntry"] = Relationship(back_populates="category")
 
 
 class Category(CategoryBase, table=True):
     __tablename__ = "category"
     id: Optional[int] = Field(primary_key=True, nullable=False)
+    entries: List["PaymentEntry"] = Relationship(back_populates="category")
 
 
 class CategoryCreate(CategoryBase):
diff --git a/k_backend/schemas/payment.py b/k_backend/schemas/payment.py
@@ -1,21 +1,65 @@
 from datetime import datetime
 from typing import List, Optional
 
+from pydantic import root_validator
 from sqlmodel import Column, DateTime, Field, Relationship, SQLModel
 
-from ._custom_types import PydanticTimezone, SATimezone
+from ._custom_types import (
+    EXTENDED_JSON_ENCODERS,
+    PydanticTimezone,
+    SATimezone,
+    create_timestamp_validator,
+    tz_timestamp_reader,
+)
 
+#
+# Payment
+#
 
-class Payment(SQLModel, table=True):
-    __tablename__ = "payment"
-    id: Optional[int] = Field(primary_key=True, nullable=False)
-    total: float
+
+class PaymentBase(SQLModel):
     timestamp: datetime = Field(
-        sa_column=Column(DateTime(timezone=True)), nullable=False
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+        nullable=False,
+        title="Local timestamp, or timezone-aware timestamp",
+    )
+    timezone: PydanticTimezone = Field(
+        sa_column=Column(SATimezone(), nullable=False), nullable=False
     )
-    timezone: PydanticTimezone = Field(sa_column=Column(SATimezone()), nullable=False)
     description: str
+
+
+class Payment(PaymentBase, table=True):
+    __tablename__ = "payment"
+    id: Optional[int] = Field(primary_key=True, nullable=False)
+    total: float
     transactions: List["Transaction"] = Relationship(back_populates="payment")
+    entries: List["PaymentEntry"] = Relationship(back_populates="payment")
+
+
+class PaymentCreate(PaymentBase):
+    total: Optional[float]
+
+    @root_validator
+    def verify_timezone(cls, values):
+        return create_timestamp_validator(values)
+
+
+class PaymentRead(PaymentBase):
+    id: int
+    total: float
+
+    @root_validator
+    def convert_timezone(cls, values):
+        return tz_timestamp_reader(values)
+
+    class Config:
+        json_encoders = EXTENDED_JSON_ENCODERS
+
+
+#
+# PaymentEntry
+#
 
 
 class PaymentEntryBase(SQLModel):
@@ -24,14 +68,14 @@ class PaymentEntryBase(SQLModel):
     amount: float
     quantity: int
     description: str
-    payment: Payment = Relationship(back_populates="entries")
-    category: "Category" = Relationship(back_populates="entries")
 
 
 class PaymentEntry(PaymentEntryBase, table=True):
     __tablename__ = "payment_entry"
     id: Optional[int] = Field(primary_key=True, nullable=False)
     payment_id: int = Field(foreign_key="payment.id", nullable=False)
+    payment: Payment = Relationship(back_populates="entries")
+    category: "Category" = Relationship(back_populates="entries")
 
 
 class PaymentEntryCreate(PaymentEntryBase):
@@ -43,19 +87,35 @@ class PaymentEntryRead(PaymentEntryBase):
     payment_id: int
 
 
+#
+# Transaction
+#
+
+
 class Transaction(SQLModel, table=True):
 
     __tablename__ = "transaction"
     account_id: int = Field(primary_key=True, foreign_key="account.id", nullable=False)
     payment_id: int = Field(primary_key=True, foreign_key="payment.id", nullable=False)
     amount: float
     timestamp: datetime = Field(
-        sa_column=Column(DateTime(timezone=True)), nullable=False
+        sa_column=Column(DateTime(timezone=True), nullable=False), nullable=False
+    )
+    timezone: PydanticTimezone = Field(
+        sa_column=Column(SATimezone(), nullable=False), nullable=False
     )
-    timezone: PydanticTimezone = Field(sa_column=Column(SATimezone()), nullable=False)
     account: "Account" = Relationship(back_populates="transactions")
     payment: Payment = Relationship(back_populates="transactions")
 
 
+#
+# Relationship Models
+#
+
+
+class PaymentReadWithEntries(PaymentRead):
+    entries: List[PaymentEntryRead] = []
+
+
 from .account import Account
 from .category import Category
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml

Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,7 @@`
`9`	`9`	`auth_router,`
`10`	`10`	`account_router,`
`11`	`11`	`currency_router,`
	`12`	`+ category_router,`
	`13`	`+ payment_router,`
`12`	`14`	`invoice_router,`
`13`	`15`	`]`