feat: add API to get daily consumption

server/app/adapters/http/__init__.py

@@ -0,0 +1,3 @@
+from .readings import readings_router
+
+__all__ = ["readings_router"]

server/app/adapters/http/_readings_schemas.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+from pydantic import BaseModel
+
+from domain.entities import ConsumptionResponse
+
+class ConsumptionPointSchema(BaseModel):
+    period: datetime
+    pulse_count_start: int
+    pulse_count_end: int
+    delta_pulses: int
+    delta_m3: float
+
+class ConsumptionResponseSchema(BaseModel):
+    dev_eui: str
+    start: datetime
+    end: datetime
+    granularity: str
+    points: list[ConsumptionPointSchema]
+
+    @classmethod
+    def from_domain(cls, r: ConsumptionResponse) -> "ConsumptionResponseSchema":
+        return cls(
+            dev_eui=r.dev_eui,
+            start=r.start,
+            end=r.end,
+            granularity=r.granularity,
+            points=[ConsumptionPointSchema(**p.__dict__) for p in r.points],
+        )

server/app/adapters/http/main.py

@@ -0,0 +1,18 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .readings import readings_router
+
+app = FastAPI(title="SimuGazAPI", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["GET"],
+    allow_headers=["*"],
+)
+
+app.include_router(readings_router)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}

server/app/adapters/http/readings.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query, HTTPException
+
+from domain.value_objects import Granularity
+from domain.exceptions import ValidationError, DatabaseError
+from services.consumption_service import ConsumptionService
+from dependencies import get_consumption_service
+
+from ._readings_schemas import ConsumptionResponseSchema
+
+readings_router = APIRouter(prefix="/readings", tags=["readings"])
+
+
+@readings_router.get("/{dev_eui}", response_model=ConsumptionResponseSchema)
+def get_consumption(
+    dev_eui: str,
+    start: Annotated[datetime, Query()],
+    end: Annotated[datetime, Query()],
+    granularity: Annotated[Granularity, Query()] = "day",
+    service: ConsumptionService = Depends(get_consumption_service),
+):
+    try:
+        result = service.get_consumption(dev_eui, start, end, granularity)
+        return ConsumptionResponseSchema.from_domain(result)
+    except ValidationError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+    except DatabaseError as e:
+        raise HTTPException(status_code=500, detail=str(e))

server/app/adapters/postgres_query.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+
+import psycopg2
+from psycopg2.extensions import connection
+
+from domain.entities import ConsumptionPoint
+from domain.exceptions import DatabaseError
+from domain.value_objects import Granularity
+from ports.reading_query_repository import ReadingQueryRepository
+
+
+class PgReadingQueryRepository(ReadingQueryRepository):
+    def __init__(self, conn: connection) -> None:
+        self._conn = conn
+
+    def get_consumption(
+        self,
+        dev_eui: str,
+        start: datetime,
+        end: datetime,
+        granularity: Granularity,
+    ) -> list[ConsumptionPoint]:
+        date_trunc = granularity
+        query = """
+            SELECT
+                DATE_TRUNC(%s, r.date)          AS period,
+                MIN(r.pulses)                   AS pulse_start,
+                MAX(r.pulses)                   AS pulse_end,
+                MAX(r.pulses) - MIN(r.pulses)   AS delta_pulses
+            FROM reading r
+            JOIN device d ON d.device_id = r.device_id
+            WHERE d.device_eui = %s
+              AND r.date >= %s
+              AND r.date <  %s
+            GROUP BY period
+            ORDER BY period ASC
+        """
+        try:
+            with self._conn.cursor() as cur:
+                cur.execute(query, (date_trunc, dev_eui, start, end))
+                rows = cur.fetchall()
+        except psycopg2.DatabaseError as e:
+            raise DatabaseError(f"Erreur requête consumption : {e}") from e
+
+        return [
+            ConsumptionPoint(
+                period=row[0],
+                pulse_count_start=row[1],
+                pulse_count_end=row[2],
+                delta_pulses=row[3],
+                delta_m3=round(row[3] * 0.010, 3),
+            )
+            for row in rows
+        ]