feat: implement master data management module and add automatic database schema initialization

src/dashboard_model/model.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Float, String
+from src.database.core import Base
+from src.models import DefaultMixin
+
+class RBDMasterData(Base, DefaultMixin):
+    __tablename__ = "rbd_ms_master_data"
+    
+    name = Column(String(255), unique=True, nullable=False, index=True)
+    value_float = Column(Float, nullable=True)
+    value_string = Column(String(255), nullable=True)

src/dashboard_model/router.py

@@ -8,6 +8,7 @@ from src.dashboard_model.schema import DashboardModelQuery
 from src.database.core import DbSession
 from src.database.service import CommonParameters
 from src.models import StandardResponse
+from src.dashboard_model.schema_masterdata import RBDMasterDataSchema, RBDMasterDataUpdate
 
 from .service import get_model_data
 
@@ -26,3 +27,29 @@ async def get_dashboard_model_data(
         data=result,
         message="Data retrieved successfully",
     )
+
+
+@router.get("/master-data", response_model=StandardResponse[List[RBDMasterDataSchema]])
+async def get_dashboard_master_data(
+    db_session: DbSession
+):
+    from src.dashboard_model.service import get_master_data_list
+    result = await get_master_data_list(db_session=db_session)
+    return StandardResponse(
+        data=result,
+        message="Master data retrieved successfully"
+    )
+
+
+@router.post("/master-data/{md_id}/update", response_model=StandardResponse[RBDMasterDataSchema])
+async def update_dashboard_master_data(
+    md_id: UUID,
+    payload: RBDMasterDataUpdate,
+    db_session: DbSession
+):
+    from src.dashboard_model.service import update_master_data
+    result = await update_master_data(db_session=db_session, md_id=md_id, payload=payload)
+    return StandardResponse(
+        data=result,
+        message="Master data updated successfully"
+    )

src/dashboard_model/schema_masterdata.py

@@ -0,0 +1,14 @@
+from typing import Optional
+from pydantic import BaseModel, ConfigDict
+
+class RBDMasterDataSchema(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    
+    id: str
+    name: str
+    value_float: Optional[float] = None
+    value_string: Optional[str] = None
+
+class RBDMasterDataUpdate(BaseModel):
+    value_float: Optional[float] = None
+    value_string: Optional[str] = None

src/dashboard_model/service.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 from uuid import UUID
 
 from fastapi import HTTPException, status
@@ -17,6 +17,46 @@ from src.database.core import DbSession
 from src.database.service import search_filter_sort_paginate
 from tkinter.constants import E
 
+from src.dashboard_model.model import RBDMasterData
+from src.dashboard_model.schema_masterdata import RBDMasterDataUpdate
+
+
+async def _get_or_create_master_data(db_session: DbSession, name: str, default_float: float):
+    query = select(RBDMasterData).where(RBDMasterData.name == name)
+    result = await db_session.execute(query)
+    record = result.scalars().first()
+    if not record:
+        record = RBDMasterData(name=name, value_float=default_float)
+        db_session.add(record)
+        await db_session.commit()
+        await db_session.refresh(record)
+    return record
+
+
+async def get_master_data_list(db_session: DbSession):
+    # Ensure Current EAF exists
+    await _get_or_create_master_data(db_session, "Current EAF Realization", 85.62)
+    query = select(RBDMasterData)
+    result = await db_session.execute(query)
+    return result.scalars().all()
+
+
+async def update_master_data(db_session: DbSession, md_id: UUID, payload: RBDMasterDataUpdate):
+    query = select(RBDMasterData).where(RBDMasterData.id == md_id)
+    result = await db_session.execute(query)
+    record = result.scalars().first()
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Master Data not found"
+        )
+    if payload.value_float is not None:
+        record.value_float = payload.value_float
+    if payload.value_string is not None:
+        record.value_string = payload.value_string
+    await db_session.commit()
+    await db_session.refresh(record)
+    return record
+
 
 async def get_model_data(*, db_session: DbSession, simulation_id: Optional[UUID]):
     if simulation_id:
@@ -54,11 +94,14 @@ async def get_model_data(*, db_session: DbSession, simulation_id: Optional[UUID]
     
     SOF = main_calc_data.sof
     
+    #Fetch Master Data EAF realization
+    eaf_record = await _get_or_create_master_data(db_session, "Current EAF Realization", 85.62)
+    eaf_real_val = eaf_record.value_float if eaf_record.value_float is not None else 85.62
     
     #Realization
-    EAF_REAL = 85.62
+    EAF_REAL = eaf_real_val
     EFOR_REAL = 1.7
-    EAF_KONKIN_REAL = 85.62
+    EAF_KONKIN_REAL = eaf_real_val
 
     powerplant_reliability = {
         "Plant Control": 98,

src/main.py

@@ -44,9 +44,20 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
 configure_logging()
 
 # we create the ASGI for the app
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from src.database.core import engine, Base
+    import src.dashboard_model.model
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield
+
 app = FastAPI(openapi_url="", title="LCCA API",
               description="Welcome to RBD's API documentation!",
-              version="0.1.0")
+              version="0.1.0",
+              lifespan=lifespan)
 
 # we define the exception handlers
 app.add_exception_handler(Exception, handle_exception)

sync_db.py

@@ -0,0 +1,9 @@
+import asyncio
+from src.database.core import Base, engine
+
+async def main():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    print("Created tables")
+
+p = asyncio.run(main())