❇️ [refactor][backend] Payment to Event internal renames

Author: tomy0000000

backend/kayman/crud/event.py

@@ -0,0 +1,42 @@
+from collections.abc import Sequence
+from datetime import date
+
+from sqlmodel import Session, func, select
+
+from kayman.schemas.event import (
+    Event,
+    EventBase,
+    EventCreate,
+    PaymentEntry,
+)
+
+
+def create_event(
+    session: Session, event: EventCreate, commit: bool = True
+) -> EventBase:
+    db_event = Event.model_validate(event)
+    session.add(db_event)
+    if commit:
+        session.commit()
+        session.refresh(db_event)
+    else:
+        session.flush()
+    return db_event
+
+
+def read_event(session: Session, event_id: int) -> Event | None:
+    return session.get(Event, event_id)
+
+
+def read_events(
+    session: Session, event_date: date | None = None, category_id: int | None = None
+) -> Sequence[Event]:
+    scalar = select(Event).distinct()
+    if event_date:
+        scalar = scalar.where(func.date(Event.timestamp) == event_date)
+    if category_id:
+        scalar = scalar.join(PaymentEntry).where(
+            PaymentEntry.category_id == category_id
+        )
+    events = session.exec(scalar).all()
+    return events

backend/kayman/crud/payment.py

@@ -7,15 +7,15 @@
 
 from kayman.auth import get_client
 from kayman.core.db import get_session
