feat: Implement currency management with models, routes, and UI updates; add backfill script for existing records

models/__init__.py

@@ -0,0 +1,5 @@
+"""
+models package initializer. Import the currency model so it's registered
+with the shared Base.metadata when the package is imported by tests.
+"""
+from . import currency  # noqa: F401

models/capex.py

@@ -1,3 +1,4 @@
+from sqlalchemy import event, text
 from sqlalchemy import Column, Integer, Float, String, ForeignKey
 from sqlalchemy.orm import relationship
 from config.database import Base
@@ -10,12 +11,55 @@ class Capex(Base):
     scenario_id = Column(Integer, ForeignKey("scenario.id"), nullable=False)
     amount = Column(Float, nullable=False)
     description = Column(String, nullable=True)
-    currency_code = Column(String(3), nullable=False, default="USD")
+    currency_id = Column(Integer, ForeignKey("currency.id"), nullable=False)
 
     scenario = relationship("Scenario", back_populates="capex_items")
+    currency = relationship("Currency", back_populates="capex_items")
 
     def __repr__(self):
         return (
             f"<Capex id={self.id} scenario_id={self.scenario_id} "
-            f"amount={self.amount} currency={self.currency_code}>"
+            f"amount={self.amount} currency_id={self.currency_id}>"
         )
+
+    @property
+    def currency_code(self) -> str:
+        return self.currency.code if self.currency else None
+
+    @currency_code.setter
+    def currency_code(self, value: str) -> None:
+        # store pending code so application code or migrations can pick it up
+        setattr(self, "_currency_code_pending",
+                (value or "USD").strip().upper())
+
+
+# SQLAlchemy event handlers to ensure currency_id is set before insert/update
+
+
+def _resolve_currency(mapper, connection, target):
+    # If currency_id already set, nothing to do
+    if getattr(target, "currency_id", None):
+        return
+    code = getattr(target, "_currency_code_pending", None) or "USD"
+    # Try to find existing currency id
+    row = connection.execute(text("SELECT id FROM currency WHERE code = :code"), {
+                             "code": code}).fetchone()
+    if row:
+        cid = row[0]
+    else:
+        # Insert new currency and attempt to get lastrowid
+        res = connection.execute(
+            text("INSERT INTO currency (code, name, symbol, is_active) VALUES (:code, :name, :symbol, :active)"),
+            {"code": code, "name": code, "symbol": None, "active": True},
+        )
+        try:
+            cid = res.lastrowid
+        except Exception:
+            # fallback: select after insert
+            cid = connection.execute(text("SELECT id FROM currency WHERE code = :code"), {
+                                     "code": code}).scalar()
+    target.currency_id = cid
+
+
+event.listen(Capex, "before_insert", _resolve_currency)
+event.listen(Capex, "before_update", _resolve_currency)

models/currency.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, Integer, String, Boolean
+from sqlalchemy.orm import relationship
+from config.database import Base
+
+
+class Currency(Base):
+    __tablename__ = "currency"
+
+    id = Column(Integer, primary_key=True, index=True)
+    code = Column(String(3), nullable=False, unique=True, index=True)
+    name = Column(String(128), nullable=False)
+    symbol = Column(String(8), nullable=True)
+    is_active = Column(Boolean, nullable=False, default=True)
+
+    # reverse relationships (optional)
+    capex_items = relationship(
+        "Capex", back_populates="currency", lazy="select")
+    opex_items = relationship("Opex", back_populates="currency", lazy="select")
+
+    def __repr__(self):
+        return f"<Currency code={self.code} name={self.name} symbol={self.symbol}>"

models/opex.py

@@ -1,3 +1,4 @@
+from sqlalchemy import event, text
 from sqlalchemy import Column, Integer, Float, String, ForeignKey
 from sqlalchemy.orm import relationship
 from config.database import Base
@@ -10,12 +11,47 @@ class Opex(Base):
     scenario_id = Column(Integer, ForeignKey("scenario.id"), nullable=False)
     amount = Column(Float, nullable=False)
     description = Column(String, nullable=True)
-    currency_code = Column(String(3), nullable=False, default="USD")
+    currency_id = Column(Integer, ForeignKey("currency.id"), nullable=False)
 
     scenario = relationship("Scenario", back_populates="opex_items")
+    currency = relationship("Currency", back_populates="opex_items")
 
     def __repr__(self):
         return (
             f"<Opex id={self.id} scenario_id={self.scenario_id} "
-            f"amount={self.amount} currency={self.currency_code}>"
+            f"amount={self.amount} currency_id={self.currency_id}>"
         )
+
+    @property
+    def currency_code(self) -> str:
+        return self.currency.code if self.currency else None
+
+    @currency_code.setter
+    def currency_code(self, value: str) -> None:
+        setattr(self, "_currency_code_pending",
+                (value or "USD").strip().upper())
+
+
+def _resolve_currency_opex(mapper, connection, target):
+    if getattr(target, "currency_id", None):
+        return
+    code = getattr(target, "_currency_code_pending", None) or "USD"
+    row = connection.execute(text("SELECT id FROM currency WHERE code = :code"), {
+                             "code": code}).fetchone()
+    if row:
+        cid = row[0]
+    else:
+        res = connection.execute(
+            text("INSERT INTO currency (code, name, symbol, is_active) VALUES (:code, :name, :symbol, :active)"),
+            {"code": code, "name": code, "symbol": None, "active": True},
+        )
+        try:
+            cid = res.lastrowid
+        except Exception:
+            cid = connection.execute(text("SELECT id FROM currency WHERE code = :code"), {
+                                     "code": code}).scalar()
+    target.currency_id = cid
+
+
+event.listen(Opex, "before_insert", _resolve_currency_opex)
+event.listen(Opex, "before_update", _resolve_currency_opex)