EHV/sejeteralo
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add interactive citizen page with sidebar, display settings, and adaptive CSS

Browse Source 
Major rework of the citizen-facing page:
- Chart + sidebar layout (auth/vote/countdown in right sidebar)
- DisplaySettings component (font size, chart density, color palettes)
- Adaptive CSS with clamp() throughout, responsive breakpoints at 480/768/1024
- Baseline charts zoomed on first tier for small consumption detail
- Marginal price chart with dual Y-axes (foyers left, €/m³ right)
- Key metrics banner (5 columns: recettes, palier, prix palier, prix médian, mon prix)
- Client-side p0/impacts computation, draggable median price bar
- Household dots toggle, vote overlay curves
- Auth returns volume_m3, vote captures submitted_at
- Cleaned header nav (removed Accueil/Super Admin for public visitors)
- Terminology: foyer for bills, électeur for votes
- 600m³ added to impact reference volumes
- Realistic seed votes (50 votes, 3 profiles)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Yvv
2026-02-23 21:00:22 +01:00
parent 6caea1b809
commit 5dc42af33e
19 changed files with 2109 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
backend/app/engine/current_model.py
View File

@@ -56,11 +56,14 @@ def compute_linear_tariff(
price_m3_rp = abop / vv + p0
price_m3_rs = abos / vv + p0
def sanitize(arr):
return [0.0 if (x != x or x == float('inf') or x == float('-inf')) else float(x) for x in arr]
return LinearTariffResult(
p0=p0,
curve_volumes=vv.tolist(),
curve_bills_rp=bills_rp.tolist(),
curve_bills_rs=bills_rs.tolist(),
curve_price_m3_rp=price_m3_rp.tolist(),
curve_price_m3_rs=price_m3_rs.tolist(),
curve_volumes=sanitize(vv),
curve_bills_rp=sanitize(bills_rp),
curve_bills_rs=sanitize(bills_rs),
curve_price_m3_rp=sanitize(price_m3_rp),
curve_price_m3_rs=sanitize(price_m3_rs),
)

15
backend/app/engine/pricing.py
View File

@@ -138,13 +138,16 @@ def compute_tariff(
a1, a2, b2 = compute_integrals(vol, vinf, vmax, pmax, a, b, c, d, e)
household_bills.append(abo + (a1 + a2) * p0 + b2)
def sanitize(arr):
return [0.0 if (x != x or x == float('inf') or x == float('-inf')) else float(x) for x in arr]
return TariffResult(
p0=p0,
curve_volumes=vv.tolist(),
curve_prices_m3=prix_m3.tolist(),
curve_bills_rp=bills_rp.tolist(),
curve_bills_rs=bills_rs.tolist(),
household_bills=household_bills,
curve_volumes=sanitize(vv),
curve_prices_m3=sanitize(prix_m3),
curve_bills_rp=sanitize(bills_rp),
curve_bills_rs=sanitize(bills_rs),
household_bills=sanitize(household_bills),
)
@@ -169,7 +172,7 @@ def compute_impacts(
Returns (p0, list of ImpactRow).
"""
if reference_volumes is None:
reference_volumes = [30, 60, 90, 150, 300]
reference_volumes = [30, 60, 90, 150, 300, 600]
p0 = compute_p0(households, recettes, abop, abos, vinf, vmax, pmax, a, b, c, d, e)

11
backend/app/models/models.py
View File

@@ -48,9 +48,20 @@ class TariffParams(Base):
recettes = Column(Float, default=75000.0)
pmax = Column(Float, default=20.0)
vmax = Column(Float, default=2100.0)
differentiated_tariff = Column(Boolean, default=False)
data_year = Column(Integer, nullable=True)
data_imported_at = Column(DateTime, nullable=True)
# Published Bézier curve (set by admin)
published_vinf = Column(Float, nullable=True)
published_a = Column(Float, nullable=True)
published_b = Column(Float, nullable=True)
published_c = Column(Float, nullable=True)
published_d = Column(Float, nullable=True)
published_e = Column(Float, nullable=True)
published_p0 = Column(Float, nullable=True)
published_at = Column(DateTime, nullable=True)
commune = relationship("Commune", back_populates="tariff_params")

1
backend/app/routers/auth.py
View File

@@ -51,6 +51,7 @@ async def citizen_verify(data: CitizenVerify, db: AsyncSession = Depends(get_db)
access_token=create_citizen_token(household, data.commune_slug),
role="citizen",
commune_slug=data.commune_slug,
volume_m3=household.volume_m3,
)

51
backend/app/routers/communes.py
View File

@@ -2,13 +2,16 @@ from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, delete
from datetime import datetime
from app.database import get_db
from app.models import Commune, TariffParams, Household, Vote, CommuneContent, AdminUser, admin_commune_table
from app.schemas import (
CommuneCreate, CommuneUpdate, CommuneOut,
TariffParamsUpdate, TariffParamsOut,
TariffParamsUpdate, TariffParamsOut, PublishCurveRequest,
)
from app.services.auth_service import get_current_admin, require_super_admin
from app.engine.pricing import HouseholdData, compute_p0
router = APIRouter()
@@ -128,3 +131,49 @@ async def update_params(
await db.commit()
await db.refresh(params)
return params
@router.post("/{slug}/params/publish", response_model=TariffParamsOut)
async def publish_curve(
slug: str,
data: PublishCurveRequest,
db: AsyncSession = Depends(get_db),
admin: AdminUser = Depends(get_current_admin),
):
"""Admin publishes a Bézier curve as the commune's reference."""
result = await db.execute(
select(TariffParams).join(Commune).where(Commune.slug == slug)
)
params = result.scalar_one_or_none()
if not params:
raise HTTPException(status_code=404, detail="Paramètres introuvables")
# Compute p0 for this curve
hh_result = await db.execute(
select(Household).join(Commune).where(Commune.slug == slug)
)
households_db = hh_result.scalars().all()
households = [
HouseholdData(volume_m3=h.volume_m3, status=h.status, price_paid_eur=h.price_paid_eur)
for h in households_db
]
p0 = compute_p0(
households,
recettes=params.recettes, abop=params.abop, abos=params.abos,
vinf=data.vinf, vmax=params.vmax, pmax=params.pmax,
a=data.a, b=data.b, c=data.c, d=data.d, e=data.e,
)
params.published_vinf = data.vinf
params.published_a = data.a
params.published_b = data.b
params.published_c = data.c
params.published_d = data.d
params.published_e = data.e
params.published_p0 = p0
params.published_at = datetime.utcnow()
await db.commit()
await db.refresh(params)
return params

53
backend/app/routers/households.py
View File

@@ -16,6 +16,59 @@ from app.services.import_service import parse_import_file, import_households, ge
router = APIRouter()
@router.get("/communes/{slug}/households/distribution")
async def household_distribution(
slug: str,
bucket_size: int = 50,
db: AsyncSession = Depends(get_db),
):
"""Public: returns consumption distribution as histogram buckets."""
result = await db.execute(select(Commune).where(Commune.slug == slug))
commune = result.scalar_one_or_none()
if not commune:
raise HTTPException(status_code=404, detail="Commune introuvable")
hh_result = await db.execute(
select(Household).where(Household.commune_id == commune.id)
)
households = hh_result.scalars().all()
if not households:
return {"buckets": [], "total": 0, "bucket_size": bucket_size}
volumes = [h.volume_m3 for h in households]
max_vol = max(volumes)
num_buckets = int(max_vol // bucket_size) + 1
buckets = []
for i in range(num_buckets):
low = i * bucket_size
high = (i + 1) * bucket_size
count = sum(1 for v in volumes if low <= v < high)
if count > 0 or i < num_buckets:
buckets.append({"low": low, "high": high, "count": count})
return {"buckets": buckets, "total": len(households), "bucket_size": bucket_size}
@router.get("/communes/{slug}/households/volumes")
async def household_volumes(
slug: str,
db: AsyncSession = Depends(get_db),
):
"""Public: returns anonymous list of household volumes and statuses for chart display."""
result = await db.execute(select(Commune).where(Commune.slug == slug))
commune = result.scalar_one_or_none()
if not commune:
raise HTTPException(status_code=404, detail="Commune introuvable")
hh_result = await db.execute(
select(Household.volume_m3, Household.status).where(Household.commune_id == commune.id)
)
rows = hh_result.all()
return [{"volume_m3": r.volume_m3, "status": r.status} for r in rows]
@router.get("/communes/{slug}/households/template")
async def download_template():
content = generate_template_csv()

35
backend/app/routers/votes.py
View File

@@ -103,29 +103,47 @@ async def current_curve(slug: str, db: AsyncSession = Depends(get_db)):
)
votes = result.scalars().all()
# Published curve from admin (if any)
published = None
if params.published_vinf is not None:
published = {
"vinf": params.published_vinf,
"a": params.published_a,
"b": params.published_b,
"c": params.published_c,
"d": params.published_d,
"e": params.published_e,
"p0": params.published_p0,
}
if not votes:
# Return default Bézier curve (a=b=c=d=e=0.5, vinf=vmax/2)
default_vinf = params.vmax / 2
# Use published curve if available, otherwise default
if published:
dv, da, db_, dc, dd, de = published["vinf"], published["a"], published["b"], published["c"], published["d"], published["e"]
else:
dv, da, db_, dc, dd, de = 400, 0.5, 0.5, 0.5, 0.5, 0.5
default_tariff = compute_tariff(
households,
recettes=params.recettes, abop=params.abop, abos=params.abos,
vinf=default_vinf, vmax=params.vmax, pmax=params.pmax,
a=0.5, b=0.5, c=0.5, d=0.5, e=0.5,
vinf=dv, vmax=params.vmax, pmax=params.pmax,
a=da, b=db_, c=dc, d=dd, e=de,
)
_, default_impacts = compute_impacts(
households,
recettes=params.recettes, abop=params.abop, abos=params.abos,
vinf=default_vinf, vmax=params.vmax, pmax=params.pmax,
a=0.5, b=0.5, c=0.5, d=0.5, e=0.5,
vinf=dv, vmax=params.vmax, pmax=params.pmax,
a=da, b=db_, c=dc, d=dd, e=de,
)
return {
"has_votes": False,
"vote_count": 0,
"params": tariff_params,
"published": published,
"median": {
"vinf": default_vinf, "a": 0.5, "b": 0.5,
"c": 0.5, "d": 0.5, "e": 0.5,
"vinf": dv, "a": da, "b": db_,
"c": dc, "d": dd, "e": de,
},
"p0": default_tariff.p0,
"curve_volumes": default_tariff.curve_volumes,
@@ -166,6 +184,7 @@ async def current_curve(slug: str, db: AsyncSession = Depends(get_db)):
"has_votes": True,
"vote_count": len(votes),
"params": tariff_params,
"published": published,
"median": {
"vinf": median.vinf,
"a": median.a,

20
backend/app/schemas/schemas.py
View File

@@ -21,6 +21,7 @@ class Token(BaseModel):
token_type: str = "bearer"
role: str
commune_slug: str | None = None
volume_m3: float | None = None
# ── Commune ──
@@ -58,6 +59,7 @@ class TariffParamsUpdate(BaseModel):
recettes: float | None = None
pmax: float | None = None
vmax: float | None = None
differentiated_tariff: bool | None = None
data_year: int | None = None
@@ -67,12 +69,30 @@ class TariffParamsOut(BaseModel):
recettes: float
pmax: float
vmax: float
differentiated_tariff: bool = False
data_year: int | None = None
data_imported_at: datetime | None = None
published_vinf: float | None = None
published_a: float | None = None
published_b: float | None = None
published_c: float | None = None
published_d: float | None = None
published_e: float | None = None
published_p0: float | None = None
published_at: datetime | None = None
model_config = {"from_attributes": True}
class PublishCurveRequest(BaseModel):
vinf: float = Field(ge=0)
a: float = Field(ge=0, le=1)
b: float = Field(ge=0, le=1)
c: float = Field(ge=0, le=1)
d: float = Field(ge=0, le=1)
e: float = Field(ge=0, le=1)
# ── Household ──
class HouseholdOut(BaseModel):