-from kayman.crud.payment import (
-    create_payment,
-    read_payment,
-    read_payments,
+from kayman.crud.event import (
+    create_event,
+    read_event,
+    read_events,
 )
 from kayman.crud.payment_entry import create_payment_entries
 from kayman.crud.transaction import create_transactions
 from kayman.logics.account import update_balances_with_transactions
-from kayman.logics.payment import validate_total
+from kayman.logics.event import validate_total
 from kayman.schemas.api_models import PaymentCreateDetailed, PaymentReadDetailed
 from kayman.schemas.event import (
     Event,
@@ -264,9 +264,9 @@ def create(
     except ValueError as err:
         raise HTTPException(status_code=400, detail=err.args[0]) from err
 
-    # Store payment
-    db_payment = create_payment(session, body.payment, commit=False)
-    payment_id = EventRead.model_validate(db_payment).id
+    # Store event
+    db_event = create_event(session, body.payment, commit=False)
+    event_id = EventRead.model_validate(db_event).id
 
     # Store entries
     entries = []
@@ -275,7 +275,7 @@ def create(
             PaymentEntryBase.model_validate(
                 entry_create,
                 update={
-                    "payment_id": payment_id,
+                    "payment_id": event_id,
                     "index": entry_index,
                 },
             )
@@ -289,7 +289,7 @@ def create(
             TransactionBase.model_validate(
                 transaction,
                 update={
-                    "payment_id": payment_id,
+                    "payment_id": event_id,
                     "index": transaction_index,
                 },
             )
@@ -299,25 +299,25 @@ def create(
     # Modify account balance
     update_balances_with_transactions(session, body.transactions, commit=False)
 
-    # Read the new payment
-    new_payment = read_payment(session, payment_id)
-    if new_payment is None:
+    # Read the new event
+    new_event = read_event(session, event_id)
+    if new_event is None:
         raise HTTPException(status_code=500, detail="Failed to create payment")
 
     # Commit all changes
     session.commit()
 
-    return new_payment
+    return new_event
 
 
 @payment_router.get(
     "/{payment_id}", name="Read Payment", response_model=PaymentReadDetailed
 )
 def read(*, session: Session = Depends(get_session), payment_id: int) -> EventBase:
-    payment = read_payment(session, payment_id)
-    if payment is None:
+    event = read_event(session, payment_id)
+    if event is None:
         raise HTTPException(status_code=404, detail="Payment not found")
-    return payment
+    return event
 
 
 @payment_router.get("", name="Read Payments", response_model=list[PaymentReadDetailed])
@@ -327,21 +327,21 @@ def reads(
     payment_date: date | None = None,
     category_id: int | None = None,
 ) -> Sequence[EventBase]:
-    return read_payments(session, payment_date, category_id)
+    return read_events(session, payment_date, category_id)
 
 
 @payment_router.patch("", name="Update Payment", response_model=EventRead)
-def update(*, session: Session = Depends(get_session), payment: Event) -> EventBase:
-    session.merge(payment)
+def update(*, session: Session = Depends(get_session), event: Event) -> EventBase:
+    session.merge(event)
     session.commit()
-    session.refresh(payment)
-    return payment
+    session.refresh(event)
+    return event
 
 
 @payment_router.delete("/{id}", name="Delete Payment")
 def delete(*, session: Session = Depends(get_session), id: int) -> None:
-    payment = session.get(Event, id)
-    if payment is None:
+    event = session.get(Event, id)
+    if event is None:
         raise HTTPException(status_code=404, detail="Payment not found")
-    session.delete(payment)
+    session.delete(event)
     session.commit()

backend/kayman/logics/payment.py backend/kayman/logics/event.pybackend/kayman/logics/payment.py renamed to backend/kayman/logics/event.py

@@ -0,0 +1,102 @@
+from datetime import datetime
+
+from sqlmodel import Session
+
+from kayman.crud.event import create_event, read_event, read_events
+from kayman.tests.factories import (
+    CategoryFactory,
+    EventFactory,
+    PaymentEntryFactory,
+)
+
+
+def test_create_event(session: Session, session_2: Session):
+    event = EventFactory.build()
+    db_event = create_event(session, event)
+    db_read_event = read_event(session_2, db_event.id)
+
+    assert db_read_event.id is not None
+    assert db_read_event.description == event.description
+    assert db_read_event.timestamp == event.timestamp
+    assert db_read_event.timezone == event.timezone
+    assert db_read_event.type == event.type
+
+
+def test_create_event_no_commit(session: Session, session_2: Session):
+    event = EventFactory.build()
+
+    # The event should be created in the session
+    session_event = create_event(session, event, commit=False)
+    assert session_event.id is not None  # Auto int should be set
+    assert session_event.description == event.description
+    assert session_event.timestamp == event.timestamp
+    assert session_event.timezone == event.timezone
+    assert session_event.type == event.type
+
+    # The event should not be visible to other sessions (yet)
+    session_2_event = read_event(session_2, session_event.id)
+    assert session_2_event is None
+
+    # Commit the event from main session
+    session.commit()
+
+    # The event should now be visible to other sessions
+    session_3_event = read_event(session_2, session_event.id)
+    assert session_3_event is not None
+    assert session_3_event.id == session_event.id
+    assert session_3_event.description == session_event.description
+    assert session_3_event.timestamp == session_event.timestamp
+    assert session_3_event.timezone == session_event.timezone
+    assert session_3_event.type == session_event.type
+
+
+def test_read_event(session: Session):
+    event = EventFactory()
+    assert read_event(session, event.id) == event
+
+
+def test_read_events_all(session: Session):
+    for _ in range(10):
+        EventFactory()
+
+    assert len(read_events(session)) == 10
+
+
+def test_read_events_by_date(session: Session):
+    EventFactory(timestamp=datetime(2025, 1, 1))
+    EventFactory(timestamp=datetime(2025, 1, 2))
+
+    assert len(read_events(session, event_date="2025-01-01")) == 1
+    assert len(read_events(session, event_date="2025-01-02")) == 1
+
+
+def test_read_events_by_category(session: Session):
+    category_1 = CategoryFactory()
+    category_2 = CategoryFactory()
+    category_3 = CategoryFactory()
+    event_1 = EventFactory(
+        entries=[
+            PaymentEntryFactory(category=category_1),
+            PaymentEntryFactory(category=category_2),
+        ]
+    )
+    event_2 = EventFactory(
+        entries=[
+            PaymentEntryFactory(category=category_1),
+            PaymentEntryFactory(category=category_3),
+        ]
+    )
+
+    events = read_events(session, category_id=category_1.id)
+    event_ids = {event.id for event in events}
+    assert len(events) == 2
+    assert event_1.id in event_ids
+    assert event_2.id in event_ids
+
+    events = read_events(session, category_id=category_2.id)
+    assert len(events) == 1
+    assert events[0].id == event_1.id
+
+    events = read_events(session, category_id=category_3.id)
+    assert len(events) == 1
+    assert events[0].id == event_2.id