Sync from GitHub · 2026-10-22 20:43 UTC

routes/admin.py

@@ -10,6 +10,8 @@ Routes:
   DELETE /api/admin/users/{uid}   → delete user account + Firestore data
   GET  /api/admin/stats           → platform overview stats
   GET  /api/admin/audit           → audit trail of manual admin actions
+  GET  /api/admin/niche-requests  → niches people couldn't find, most requested first
+  PUT  /api/admin/niche-requests/{id} → mark one added / dismissed / open
 """
 
 from fastapi import APIRouter, HTTPException, Depends
@@ -18,6 +20,8 @@ from firebase_admin import auth as fb_auth, firestore
 from auth import verify_firebase_token
 from routes.account import delete_all_user_data
 from utils.supabase_client import get_supabase
+from utils import niche_requests
+from utils.audit import log_action
 
 router = APIRouter()
 
@@ -140,3 +144,26 @@ def platform_stats(user: dict = Depends(verify_firebase_token)):
         "totalUsers":   user_count,
         "note": "Deep counts require Cloud Functions — this shows top-level totals only."
     }
+
+
+class NicheStatusRequest(BaseModel):
+    status: str  # open | added | dismissed
+
+
+@router.get("/niche-requests")
+def list_niche_requests(status: str | None = None, user: dict = Depends(verify_firebase_token)):
+    _verify_admin(user)
+    return {"requests": niche_requests.list_requests(status)}
+
+
+@router.put("/niche-requests/{key}")
+def update_niche_request(key: str, body: NicheStatusRequest, user: dict = Depends(verify_firebase_token)):
+    admin_uid = _verify_admin(user)
+    try:
+        text = niche_requests.set_status(key, body.status)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Niche request not found.")
+    log_action(admin_uid, "niche", body.status, text, target=key)
+    return {"success": True}

routes/bff.py

@@ -1,11 +1,12 @@
 import json
 from fastapi import APIRouter, HTTPException, Depends
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from firebase_admin import firestore
 from auth import verify_firebase_token
 from utils.rate_limiter import with_rate_limit
 from utils.groq_client import call_groq_json, HEAVY_MODEL
 from utils.pinecone_client import query_book_context
+from utils import niche_requests
 
 router = APIRouter()
 
@@ -28,6 +29,12 @@ class ReopenFollowupsRequest(BaseModel):
     businessId: str
 
 
+class NicheRequestIn(BaseModel):
+    text: str = Field(min_length=2, max_length=80)
+    sectorId: str = Field(default="", max_length=60)
+    subsectorId: str = Field(default="", max_length=60)
+
+
 # ─── Helpers ──────────────────────────────────────────────────────────────────
 
 def _db():
@@ -216,7 +223,9 @@ def generate_profile(
 
     # ── Retrieve relevant passages from "Built on Rock" via Pinecone ─────────
     sector = bff.get("section1", {}).get("sectorId", "")
-    niche  = bff.get("section1", {}).get("nicheId", "")
+    s1     = bff.get("section1", {})
+    # nicheId "other" means the person described their own niche in customNiche.
+    niche  = s1.get("customNiche") if s1.get("nicheId") == "other" else s1.get("nicheId", "")
     book_ctx = query_book_context(
         f"Business Footing Framework WHAT WHY HOW {sector} {niche} Nigerian entrepreneur",
         top_k=3,
@@ -464,3 +473,15 @@ def reopen_followups(
     if missing:
         biz_ref.update({"bffCompleted": False, "profileStale": True})
     return {"missing": missing}
+
+
+# ─── Route: Niche not in our list ────────────────────────────────────────────
+
+@router.post("/niche-request")
+def niche_request(body: NicheRequestIn, user: dict = Depends(verify_firebase_token)):
+    """Records a niche the person couldn't find, for admins to review and add."""
+    try:
+        niche_requests.record(user["uid"], body.text, body.sectorId, body.subsectorId)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return {"success": True}

routes/chat.py

@@ -6,6 +6,7 @@ from firebase_admin import firestore
 from utils.rate_limiter import with_rate_limit
 from utils.groq_client import call_groq_stream, LIGHT_MODEL, HEAVY_MODEL
 from utils.pinecone_client import query_book_context
+from utils import business_type
 
 router = APIRouter()
 
@@ -63,10 +64,12 @@ def _get_business_context(user_id: str, business_id: str) -> str:
 
     if s1.exists:
         d = s1.to_dict()
+        t = business_type.describe(d)
         ctx_parts.append(
             f"Business: {d.get('businessName', 'Unknown')}, "
-            f"Sector: {d.get('sector', '')}, "
-            f"Niche: {d.get('niche', '')}"
+            f"Sector: {t['sector']}, "
+            f"Type of business: {t['subsector']}, "
+            f"Niche: {t['niche']}"
         )
 
     if identity.exists:

routes/documents.py

@@ -20,6 +20,7 @@ from firebase_admin import firestore
 from utils.rate_limiter import with_rate_limit
 from utils.groq_client import call_groq_json, HEAVY_MODEL
 from utils.pinecone_client import query_book_context
+from utils import business_type
 
 router = APIRouter()
 
@@ -159,11 +160,8 @@ def generate_document_content(
         raise HTTPException(status_code=404, detail="Business profile not found.")
 
     # ── BFF Philosophy context from Pinecone ──────────────────────────────────
-    query = (
-        f"business plan entrepreneurship Nigeria "
-        f"{ctx.get('businessIdentity', {}).get('sector', '')} "
-        f"{ctx.get('section1', {}).get('niche', '')}"
-    )
+    t = business_type.describe(ctx.get("section1", {}))
+    query = f"business plan entrepreneurship Nigeria {t['subsector']} {t['niche']}"
     book_context = query_book_context(query, top_k=3)
 
     # ── Generate ──────────────────────────────────────────────────────────────

sql/admin_audit_schema.sql

@@ -10,10 +10,16 @@ create table if not exists admin_audit_log (
   id         uuid primary key default gen_random_uuid(),
   at         timestamptz not null default now(),
   actor      text not null,   -- admin's Firebase UID
-  kind       text not null check (kind in ('review', 'source', 'run')),
+  kind       text not null check (kind in ('review', 'source', 'run', 'niche')),
   action     text not null,   -- e.g. 'published', 'discarded', 'enabled', 'disabled', 'started'
   target     text,            -- the item/source/poll id this action was on
   summary    text not null    -- short human-readable description, e.g. the item title
 );
 
 create index if not exists admin_audit_log_at_idx on admin_audit_log (at desc);
+
+-- 2026-10-22: niche requests (marking a missing niche added/dismissed) are
+-- audited too. For a table created before this date, run:
+alter table admin_audit_log drop constraint if exists admin_audit_log_kind_check;
+alter table admin_audit_log add constraint admin_audit_log_kind_check
+  check (kind in ('review', 'source', 'run', 'niche'));

tests/test_business_type.py

@@ -0,0 +1,15 @@
+from utils.business_type import describe
+
+
+def test_ids_become_readable_labels():
+    t = describe({"sectorId": "food_agriculture", "subsectorId": "catering_food_service", "nicheId": "outdoor_catering"})
+    assert t == {"sector": "Food agriculture", "subsector": "Catering & Food Service", "niche": "Outdoor catering"}
+
+
+def test_other_niche_uses_the_persons_own_words():
+    t = describe({"sectorId": "trade_commerce", "subsectorId": "retail_trade", "nicheId": "other", "customNiche": " drone repair "})
+    assert t["niche"] == "drone repair"
+
+
+def test_missing_fields_are_empty():
+    assert describe({}) == {"sector": "", "subsector": "", "niche": ""}

tests/test_niche_requests.py

@@ -0,0 +1,78 @@
+"""
+Unit tests for utils/niche_requests.py and the /niche-request route: the list of
+niches people couldn't find. Firestore is mocked.
+"""
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi import HTTPException
+
+from utils import niche_requests
+from routes.bff import NicheRequestIn, niche_request
+
+
+def test_key_ignores_case_spacing_and_punctuation():
+    assert niche_requests.niche_key("  School  Stationery! ") == "school-stationery"
+    assert niche_requests.niche_key("school stationery") == "school-stationery"
+    assert niche_requests.niche_key("!!!") == ""
+
+
+def test_route_rejects_text_without_letters():
+    with pytest.raises(HTTPException) as e:
+        niche_request(NicheRequestIn(text="!!!"), user={"uid": "u1"})
+    assert e.value.status_code == 400
+
+
+def test_list_hides_who_asked_and_sorts_by_count():
+    def doc(id_, **d):
+        m = MagicMock(id=id_)
+        m.to_dict.return_value = d
+        return m
+    db = MagicMock()
+    db.collection.return_value.stream.return_value = [
+        doc("a", text="A", userCount=1, uids=["u1"], status="open"),
+        doc("b", text="B", userCount=3, uids=["u1", "u2", "u3"], status="open"),
+        doc("c", text="C", userCount=9, uids=["x"], status="added"),
+    ]
+    with patch.object(niche_requests.firestore, "client", return_value=db):
+        rows = niche_requests.list_requests("open")
+    assert [r["text"] for r in rows] == ["B", "A"]
+    assert all("uids" not in r for r in rows)
+
+
+def test_set_status_validates():
+    with pytest.raises(ValueError):
+        niche_requests.set_status("x", "deleted")
+
+
+def _fake_firestore(existing: dict | None):
+    fs = MagicMock()
+    fs.transactional = lambda f: f          # run the body directly with our fake transaction
+    snap = MagicMock(exists=existing is not None)
+    snap.to_dict.return_value = existing or {}
+    ref = fs.client.return_value.collection.return_value.document.return_value
+    ref.get.return_value = snap
+    tx = fs.client.return_value.transaction.return_value
+    return fs, ref, tx
+
+
+def test_record_counts_each_person_once_and_keeps_where_they_put_it():
+    fs, ref, tx = _fake_firestore({"uids": ["u1"], "sectors": ["trade_commerce/retail_trade"], "status": "added"})
+    with patch.object(niche_requests, "firestore", fs):
+        key = niche_requests.record("u1", "School  stationery", "trade_commerce", "retail_trade")
+    assert key == "school-stationery"
+    saved = tx.set.call_args[0][1]
+    assert saved["userCount"] == 1 and saved["uids"] == ["u1"]
+    assert saved["sectors"] == ["trade_commerce/retail_trade"]
+    assert saved["status"] == "added"                 # an admin decision isn't reset by a new request
+    assert saved["text"] == "School stationery"
+    assert "firstAt" not in saved
+
+
+def test_record_new_niche_starts_open_with_one_person():
+    fs, ref, tx = _fake_firestore(None)
+    with patch.object(niche_requests, "firestore", fs):
+        niche_requests.record("u2", "Shoe repair")
+    saved = tx.set.call_args[0][1]
+    assert saved["userCount"] == 1 and saved["status"] == "open" and "firstAt" in saved
+    assert saved["sectors"] == []

utils/business_type.py

@@ -0,0 +1,31 @@
+"""
+Readable sector / type of business / niche from a BFF section1 doc.
+
+section1 stores only ids (sectorId, subsectorId, nicheId), plus customNiche when
+nicheId is "other". Sub-sector labels come from the exported subsectors.json;
+sector and niche ids are snake_case, so they read fine once humanised.
+"""
+
+from news.business_types import SUBSECTORS
+
+OTHER_NICHE_ID = "other"
+_SUBSECTOR_LABELS = {s["id"]: s["label"] for s in SUBSECTORS}
+
+
+def _humanise(id_: str) -> str:
+    return id_.replace("_", " ").strip().capitalize()
+
+
+def describe(s1: dict) -> dict:
+    """{'sector': ..., 'subsector': ..., 'niche': ...}, '' for anything not set."""
+    sub_id = s1.get("subsectorId", "")
+    niche_id = s1.get("nicheId", "")
+    if niche_id == OTHER_NICHE_ID:
+        niche = (s1.get("customNiche") or "").strip()
+    else:
+        niche = _humanise(niche_id)
+    return {
+        "sector": _humanise(s1.get("sectorId", "")),
+        "subsector": _SUBSECTOR_LABELS.get(sub_id, _humanise(sub_id)),
+        "niche": niche,
+    }

utils/niche_requests.py

@@ -0,0 +1,86 @@
+"""
+Niches people couldn't find in data/sectors.ts and described in their own words.
+
+One Firestore doc per distinct niche (keyed by its normalised text), so repeat
+requests add up instead of piling up as duplicates. Admins read the list in the
+console to decide which niches to add. firestore.rules' default deny keeps the
+collection backend-only.
+"""
+
+import re
+
+from firebase_admin import firestore
+
+COLLECTION = "niche_requests"
+STATUSES = {"open", "added", "dismissed"}
+MAX_USERS_TRACKED = 1000  # beyond this the count stops rising; plenty to rank by
+
+
+def niche_key(text: str) -> str:
+    """'School  Stationery!' and 'school stationery' are the same request."""
+    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")[:100]
+
+
+def record(uid: str, text: str, sector_id: str = "", subsector_id: str = "") -> str:
+    key = niche_key(text)
+    if not key:
+        raise ValueError("Niche text has no letters or numbers.")
+    db = firestore.client()
+    ref = db.collection(COLLECTION).document(key)
+
+    @firestore.transactional
+    def _upsert(tx):
+        snap = ref.get(transaction=tx)
+        d = snap.to_dict() if snap.exists else {}
+        uids = list(d.get("uids", []))
+        if uid not in uids and len(uids) < MAX_USERS_TRACKED:
+            uids.append(uid)
+        sectors = list(d.get("sectors", []))
+        where = "/".join(p for p in (sector_id, subsector_id) if p)
+        if where and where not in sectors:
+            sectors.append(where)
+        update = {
+            "text": " ".join(text.split()),
+            "uids": uids,
+            "userCount": len(uids),
+            "sectors": sectors[-20:],
+            "status": d.get("status", "open"),
+            "lastAt": firestore.SERVER_TIMESTAMP,
+        }
+        if not snap.exists:
+            update["firstAt"] = firestore.SERVER_TIMESTAMP
+        tx.set(ref, update, merge=True)
+
+    _upsert(db.transaction())
+    return key
+
+
+def list_requests(status: str | None = None) -> list[dict]:
+    """Most-requested first. Never returns who asked, only how many."""
+    out = []
+    for doc in firestore.client().collection(COLLECTION).stream():
+        d = doc.to_dict()
+        if status and d.get("status", "open") != status:
+            continue
+        out.append({
+            "id": doc.id,
+            "text": d.get("text", ""),
+            "userCount": d.get("userCount", 0),
+            "sectors": d.get("sectors", []),
+            "status": d.get("status", "open"),
+            "firstAt": str(d.get("firstAt", "")),
+            "lastAt": str(d.get("lastAt", "")),
+        })
+    return sorted(out, key=lambda r: (-r["userCount"], r["text"]))
+
+
+def set_status(key: str, status: str) -> str:
+    """Returns the niche text, for the audit trail."""
+    if status not in STATUSES:
+        raise ValueError(f"status must be one of {sorted(STATUSES)}")
+    ref = firestore.client().collection(COLLECTION).document(key)
+    snap = ref.get()
+    if not snap.exists:
+        raise KeyError(key)
+    ref.update({"status": status})
+    return snap.to_dict().get("text", key)