Fully functional opening transactions

api/app/account/account_routes.py

@@ -7,7 +7,7 @@ from fastapi_filter.contrib.sqlalchemy import Filter
 from fastapi_pagination import Page
 from fastapi_pagination.ext.sqlmodel import paginate
 
-from account.schemas import AccountCreate, AccountRead, AccountUpdate
+from account.schemas import AccountCreate, AccountRead, AccountUpdate, OpeningTransaction, OpeningTransactionUpdate
 from account.models import Account
 from account.resource import AccountResource
 
@@ -57,13 +57,6 @@ def read_account(account_id: UUID, session: SessionDep, current_user=Depends(get
         raise HTTPException(status_code=404, detail="Account not found")
     return account
 
-@router.get("/{account_id}/opening_state")
-def read_account_opening_state(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)) -> TransactionRead:
-    transaction = TransactionResource.get_opening_transaction(session, account_id)
-    if not transaction:
-        raise HTTPException(status_code=404, detail="Account not found")
-    return transaction
-
 @router.put("/{account_id}")
 def update_account(account_id: UUID, account: AccountUpdate, session: SessionDep, current_user=Depends(get_current_user)) -> AccountRead:
     db_account = AccountResource.get(session, account_id)
@@ -74,6 +67,22 @@ def update_account(account_id: UUID, account: AccountUpdate, session: SessionDep
     account = AccountResource.update(session, db_account, account_data)
     return account
 
+@router.get("/{account_id}/opening_state")
+def read_account_opening_state(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)) -> OpeningTransaction:
+    transaction = AccountResource.get_opening_transaction(session, account_id)
+    if not transaction:
+        raise HTTPException(status_code=404, detail="Account not found")
+    return transaction
+
+@router.put("/{account_id}/opening_state")
+def update_account_opening_state(account_id: UUID, opening_transaction: OpeningTransactionUpdate, session: SessionDep, current_user=Depends(get_current_user)) -> OpeningTransaction:
+    account = AccountResource.get(session, account_id)
+    if not account:
+        raise HTTPException(status_code=404, detail="Account not found")
+
+    transaction = AccountResource.update_opening_transaction(session, account, opening_transaction)
+    return transaction
+
 @router.delete("/{account_id}")
 def delete_account(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)):
     account = AccountResource.get(session, account_id)

api/app/account/fixtures.py

@@ -29,42 +29,42 @@ fixtures_account = [
       "name": "Current Assets",
       "parent_path": None,
       "type": "Asset",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 2),
       "opening_balance": Decimal("0.00"),
     },
     {
       "name": "Cash in Wallet",
       "parent_path": "/Accounts/Asset/Current Assets/",
       "type": "Asset",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 3),
       "opening_balance": Decimal("0.00"),
     },
     {
       "name": "Checking Account",
       "parent_path": "/Accounts/Asset/Current Assets/",
       "type": "Asset",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 4),
       "opening_balance": Decimal("0.00"),
     },
     {
       "name": "Savings Account",
       "parent_path": "/Accounts/Asset/Current Assets/",
       "type": "Asset",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 5),
       "opening_balance": Decimal("0.00"),
     },
     {
       "name": "Debt Accounts",
       "parent_path": None,
       "type": "Liability",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 6),
       "opening_balance": Decimal("0.00"),
     },
     {
       "name": "Credit Card",
       "parent_path": "/Accounts/Liability/Debt Accounts/",
       "type": "Liability",
-      "opening_date": date(1970, 1, 1),
+      "opening_date": date(1970, 1, 7),
       "opening_balance": Decimal("0.00"),
     },
 ]

api/app/account/resource.py

@@ -1,8 +1,11 @@
-from sqlalchemy import literal_column
+from datetime import date
+
+from sqlalchemy import and_
 from sqlalchemy.orm import aliased
 from sqlmodel import select
 
 from account.models import Account
+from account.schemas import OpeningTransaction
 from transaction.models import Split, Transaction
 
 
@@ -24,9 +27,9 @@ class AccountResource:
 
     @classmethod
     def create_opening_transaction(cls, session, account, schema):
-
         equity_account = cls.get_by_path(session, "/Equity/")
         t = Transaction()
+        t.transaction_date = schema.opening_date
         split_opening = Split()
         split_opening.id = 0
         split_opening.transaction = t
@@ -41,6 +44,56 @@ class AccountResource:
 
         account.transaction_splits.append(split_opening)
 
+    @classmethod
+    def fetch_opening_transaction(cls, session, account_id):
+        split_account = aliased(Split)
+        split_equity = aliased(Split)
+        account_equity = aliased(Account)
+
+        return session.execute(select(Transaction)
+                                   .join(split_account, and_(split_account.transaction_id == Transaction.id, split_account.account_id == account_id))
+                                   .join(split_equity, split_equity.transaction_id == Transaction.id)
+                                   .join(account_equity, and_(account_equity.id == split_equity.account_id, account_equity.path == "/Equity/"))
+                               ).first()[0]
+
+    @classmethod
+    def get_opening_transaction(cls, session, account_id):
+        transaction = cls.fetch_opening_transaction(session, account_id)
+
+        if transaction is None:
+            return None
+
+        return OpeningTransaction(
+            opening_date=transaction.transaction_date,
+            opening_balance=transaction.splits[0].amount
+        )
+
+    @classmethod
+    def update_opening_transaction(cls, session, account, schema):
+        opening_transaction = cls.fetch_opening_transaction(session, account.id)
+
+        stmt = select(Transaction).join(Split) \
+          .where(Transaction.id != opening_transaction.id) \
+          .where(Split.account_id == account.id) \
+          .order_by(Transaction.transaction_date.asc())
+
+        first_transaction = session.exec(stmt).first()
+        if first_transaction and schema.opening_date > first_transaction[0].transaction_date:
+            raise ValueError("Account opening date is posterior to its first transaction date")
+
+        opening_transaction = cls.fetch_opening_transaction(session, account.id)
+        opening_transaction.transaction_date = schema.opening_date
+        opening_transaction.splits[0].amount = schema.opening_balance
+        opening_transaction.splits[1].amount = - schema.opening_balance
+
+        session.commit()
+        session.refresh(opening_transaction)
+
+        return OpeningTransaction(
+            opening_date=opening_transaction.transaction_date,
+            opening_balance=opening_transaction.splits[0].amount
+        )
+
     @classmethod
     def schema_to_model(cls, session, schema, model=None):
         try:

api/app/account/schemas.py

@@ -4,7 +4,7 @@ from typing import Optional
 from uuid import UUID, uuid4
 
 from sqlmodel import Field, SQLModel
-from pydantic import Field as PydField
+from pydantic import Field as PydField, BaseModel
 from pydantic.json_schema import SkipJsonSchema
 
 from account.enums import Asset, Liability, CategoryFamily
@@ -67,3 +67,10 @@ class CategoryCreate(CategoryWrite):
 
 class CategoryUpdate(CategoryWrite):
     pass
+
+class OpeningTransaction(BaseModel):
+    opening_date: date = Field()
+    opening_balance: MonetaryAmount = Field(default=0)
+
+class OpeningTransactionUpdate(OpeningTransaction):
+    pass