Price items from the bot's canonical item_prices registry (smart-w ADR 0018)

The bot now keeps ONE authoritative selling price per item in
users/{mobile}/item_prices (base price + on-sale price/discount while a promo
runs). Reading prices from stock batches is what caused the July field-report
mismatch (dashboard-side USD2.56 vs the bot's updated USD4.00) — batches are
unordered copies and can be stale or depleted.

- fetch_user_ledger also reads item_prices; aggregate_ledger takes it.
- build_price_view: registry first; newest ACTIVE batch price_each only as a
legacy fallback (mirrors the bot's _lookup_item_price order).
- New payload fields: per-item "pricing" (price/basePrice/onSale/discountPct/
onHand) and "stockRetailValue" (on-hand at today's bot prices). stockValue
stays cost-based, matching the bot's accounting.
- Admin stats aggregate a global stockRetailValue.

Existing frontend fields are unchanged; the new ones are additive.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

analytics.py

@@ -109,6 +109,66 @@ def _truthy(v: Any) -> bool:
     return str(v).strip().lower() in ("true", "1", "yes", "y", "service")
 
 
+# ── Selling prices (canonical registry, smart-w ADR 0018) ────────────────────
+def _sorted_batches(stock_batches: List[Dict]) -> List[Dict]:
+    """Newest-first, active before depleted — mirrors the bot's read order so a
+    stale price on an old empty batch never wins."""
+    return sorted(
+        stock_batches or [],
+        key=lambda b: (money(b.get("quantity_remaining")) > 0, str(b.get("stocked_at") or "")),
+        reverse=True,
+    )
+
+
+def build_price_view(item_prices: List[Dict], stock_batches: List[Dict]) -> Dict[str, Dict]:
+    """item name → current selling-price record.
+
+    The bot keeps ONE authoritative selling price per item in
+    users/{mobile}/item_prices (smart-w ADR 0018): base price, plus sale_price /
+    discount_pct while a promotion runs. The registry wins; the newest ACTIVE
+    stock batch's price_each is only a legacy fallback for items priced before
+    the registry existed. This must stay in lockstep with the bot's
+    _lookup_item_price, or the dashboard shows a different price than the bot
+    charges (the July-2026 USD2.56-vs-USD4.00 mismatch).
+    """
+    view: Dict[str, Dict] = {}
+    for e in item_prices or []:
+        nm = str(e.get("name") or "").strip().lower()
+        if not nm:
+            continue
+        base = money_opt(e.get("price"))
+        sale = money_opt(e.get("sale_price")) if e.get("on_sale") else None
+        current = sale if (sale is not None and sale > 0) else base
+        if current is None or current <= 0:
+            continue
+        view[nm] = {
+            "price": round(current, 2),
+            "basePrice": round(base, 2) if (base is not None and base > 0) else None,
+            "onSale": bool(e.get("on_sale")),
+            "discountPct": e.get("discount_pct"),
+            "source": "registry",
+        }
+    for b in _sorted_batches(stock_batches):
+        nm = str(b.get("name") or "").strip().lower()
+        if not nm or nm in view:
+            continue
+        p = None
+        if b.get("on_sale"):
+            p = money_opt(b.get("sale_price_each"))
+        if p is None or p <= 0:
+            p = money_opt(b.get("price_each"))
+        if p is None or p <= 0:
+            continue
+        view[nm] = {
+            "price": round(p, 2),
+            "basePrice": round(p, 2),
+            "onSale": bool(b.get("on_sale")),
+            "discountPct": b.get("discount_pct"),
+            "source": "batch",
+        }
+    return view
+
+
 # ── Cost basis (COGS) ────────────────────────────────────────────────────────
 def build_cost_map(stock_batches: List[Dict]) -> Dict[str, float]:
     """item name → mean known unit cost (cost_each) from stock batches."""
@@ -126,7 +186,8 @@ def build_cost_map(stock_batches: List[Dict]) -> Dict[str, float]:
 # ── Main ledger aggregation ──────────────────────────────────────────────────
 def aggregate_ledger(txns: List[Dict], stock_batches: List[Dict], customers: List[Dict],
                      start: Optional[datetime] = None, end: Optional[datetime] = None,
-                     default_currency: str = "USD") -> Dict[str, Any]:
+                     default_currency: str = "USD",
+                     item_prices: Optional[List[Dict]] = None) -> Dict[str, Any]:
     """Return per-currency financials + insight lists. Mirrors the bot's report math.
 
     Standing figures (cash on hand, receivables, payables, stock value) are CURRENT — the
@@ -224,6 +285,26 @@ def aggregate_ledger(txns: List[Dict], stock_batches: List[Dict], customers: Lis
     payables = round(sum(money(c.get("payable", c.get("outstanding_change"))) for c in (customers or [])), 2)
     stock_value = round(sum(money(b.get("quantity_remaining")) * money(b.get("cost_each")) for b in (stock_batches or [])), 2)
 
+    # Current selling prices (canonical registry first — smart-w ADR 0018) and the
+    # stock's value AT those prices. stockValue stays cost-based (accounting);
+    # stockRetailValue is what the shelf would fetch at today's bot prices.
+    price_view = build_price_view(item_prices, stock_batches)
+    on_hand: Dict[str, float] = defaultdict(float)
+    for b in stock_batches or []:
+        nm = str(b.get("name") or "").strip().lower()
+        if nm:
+            on_hand[nm] += money(b.get("quantity_remaining"))
+    stock_retail_value = round(sum(
+        qty * price_view[nm]["price"] for nm, qty in on_hand.items()
+        if qty > 0 and nm in price_view), 2)
+    pricing = sorted(
+        ({"item": nm,
+          "onHand": round(on_hand.get(nm, 0.0), 2),
+          "price": v["price"], "basePrice": v.get("basePrice"),
+          "onSale": v.get("onSale", False), "discountPct": v.get("discountPct")}
+         for nm, v in price_view.items()),
+        key=lambda x: -(x["onHand"] * x["price"]))[:20]
+
     # leaderboards / lists
     top_items = sorted(
         ({"item": nm, "quantity": round(item_qty.get(nm, 0.0), 2),
@@ -254,6 +335,8 @@ def aggregate_ledger(txns: List[Dict], stock_batches: List[Dict], customers: Lis
         "receivables": receivables,
         "payables": payables,
         "stockValue": stock_value,
+        "stockRetailValue": stock_retail_value,
+        "pricing": pricing,
         "topItems": top_items,
         "topCustomers": top_customers,
         "topExpenses": top_expenses,

main.py

@@ -109,12 +109,16 @@ def parse_date_range(req):
 
 
 def fetch_user_ledger(bot_data_id):
-    """Read a bot user's v2 ledger: (transactions, stock_batches, customers) as dicts."""
+    """Read a bot user's v2 ledger: (transactions, stock_batches, customers,
+    item_prices) as dicts. item_prices is the bot's canonical selling-price
+    registry (smart-w ADR 0018) — the dashboard must price items from it, not
+    from batch copies, or it disagrees with what the bot charges."""
     ref = db.collection('users').document(bot_data_id)
     txns = [d.to_dict() for d in ref.collection('transactions').stream()]
     batches = [d.to_dict() for d in ref.collection('stock_batches').stream()]
     customers = [d.to_dict() for d in ref.collection('customers').stream()]
-    return txns, batches, customers
+    item_prices = [d.to_dict() for d in ref.collection('item_prices').stream()]
+    return txns, batches, customers, item_prices
 
 # -----------------------------------------------------------------------------
 # 3. AUTHENTICATION & USER MANAGEMENT ENDPOINTS
@@ -272,9 +276,10 @@ def get_user_dashboard():
         default_currency = user_data.get('defaultCurrency', 'USD')
         bot_data_id = phone_number.lstrip('+')
 
-        txns, batches, customers = fetch_user_ledger(bot_data_id)
+        txns, batches, customers, item_prices = fetch_user_ledger(bot_data_id)
         agg = analytics.aggregate_ledger(txns, batches, customers, start_date, end_date,
-                                         default_currency=default_currency)
+                                         default_currency=default_currency,
+                                         item_prices=item_prices)
 
         # Legacy-compatible per-currency maps (so existing UI keeps working during the switch)
         by_cur = agg['byCurrency']
@@ -294,6 +299,8 @@ def get_user_dashboard():
             'receivables': agg['receivables'],
             'payables': agg['payables'],
             'stockValue': agg['stockValue'],
+            'stockRetailValue': agg['stockRetailValue'],
+            'pricing': agg['pricing'],
             'topItems': agg['topItems'],
             'topCustomers': agg['topCustomers'],
             'dailySeries': agg['dailySeries'],
@@ -863,16 +870,17 @@ def get_admin_dashboard_stats():
         item_rev = _dd(lambda: _dd(float))       # item -> cur -> revenue
         exp_cat = _dd(lambda: _dd(float))         # category -> cur -> amount
         user_rev = _dd(lambda: _dd(float))        # phone -> cur -> revenue
-        g_cash = g_recv = g_pay = g_stock = 0.0
+        g_cash = g_recv = g_pay = g_stock = g_stock_retail = 0.0
 
         for phone in phone_to_user:
             try:
-                txns, batches, customers = fetch_user_ledger(phone.lstrip('+'))
+                txns, batches, customers, item_prices = fetch_user_ledger(phone.lstrip('+'))
             except Exception as e:
                 logging.error(f"Admin stats: ledger read failed for {phone}: {e}")
                 continue
             agg = analytics.aggregate_ledger(txns, batches, customers, start_date, end_date,
-                                             default_currency=phone_to_user[phone]['defaultCurrency'])
+                                             default_currency=phone_to_user[phone]['defaultCurrency'],
+                                             item_prices=item_prices)
             for cur, m in agg['byCurrency'].items():
                 gcur[cur]['sales'] += m['sales']; gcur[cur]['cogs'] += m['cogs']
                 gcur[cur]['expenses'] += m['expenses']; gcur[cur]['salesCount'] += m['salesCount']
@@ -885,6 +893,7 @@ def get_admin_dashboard_stats():
                     exp_cat[ex['category']][cur] += v
             g_cash += agg['cashOnHand']; g_recv += agg['receivables']
             g_pay += agg['payables']; g_stock += agg['stockValue']
+            g_stock_retail += agg.get('stockRetailValue', 0.0)
 
         all_currencies = set(gcur)
         system_by_cur, total_count = {}, 0
@@ -922,7 +931,8 @@ def get_admin_dashboard_stats():
                 'totalNetProfitByCurrency': {c: v['netProfit'] for c, v in system_by_cur.items()},
                 'totalSalesCount': total_count,
                 'cashOnHand': round(g_cash, 2), 'receivables': round(g_recv, 2),
-                'payables': round(g_pay, 2), 'stockValue': round(g_stock, 2)},
+                'payables': round(g_pay, 2), 'stockValue': round(g_stock, 2),
+                'stockRetailValue': round(g_stock_retail, 2)},
             'leaderboards': leaderboards,
         }), 200