zwitschi
5ecd2b8d19
feat: Refactor Dashboard template to extend base layout and improve structure feat: Enhance Parameter Input template with improved layout and feedback mechanisms feat: Update Scenario Form template to utilize base layout and improve user experience feat: Create base layout template for consistent styling across pages feat: Add Consumption, Costs, Equipment, Maintenance, Production, Reporting, and Simulations templates with placeholders for future functionality feat: Implement base header and footer partials for consistent navigation and footer across the application
155 lines
5.0 KiB
Python
155 lines
5.0 KiB
Python
from collections import defaultdict
|
|
from datetime import datetime, timezone
|
|
from typing import Any, Dict, Optional
|
|
|
|
from fastapi import APIRouter, Depends, Request
|
|
from fastapi.responses import HTMLResponse
|
|
from fastapi.templating import Jinja2Templates
|
|
from sqlalchemy.orm import Session
|
|
|
|
from models.parameters import Parameter
|
|
from models.scenario import Scenario
|
|
from routes.dependencies import get_db
|
|
|
|
router = APIRouter()
|
|
|
|
# Set up Jinja2 templates directory
|
|
templates = Jinja2Templates(directory="templates")
|
|
|
|
|
|
def _context(request: Request, extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
|
|
payload: Dict[str, Any] = {
|
|
"request": request,
|
|
"current_year": datetime.now(timezone.utc).year,
|
|
}
|
|
if extra:
|
|
payload.update(extra)
|
|
return payload
|
|
|
|
|
|
def _render(
|
|
request: Request,
|
|
template_name: str,
|
|
extra: Optional[Dict[str, Any]] = None,
|
|
):
|
|
return templates.TemplateResponse(template_name, _context(request, extra))
|
|
|
|
|
|
def _load_scenarios(db: Session) -> Dict[str, Any]:
|
|
scenarios: list[Dict[str, Any]] = [
|
|
{
|
|
"id": item.id,
|
|
"name": item.name,
|
|
"description": item.description,
|
|
}
|
|
for item in db.query(Scenario).order_by(Scenario.name).all()
|
|
]
|
|
return {"scenarios": scenarios}
|
|
|
|
|
|
def _load_parameters(db: Session) -> Dict[str, Any]:
|
|
grouped: defaultdict[int, list[Dict[str, Any]]] = defaultdict(list)
|
|
for param in db.query(Parameter).order_by(Parameter.scenario_id, Parameter.id):
|
|
grouped[param.scenario_id].append(
|
|
{
|
|
"id": param.id,
|
|
"name": param.name,
|
|
"value": param.value,
|
|
"distribution_type": param.distribution_type,
|
|
"distribution_parameters": param.distribution_parameters,
|
|
}
|
|
)
|
|
return {"parameters_by_scenario": dict(grouped)}
|
|
|
|
|
|
def _load_costs(_: Session) -> Dict[str, Any]:
|
|
return {"capex_entries": [], "opex_entries": []}
|
|
|
|
|
|
def _load_consumption(_: Session) -> Dict[str, Any]:
|
|
return {"consumption_records": []}
|
|
|
|
|
|
def _load_production(_: Session) -> Dict[str, Any]:
|
|
return {"production_records": []}
|
|
|
|
|
|
def _load_equipment(_: Session) -> Dict[str, Any]:
|
|
return {"equipment_items": []}
|
|
|
|
|
|
def _load_maintenance(_: Session) -> Dict[str, Any]:
|
|
return {"maintenance_records": []}
|
|
|
|
|
|
def _load_simulations(_: Session) -> Dict[str, Any]:
|
|
return {"simulation_runs": []}
|
|
|
|
|
|
def _load_reporting(_: Session) -> Dict[str, Any]:
|
|
return {"report_summaries": []}
|
|
|
|
|
|
@router.get("/ui/scenarios", response_class=HTMLResponse)
|
|
async def scenario_form(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the scenario creation form."""
|
|
context = _load_scenarios(db)
|
|
return _render(request, "ScenarioForm.html", context)
|
|
|
|
|
|
@router.get("/ui/dashboard", response_class=HTMLResponse)
|
|
async def dashboard(request: Request):
|
|
"""Render the reporting dashboard."""
|
|
return _render(request, "Dashboard.html")
|
|
|
|
|
|
@router.get("/ui/parameters", response_class=HTMLResponse)
|
|
async def parameter_form(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the parameter input form."""
|
|
context: Dict[str, Any] = {}
|
|
context.update(_load_scenarios(db))
|
|
context.update(_load_parameters(db))
|
|
return _render(request, "ParameterInput.html", context)
|
|
|
|
|
|
@router.get("/ui/costs", response_class=HTMLResponse)
|
|
async def costs_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the costs placeholder view."""
|
|
return _render(request, "costs.html", _load_costs(db))
|
|
|
|
|
|
@router.get("/ui/consumption", response_class=HTMLResponse)
|
|
async def consumption_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the consumption placeholder view."""
|
|
return _render(request, "consumption.html", _load_consumption(db))
|
|
|
|
|
|
@router.get("/ui/production", response_class=HTMLResponse)
|
|
async def production_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the production placeholder view."""
|
|
return _render(request, "production.html", _load_production(db))
|
|
|
|
|
|
@router.get("/ui/equipment", response_class=HTMLResponse)
|
|
async def equipment_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the equipment placeholder view."""
|
|
return _render(request, "equipment.html", _load_equipment(db))
|
|
|
|
|
|
@router.get("/ui/maintenance", response_class=HTMLResponse)
|
|
async def maintenance_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the maintenance placeholder view."""
|
|
return _render(request, "maintenance.html", _load_maintenance(db))
|
|
|
|
|
|
@router.get("/ui/simulations", response_class=HTMLResponse)
|
|
async def simulations_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the simulations placeholder view."""
|
|
return _render(request, "simulations.html", _load_simulations(db))
|
|
|
|
|
|
@router.get("/ui/reporting", response_class=HTMLResponse)
|
|
async def reporting_view(request: Request, db: Session = Depends(get_db)):
|
|
"""Render the reporting placeholder view."""
|
|
return _render(request, "reporting.html", _load_reporting(db))
|