Fully functional opening transactions

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: