dashboard analytics v2

Author: Leoglme

api/routes/stats_route.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Annotated, Any
+import datetime as dt
+from typing import Annotated, Any, Literal
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 
 from core.database import get_db
@@ -15,6 +16,19 @@
 router = APIRouter(prefix="/stats", tags=["stats"])
 
 
+def _parse_iso(value: str | None) -> dt.datetime | None:
+    if value is None:
+        return None
+    try:
+        # ``fromisoformat`` accepts both date and datetime strings (Py 3.11+).
+        parsed = dt.datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid ISO date: {value}") from exc
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.UTC)
+    return parsed
+
+
 @router.get("/dashboard")
 def dashboard(
     db: Annotated[Session, Depends(get_db)],
@@ -23,5 +37,18 @@ def dashboard(
         False,
         description="If true, sums Cardmarket EUR per article via PokéWallet (slower).",
     ),
+    start: str | None = Query(None, description="Range start (ISO date or datetime)."),
+    end: str | None = Query(None, description="Range end (ISO date or datetime)."),
+    period: Literal["daily", "weekly", "monthly"] = Query(
+        "daily",
+        description="Bucket size for the revenue timeline.",
+    ),
 ) -> dict[str, Any]:
-    return compute_dashboard_stats(db, user.id, include_market=include_market)
+    return compute_dashboard_stats(
+        db,
+        user.id,
+        include_market=include_market,
+        range_start=_parse_iso(start),
+        range_end=_parse_iso(end),
+        period=period,
+    )

api/services/stats_service.py

@@ -3,14 +3,16 @@
 from __future__ import annotations
 
 import datetime as dt
-from typing import Any
+from typing import Any, Literal
 
 from sqlalchemy.orm import Session
 
 from models.article import Article
 from services import article_service
 from services.pricing_service import fetch_card_prices
 
+Period = Literal["daily", "weekly", "monthly"]
+
 
 def _as_utc(value: dt.datetime | None) -> dt.datetime | None:
     if value is None:
@@ -47,36 +49,125 @@ def _hours_to_sell(article: Article) -> float | None:
     return max(0.0, delta.total_seconds() / 3600.0)
 
 
+def _bucket_key(value: dt.datetime, period: Period) -> dt.datetime:
+    """Truncate a UTC datetime to the start of its daily/weekly/monthly bucket."""
+    if period == "monthly":
+        return value.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    base = value.replace(hour=0, minute=0, second=0, microsecond=0)
+    if period == "weekly":
+        # Monday as week start
+        return base - dt.timedelta(days=base.weekday())
+    return base
+
+
+def _iter_buckets(start: dt.datetime, end: dt.datetime, period: Period) -> list[dt.datetime]:
+    """Inclusive list of bucket starts covering [start, end]."""
+    if start > end:
+        start, end = end, start
+    cursor = _bucket_key(start, period)
+    last = _bucket_key(end, period)
+    buckets: list[dt.datetime] = []
+    safety = 0
+    while cursor <= last and safety < 5000:
+        buckets.append(cursor)
+        if period == "monthly":
+            year, month = cursor.year, cursor.month + 1
+            if month > 12:
+                month = 1
+                year += 1
+            cursor = cursor.replace(year=year, month=month, day=1)
+        elif period == "weekly":
+            cursor = cursor + dt.timedelta(days=7)
+        else:
+            cursor = cursor + dt.timedelta(days=1)
+        safety += 1
+    return buckets
+
+
 def compute_dashboard_stats(
     db: Session,
     user_id: int,
     *,
     include_market: bool = False,
+    range_start: dt.datetime | None = None,
+    range_end: dt.datetime | None = None,
+    period: Period = "daily",
 ) -> dict[str, Any]:
-    """Profit windows, rankings, Vinted revenue, optional sum of Cardmarket refs for inventory."""
+    """Profit, revenue, channel split and per-period revenue timeline.
+
+    The ``range_start``/``range_end``/``period`` arguments drive the windowed
+    metrics ("profit_period_eur", "revenue_period_eur", split per channel and
+    the ``revenue_timeline`` used by the chart). Totals (profit_total_eur,
+    inventory…) ignore the range and reflect the whole catalogue.
+    """
     now = dt.datetime.now(dt.UTC)
-    week_start = now - dt.timedelta(days=7)
-    month_start = now - dt.timedelta(days=30)
+    if range_end is None:
+        range_end = now
+    if range_start is None:
+        range_start = range_end - dt.timedelta(days=14)
+    range_start = _as_utc(range_start) or now
+    range_end = _as_utc(range_end) or now
+    if range_start > range_end:
+        range_start, range_end = range_end, range_start
+    # Make the end inclusive (cover the full last day)
+    range_end_inclusive = range_end.replace(hour=23, minute=59, second=59, microsecond=999_999)
 
     rows = article_service.list_articles_for_user(db, user_id)
     sold = [a for a in rows if a.is_sold]
 
-    def in_week(a: Article) -> bool:
+    def in_range(a: Article) -> bool:
         sold_at = _as_utc(a.sold_at)
-        return bool(sold_at and sold_at >= week_start)
+        return bool(sold_at and range_start <= sold_at <= range_end_inclusive)
 
-    def in_month(a: Article) -> bool:
-        sold_at = _as_utc(a.sold_at)
-        return bool(sold_at and sold_at >= month_start)
+    sold_in_range = [a for a in sold if in_range(a)]
 
-    profit_week = sum(_profit_eur(a) for a in sold if in_week(a))
-    profit_month = sum(_profit_eur(a) for a in sold if in_month(a))
-    profit_total = sum(_profit_eur(a) for a in sold)
+    profit_period = sum(_profit_eur(a) for a in sold_in_range)
+    revenue_period = sum(
+        p for a in sold_in_range for p in [_sale_proceeds_eur(a)] if p is not None
+    )
+    period_sales_count = len(sold_in_range)
 
-    vinted_revenue = sum(
+    profit_total = sum(_profit_eur(a) for a in sold)
+    vinted_revenue_total = sum(
         p for a in sold for p in [_sale_proceeds_eur(a)] if p is not None
     )
 
+    # Channel breakdown over the selected range (Vinted vs eBay)
+    vinted_count = sum(1 for a in sold_in_range if a.sale_source == "vinted")
+    ebay_count = sum(1 for a in sold_in_range if a.sale_source == "ebay")
+    vinted_revenue_period = sum(
+        p
+        for a in sold_in_range
+        if a.sale_source == "vinted"
+        for p in [_sale_proceeds_eur(a)]
+        if p is not None
+    )
+    ebay_revenue_period = sum(
+        p
+        for a in sold_in_range
+        if a.sale_source == "ebay"
+        for p in [_sale_proceeds_eur(a)]
+        if p is not None
+    )
+
+    # Same split across all-time (used for the Vinted vs eBay pie)
+    vinted_count_total = sum(1 for a in sold if a.sale_source == "vinted")
+    ebay_count_total = sum(1 for a in sold if a.sale_source == "ebay")
+    vinted_revenue_total_split = sum(
+        p
+        for a in sold
+        if a.sale_source == "vinted"
+        for p in [_sale_proceeds_eur(a)]
+        if p is not None
+    )
+    ebay_revenue_total_split = sum(
+        p
+        for a in sold
+        if a.sale_source == "ebay"
+        for p in [_sale_proceeds_eur(a)]
+        if p is not None
+    )
+
     top_profitable = sorted(sold, key=_profit_eur, reverse=True)[:5]
     with_duration = [(a, _hours_to_sell(a)) for a in sold]
     with_duration = [(a, h) for a, h in with_duration if h is not None]
@@ -88,28 +179,30 @@ def in_month(a: Article) -> bool:
     inventory_sell_total_eur = sum(
         float(a.sell_price) for a in unsold if a.sell_price is not None
     )
+    inventory_estimated_profit_eur = sum(
+        float(a.sell_price) - float(a.purchase_price)
+        for a in unsold
+        if a.sell_price is not None
+    )
 
-    # Cumulative revenue by month (sell price of sold articles)
-    monthly_revenue: dict[str, float] = {}
-    for a in sold:
+    # Revenue timeline: bucketed per period within the selected range
+    buckets = _iter_buckets(range_start, range_end_inclusive, period)
+    bucket_totals: dict[dt.datetime, float] = {b: 0.0 for b in buckets}
+    for a in sold_in_range:
         sold_at = _as_utc(a.sold_at)
         proceeds = _sale_proceeds_eur(a)
         if sold_at is None or proceeds is None:
             continue
-        key = sold_at.strftime("%Y-%m")
-        monthly_revenue[key] = monthly_revenue.get(key, 0.0) + proceeds
-    revenue_timeline: list[dict[str, Any]] = []
-    cumulative_rev = 0.0
-    for month_key in sorted(monthly_revenue.keys()):
-        incremental = monthly_revenue[month_key]
-        cumulative_rev += incremental
-        revenue_timeline.append(
-            {
-                "month": month_key,
-                "revenue_month_eur": round(incremental, 2),
-                "revenue_cumulative_eur": round(cumulative_rev, 2),
-            }
-        )
+        key = _bucket_key(sold_at, period)
+        if key in bucket_totals:
+            bucket_totals[key] += proceeds
+    revenue_timeline: list[dict[str, Any]] = [
+        {
+            "date": b.isoformat(),
+            "revenue_eur": round(v, 2),
+        }
+        for b, v in bucket_totals.items()
+    ]
 
     recent_sales = sorted(
         sold,
@@ -154,13 +247,32 @@ def in_month(a: Article) -> bool:
                     market_sum_unsold += v
 
     return {
-        "profit_week_eur": round(profit_week, 2),
-        "profit_month_eur": round(profit_month, 2),
+        "range": {
+            "start": range_start.isoformat(),
+            "end": range_end.isoformat(),
+            "period": period,
+        },
+        "profit_period_eur": round(profit_period, 2),
+        "revenue_period_eur": round(revenue_period, 2),
+        "period_sales_count": period_sales_count,
         "profit_total_eur": round(profit_total, 2),
-        "vinted_revenue_eur": round(vinted_revenue, 2),
+        "vinted_revenue_eur": round(vinted_revenue_total, 2),
+        "channel_split_period": {
+            "vinted_count": vinted_count,
+            "ebay_count": ebay_count,
+            "vinted_revenue_eur": round(vinted_revenue_period, 2),
+            "ebay_revenue_eur": round(ebay_revenue_period, 2),
+        },
+        "channel_split_total": {
+            "vinted_count": vinted_count_total,
+            "ebay_count": ebay_count_total,
+            "vinted_revenue_eur": round(vinted_revenue_total_split, 2),
+            "ebay_revenue_eur": round(ebay_revenue_total_split, 2),
+        },
         "inventory_count": inventory_count,
         "inventory_purchase_total_eur": round(inventory_purchase_total_eur, 2),
         "inventory_sell_total_eur": round(inventory_sell_total_eur, 2),
+        "inventory_estimated_profit_eur": round(inventory_estimated_profit_eur, 2),
         "estimated_cardmarket_inventory_eur": round(market_sum, 2) if market_sum is not None else None,
         "estimated_cardmarket_unsold_eur": round(market_sum_unsold, 2)
         if market_sum_unsold is not None

todo.md

@@ -1 +0,0 @@
-demande d'accès fonctionelle

web/app/components/dashboard/Charts.client.vue

@@ -10,6 +10,18 @@ const eur = new Intl.NumberFormat('fr-FR', {
   currency: 'EUR',
   maximumFractionDigits: 0
 })
+
+function formatTimeToSell(hours: number): string {
+  if (!Number.isFinite(hours) || hours < 0) {
+    return '—'
+  }
+  if (hours < 24) {
+    const rounded = Math.max(1, Math.round(hours))
+    return `${rounded} h`
+  }
+  const days = Math.round(hours / 24)
+  return `${days} j`
+}
 </script>
 
 <template>
@@ -29,7 +41,7 @@ const eur = new Intl.NumberFormat('fr-FR', {
           :key="r.article_id"
           class="flex justify-between gap-2 py-2.5 text-sm"
         >
-          <span class="truncate text-highlighted">{{ r.pokemon_name || r.title }}</span>
+          <span class="truncate text-highlighted">{{ r.title }}</span>
           <span class="shrink-0 font-semibold text-primary">{{ eur.format(r.profit_eur) }}</span>
         </li>
       </ul>
@@ -53,8 +65,8 @@ const eur = new Intl.NumberFormat('fr-FR', {
           :key="r.article_id"
           class="flex justify-between gap-2 py-2.5 text-sm"
         >
-          <span class="truncate">{{ r.pokemon_name || r.title }}</span>
-          <span class="shrink-0 tabular-nums text-muted">{{ r.hours_to_sell }} h</span>
+          <span class="truncate">{{ r.title }}</span>
+          <span class="shrink-0 tabular-nums text-muted">{{ formatTimeToSell(r.hours_to_sell) }}</span>
         </li>
       </ul>
       <p v-else class="text-sm text-muted py-6 text-center">