diff --git a/backend/routes/__init__.py b/backend/routes/__init__.py index 8605384..e979c7e 100644 --- a/backend/routes/__init__.py +++ b/backend/routes/__init__.py @@ -5,6 +5,7 @@ from routes.campaigns import router as campaigns_router from routes.challenges import router as challenges_router from routes.debrief import router as debrief_router +from routes.demo import router as demo_router from routes.freetext import router as freetext_router from routes.glossary import router as glossary_router from routes.imports import router as imports_router @@ -48,6 +49,7 @@ "webhooks_router", "scenario_builder_router", "debrief_router", + "demo_router", # v3 platform services "personas_router", "risk_profile_router", diff --git a/backend/routes/demo.py b/backend/routes/demo.py new file mode 100644 index 0000000..84d6ddd --- /dev/null +++ b/backend/routes/demo.py @@ -0,0 +1,28 @@ +from fastapi import APIRouter, Depends + +from models.schemas import User +from services import audit, demo +from services.auth import require_admin + +router = APIRouter(prefix="/demo", tags=["demo"]) + + +@router.get("") +async def demo_status(user: User = Depends(require_admin)): + return await demo.status() + + +@router.post("") +async def load_demo(user: User = Depends(require_admin)): + """Load (or reload) the fictional demo organization. Admin only.""" + result = await demo.seed(user.id, user.organization_id or f"org-{user.id}") + await audit.record(user.id, "demo.load", None, {"people": result["people"]}) + return result + + +@router.delete("") +async def clear_demo(user: User = Depends(require_admin)): + """Remove all demo records; real data is never touched.""" + result = await demo.clear() + await audit.record(user.id, "demo.clear", None, result) + return result diff --git a/backend/server.py b/backend/server.py index 3b3c0ee..67079b7 100644 --- a/backend/server.py +++ b/backend/server.py @@ -21,6 +21,7 @@ campaigns_router, challenges_router, debrief_router, + demo_router, freetext_router, glossary_router, imports_router, @@ -489,6 +490,7 @@ async def health_check(): api_router.include_router(attack_surface_router) api_router.include_router(report_inbox_router) api_router.include_router(readiness_router) +api_router.include_router(demo_router) app.include_router(api_router) diff --git a/backend/services/demo.py b/backend/services/demo.py new file mode 100644 index 0000000..4e6ecd7 --- /dev/null +++ b/backend/services/demo.py @@ -0,0 +1,349 @@ +""" +Demo data — one complete, believable loop for a booth, a judge or a first look. + +Seeds a fictional organization on the sandbox domain `demo.test` whose story +shows what Pretexta is for: report rate climbs across three campaigns, the +people who clicked are automatically given practice for the principle that +caught them, most pass, and most pass the retest. Lab results and risk +profiles fill in the rest of the Readiness screen. + +Everything written here carries `demo: True` (or `seeded: True` on map nodes, +tracked in `demo_state`) so `clear()` removes exactly the demo and nothing a +real user created. Seeding is deterministic: the same numbers every time. +""" + +import random +import secrets +import uuid +from datetime import UTC, datetime, timedelta + +from models.schemas import LiveCampaign, User +from services import attack_surface +from services.auth import hash_password +from services.database import db + +DEMO_ORG = "org-demo" +DEMO_DOMAIN = "demo.test" +PRINCIPLES = ("reciprocity", "scarcity", "authority", "commitment", "liking", "social_proof") + +PEOPLE = [ + ("andi", "Andi Pratama"), + ("sari", "Sari Wulandari"), + ("budi", "Budi Santoso"), + ("dewi", "Dewi Lestari"), + ("rizky", "Rizky Hidayat"), + ("maya", "Maya Anggraini"), + ("fajar", "Fajar Nugroho"), + ("intan", "Intan Permata"), + ("yoga", "Yoga Saputra"), + ("nadia", "Nadia Rahma"), + ("hendra", "Hendra Wijaya"), + ("putri", "Putri Ayu"), +] + +# Three campaigns, oldest first. Indexes refer to PEOPLE. The arc: report rate +# 25% -> 50% -> 75%, click rate 42% -> 25% -> 8%, and reports arrive faster. +CAMPAIGNS = [ + { + "days_ago": 75, + "name": "Baseline — mailbox quota", + "principles": ["authority", "scarcity"], + "sender": ("IT Helpdesk", "helpdesk"), + "subject": "Mailbox almost full — verify within 24 hours", + "clicked": [0, 1, 2, 3, 4], + "reported": [8, 9, 10], + "report_minutes": [95, 180, 240], + }, + { + "days_ago": 45, + "name": "Payroll update", + "principles": ["authority", "commitment"], + "sender": ("Payroll", "payroll"), + "subject": "Action needed: confirm your payroll details", + "clicked": [0, 1, 5], + "reported": [2, 3, 4, 8, 9, 10], + "report_minutes": [25, 40, 60, 75, 110, 150], + }, + { + "days_ago": 15, + "name": "Executive request", + "principles": ["authority", "liking"], + "sender": ("Office of the Director", "director"), + "subject": "Quick favour — are you at your desk?", + "clicked": [6], + "reported": [0, 1, 2, 3, 4, 5, 8, 9, 10], + "report_minutes": [6, 9, 12, 15, 18, 22, 30, 41, 55], + }, +] + +# Which remediations and retests have been passed by now (by campaign index). +REMEDIATION_PASSED = {0: True, 1: True, 2: False} +RETEST_PASSED_FROM = {0: True, 1: False} # campaign-0 clickers already passed the retest + + +def _iso(dt: datetime) -> str: + return dt.isoformat() + + +async def _pick_content(principle: str) -> tuple[str, str, str]: + """A real exercise for the principle, so the assignment opens something.""" + doc = await db.challenges.find_one( + {"cialdini_categories": principle}, {"_id": 0, "id": 1, "title": 1} + ) + if doc: + return "challenge", doc["id"], doc["title"] + return "challenge", "demo", principle.replace("_", " ").title() + + +async def seed(admin_id: str, map_workspace: str) -> dict: + """Replace any previous demo data with a fresh copy of the story.""" + await clear() + rng = random.Random(42) # noqa: S311 — deterministic demo numbers, not security + now = datetime.now(UTC) + + users = [] + for key, name in PEOPLE: + user = User( + username=f"demo-{key}", + # Demo people never log in; their password is random and discarded. + password_hash=hash_password(secrets.token_urlsafe(24)), + email=f"{key}@{DEMO_DOMAIN}", + display_name=name, + role="user", + organization_id=DEMO_ORG, + ) + doc = user.model_dump() + doc["created_at"] = _iso(now - timedelta(days=90)) + doc["demo"] = True + await db.users.insert_one(doc) + users.append(doc) + + await db.verified_domains.insert_one( + { + "id": str(uuid.uuid4()), + "organization_id": DEMO_ORG, + "domain": DEMO_DOMAIN, + "token": secrets.token_urlsafe(12), + "sandbox": True, + "verified_at": _iso(now - timedelta(days=90)), + "created_by": admin_id, + "created_at": _iso(now - timedelta(days=90)), + "demo": True, + } + ) + + assignments = 0 + for ci, spec in enumerate(CAMPAIGNS): + launched = now - timedelta(days=spec["days_ago"]) + campaign = LiveCampaign( + name=spec["name"], + objective="click_link", + principles=spec["principles"], + sender_name=spec["sender"][0], + sender_email=f"{spec['sender'][1]}@{DEMO_DOMAIN}", + subject=spec["subject"], + body_html='
Please confirm here: verify
', + recipients=[u["email"] for u in users], + starts_at=launched, + ends_at=launched + timedelta(days=5), + max_turns=0, + organization_id=DEMO_ORG, + created_by=admin_id, + approved_by=admin_id, + status="closed", + ) + doc = campaign.model_dump() + doc.update( + { + "starts_at": _iso(launched), + "ends_at": _iso(launched + timedelta(days=5)), + "created_at": _iso(launched - timedelta(days=2)), + "launched_at": _iso(launched), + "recipient_count": len(users), + "demo": True, + } + ) + await db.live_campaigns.insert_one(doc) + + for i, u in enumerate(users): + state = "clicked" if i in spec["clicked"] else rng.choice(["sent", "opened"]) + await db.live_recipients.insert_one( + { + "campaign_id": campaign.id, + "email": u["email"], + "state": state, + "reported": i in spec["reported"], + "updated_at": _iso(launched + timedelta(hours=6)), + "demo": True, + } + ) + for i, minutes in zip(spec["reported"], spec["report_minutes"], strict=True): + await db.live_events.insert_one( + { + "campaign_id": campaign.id, + "organization_id": DEMO_ORG, + "email": users[i]["email"], + "type": "reported", + # BSON date, like the real events (TTL index, G14). + "at": launched + timedelta(minutes=minutes), + "demo": True, + } + ) + + # The remediation loop for everyone who clicked. + principle = spec["principles"][0] + content_type, content_id, title = await _pick_content(principle) + for i in spec["clicked"]: + remediation_id = str(uuid.uuid4()) + assigned = launched + timedelta(days=1) + passed = REMEDIATION_PASSED[ci] + await db.assignments.insert_one( + _assignment( + remediation_id, + users[i]["id"], + "remediation", + principle, + content_type, + content_id, + title, + assigned, + passed, + reason=f"Clicked the link in the live simulation '{spec['name']}'.", + ) + ) + assignments += 1 + if passed: + await db.assignments.insert_one( + _assignment( + str(uuid.uuid4()), + users[i]["id"], + "retest", + principle, + content_type, + content_id, + title, + assigned + timedelta(days=14), + RETEST_PASSED_FROM[ci], + reason="Scheduled retest — a different exercise to confirm the lesson stuck.", + retest_of=remediation_id, + ) + ) + assignments += 1 + + # Lab results and risk profiles: authority is the cohort's weak spot. + for u in users: + for run in range(2): + d_prime = round(rng.uniform(0.9, 1.6) + run * rng.uniform(0.3, 0.9), 2) + score = min(100, round(55 + d_prime * 15 + rng.uniform(-5, 5))) + completed = now - timedelta(days=60 - run * 40 - rng.randint(0, 5)) + await db.simulations.insert_one( + { + "id": str(uuid.uuid4()), + "user_id": u["id"], + "simulation_type": "triage", + "status": "completed", + "score": score, + "title": "Inbox Senin Pagi", + "events": [{"event_type": "triage_graded", "payload": {"d_prime": d_prime}}], + "started_at": _iso(completed - timedelta(minutes=4)), + "completed_at": _iso(completed), + "demo": True, + } + ) + vector = {p: float(rng.randint(62, 86)) for p in PRINCIPLES} + vector["authority"] = float(rng.randint(34, 58)) + await db.risk_profiles.insert_one( + { + "id": str(uuid.uuid4()), + "user_id": u["id"], + "current_vector": vector, + "baseline_vector": {p: 50.0 for p in PRINCIPLES}, + "demo": True, + } + ) + + # Attack Surface Map: the demo org, plus the admin's own workspace if it is + # empty (that is the map the admin's Readiness screen reads). + map_orgs = [DEMO_ORG] + if map_workspace != DEMO_ORG and not await db.org_nodes.find_one({"org_id": map_workspace}): + map_orgs.append(map_workspace) + for org in map_orgs: + await attack_surface.seed_demo_org(org) + await db.demo_state.update_one( + {"id": "demo"}, + {"$set": {"id": "demo", "map_orgs": map_orgs, "seeded_at": _iso(now)}}, + upsert=True, + ) + + return { + "people": len(users), + "campaigns": len(CAMPAIGNS), + "assignments": assignments, + "map_orgs": map_orgs, + } + + +def _assignment( + aid, + trainee_id, + source, + principle, + content_type, + content_id, + title, + created, + passed, + *, + reason, + retest_of=None, +): + return { + "id": aid, + "instructor_id": "system", + "trainee_id": trainee_id, + "content_type": content_type, + "content_id": content_id, + "title": f"{'Retest' if source == 'retest' else 'Remediation'}: {title}", + "instructions": reason, + "reason": reason, + "principle": principle, + "source": source, + "retest_of": retest_of, + "status": "completed" if passed else "active", + "passing_score": 70.0, + "max_attempts": 3, + "due_date": _iso(created + timedelta(days=7)), + "created_at": _iso(created), + "demo": True, + } + + +async def status() -> dict: + state = await db.demo_state.find_one({"id": "demo"}, {"_id": 0}) + return { + "loaded": bool(await db.users.find_one({"demo": True}, {"_id": 1})), + "seeded_at": (state or {}).get("seeded_at"), + } + + +async def clear() -> dict: + """Remove every demo record, and the map nodes the demo seeded.""" + removed = 0 + for name in ( + "users", + "verified_domains", + "live_campaigns", + "live_recipients", + "live_events", + "assignments", + "simulations", + "risk_profiles", + ): + removed += (await db[name].delete_many({"demo": True})).deleted_count + + state = await db.demo_state.find_one({"id": "demo"}, {"_id": 0}) or {} + for org in state.get("map_orgs", []): + removed += (await db.org_nodes.delete_many({"org_id": org, "seeded": True})).deleted_count + removed += (await db.trust_edges.delete_many({"org_id": org, "seeded": True})).deleted_count + await db.demo_state.delete_one({"id": "demo"}) + return {"removed": removed} diff --git a/backend/services/readiness.py b/backend/services/readiness.py index 1717e29..a4433e6 100644 --- a/backend/services/readiness.py +++ b/backend/services/readiness.py @@ -55,6 +55,7 @@ async def _live(scope: dict) -> dict[str, Any]: clicked += m["clicked"] rates = [t["report_rate"] for t in trend if t["report_rate"] is not None] + latest = trend[-1] if trend else {} return { "campaigns": len(campaigns), "recipients": recipients, @@ -64,6 +65,9 @@ async def _live(scope: dict) -> dict[str, Any]: "click_rate": round(clicked / recipients, 3) if recipients else None, # Change between the first and the latest campaign in the window. "report_rate_delta": round(rates[-1] - rates[0], 3) if len(rates) >= 2 else None, + # Current state = the most recent campaign; the aggregate above is context. + "latest_report_rate": latest.get("report_rate"), + "latest_click_rate": latest.get("click_rate"), "trend": trend, } @@ -129,9 +133,11 @@ async def count(extra: dict) -> int: def _index(live: dict, principles: dict, lab: dict) -> dict[str, Any]: known = [v for v in principles.values() if v is not None] + # The index describes readiness now, so live behaviour comes from the latest campaign. + report, click = live["latest_report_rate"], live["latest_click_rate"] components = { - "report_rate": None if live["report_rate"] is None else live["report_rate"] * 100, - "no_click": None if live["click_rate"] is None else (1 - live["click_rate"]) * 100, + "report_rate": None if report is None else report * 100, + "no_click": None if click is None else (1 - click) * 100, "principles": mean(known) if known else None, "triage": lab["avg_triage_score"], } diff --git a/backend/tests/test_demo.py b/backend/tests/test_demo.py new file mode 100644 index 0000000..1ddeb54 --- /dev/null +++ b/backend/tests/test_demo.py @@ -0,0 +1,69 @@ +"""Demo data: tells the loop story, is admin-only, and clears without touching real data.""" + +from services.database import db +from tests.conftest import make_user + + +async def test_admin_only(api): + _, h = await make_user("trainer") + assert (await api.post("/api/demo", headers=h)).status_code == 403 + assert (await api.delete("/api/demo", headers=h)).status_code == 403 + + +async def test_demo_tells_the_loop_story(api): + _, h = await make_user("admin") + assert (await api.post("/api/demo", headers=h)).status_code == 200 + + body = (await api.get("/api/readiness", headers=h)).json() + trend = [round(c["report_rate"], 2) for c in body["live"]["trend"]] + assert trend == [0.25, 0.5, 0.75] + assert body["live"]["clicked"] == 9 + loop = body["loop"] + assert loop["remediation_assigned"] == 9 and loop["remediation_passed"] == 8 + assert loop["retest_passed"] == 5 + assert body["weakest_principles"][0] == "authority" + assert body["lab"]["triage_runs"] == 24 + assert body["attack_surface"] is not None + assert body["index"]["score"] is not None + + # Reports arrive faster as the loop works. + medians = [c["median_time_to_report_min"] for c in body["live"]["trend"]] + assert medians[0] > medians[1] > medians[2] + + +async def test_reload_is_idempotent(api): + _, h = await make_user("admin") + await api.post("/api/demo", headers=h) + await api.post("/api/demo", headers=h) + assert await db.users.count_documents({"demo": True}) == 12 + assert await db.live_campaigns.count_documents({"demo": True}) == 3 + + +async def test_clear_leaves_real_data(api): + admin, h = await make_user("admin") + real, _ = await make_user("user") + await db.org_nodes.insert_one({"id": "mine", "org_id": "org-real", "name": "Real node"}) + + await api.post("/api/demo", headers=h) + status = (await api.get("/api/demo", headers=h)).json() + assert status["loaded"] is True + + await api.delete("/api/demo", headers=h) + assert (await api.get("/api/demo", headers=h)).json()["loaded"] is False + for name in ("users", "live_campaigns", "live_recipients", "assignments", "simulations"): + assert await db[name].count_documents({"demo": True}) == 0, name + assert await db.users.find_one({"id": real.id}) + assert await db.users.find_one({"id": admin.id}) + assert await db.org_nodes.find_one({"id": "mine"}) + # The map the demo seeded into the admin's empty workspace is gone too. + assert not await db.org_nodes.find_one({"org_id": f"org-{admin.id}"}) + + +async def test_existing_map_is_not_overwritten(api): + admin, h = await make_user("admin") + workspace = f"org-{admin.id}" + await db.org_nodes.insert_one({"id": "kept", "org_id": workspace, "name": "Admin's own map"}) + result = (await api.post("/api/demo", headers=h)).json() + assert workspace not in result["map_orgs"] + await api.delete("/api/demo", headers=h) + assert await db.org_nodes.find_one({"id": "kept"}) diff --git a/backend/tests/test_readiness.py b/backend/tests/test_readiness.py index 7ba7b8c..59407ce 100644 --- a/backend/tests/test_readiness.py +++ b/backend/tests/test_readiness.py @@ -88,15 +88,17 @@ async def test_index_and_loop(api): live = body["live"] assert live["report_rate"] == 0.5 and live["click_rate"] == 0.25 assert live["report_rate_delta"] == 0.5 + assert (live["latest_report_rate"], live["latest_click_rate"]) == (0.75, 0.25) assert [t["name"] for t in live["trend"]] == ["c1", "c2"] assert body["weakest_principles"][0] == "authority" assert body["lab"] == {"triage_runs": 1, "avg_triage_score": 90.0, "avg_d_prime": 2.0} comps = body["index"]["components"] - assert comps == {"report_rate": 50, "no_click": 75, "principles": 70, "triage": 90} - # 0.4*50 + 0.2*75 + 0.2*70 + 0.2*90 = 67 - assert body["index"]["score"] == 67 + # Live components come from the latest campaign (75% reported, 25% clicked). + assert comps == {"report_rate": 75, "no_click": 75, "principles": 70, "triage": 90} + # 0.4*75 + 0.2*75 + 0.2*70 + 0.2*90 = 77 + assert body["index"]["score"] == 77 loop = body["loop"] assert (loop["remediation_assigned"], loop["remediation_passed"]) == (2, 1) diff --git a/frontend/src/i18n/locales/en.json b/frontend/src/i18n/locales/en.json index f07d96b..52a907e 100644 --- a/frontend/src/i18n/locales/en.json +++ b/frontend/src/i18n/locales/en.json @@ -297,7 +297,20 @@ "provider_selection": "Choose your LLM provider (OpenAI, Gemini, Claude, etc.) and enter a valid API key.", "revoke_key_bold": "Revoke Key", "webhooks": "Webhooks", - "notifications": "Notifications" + "notifications": "Notifications", + "demo": { + "title": "Demo data", + "desc": "Load a fictional organization (12 people on demo.test, three campaigns, the remediation loop, lab results and an attack-surface map) to show the full story. Everything is tagged as demo and can be removed without touching real data.", + "status_loaded": "Loaded {{date}}", + "status_empty": "Not loaded", + "load": "Load demo data", + "reload": "Reload demo data", + "clear": "Remove demo data", + "confirm_clear": "Remove all demo data? Real users and campaigns are not affected.", + "loaded": "Demo loaded: {{people}} people, {{campaigns}} campaigns", + "cleared": "Demo data removed", + "failed": "Failed" + } }, "simulation": { "security_score": "Security Awareness Score", @@ -683,7 +696,7 @@ }, "no_data": "no data", "report_title": "Report rate — the behaviour we train for", - "reported_of": "{{reported}}/{{total}} reported · last {{campaigns}} campaigns", + "reported_of": "overall {{rate}} ({{reported}}/{{total}}) over {{campaigns}} campaigns", "points_since_first": "pts since the first campaign", "click_rate": "Click rate", "series": { @@ -721,6 +734,7 @@ "retest_open": "Retest scheduled for {{principle}}", "retest_done": "Retest on {{principle}} passed" }, - "cohort_note": "Cohort of {{people}} trainees. Weights: report rate 40%, did not click 20%, principle resistance 20%, Inbox Triage 20%; missing parts are left out." + "cohort_note": "Cohort of {{people}} trainees. Weights: report rate 40%, did not click 20%, principle resistance 20%, Inbox Triage 20%; missing parts are left out.", + "latest_campaign": "latest campaign" } } diff --git a/frontend/src/i18n/locales/id.json b/frontend/src/i18n/locales/id.json index 31102a8..74019ee 100644 --- a/frontend/src/i18n/locales/id.json +++ b/frontend/src/i18n/locales/id.json @@ -297,7 +297,20 @@ "provider_selection": "Pilih penyedia LLM Anda (OpenAI, Gemini, Claude, dll.) dan masukkan kunci API yang valid.", "revoke_key_bold": "Cabut Kunci", "webhooks": "Webhook", - "notifications": "Notifikasi" + "notifications": "Notifikasi", + "demo": { + "title": "Data demo", + "desc": "Muat organisasi fiktif (12 orang di demo.test, tiga kampanye, siklus remediasi, hasil lab, dan peta serangan) untuk menunjukkan cerita lengkapnya. Semua ditandai sebagai demo dan bisa dihapus tanpa menyentuh data asli.", + "status_loaded": "Dimuat {{date}}", + "status_empty": "Belum dimuat", + "load": "Muat data demo", + "reload": "Muat ulang data demo", + "clear": "Hapus data demo", + "confirm_clear": "Hapus semua data demo? Pengguna dan kampanye asli tidak terpengaruh.", + "loaded": "Demo dimuat: {{people}} orang, {{campaigns}} kampanye", + "cleared": "Data demo dihapus", + "failed": "Gagal" + } }, "simulation": { "security_score": "Skor Kesadaran Keamanan", @@ -683,7 +696,7 @@ }, "no_data": "belum ada data", "report_title": "Report rate — perilaku yang kita latih", - "reported_of": "{{reported}}/{{total}} melapor · {{campaigns}} kampanye terakhir", + "reported_of": "rata-rata {{rate}} ({{reported}}/{{total}}) dari {{campaigns}} kampanye", "points_since_first": "poin sejak kampanye pertama", "click_rate": "Click rate", "series": { @@ -721,6 +734,7 @@ "retest_open": "Tes ulang {{principle}} dijadwalkan", "retest_done": "Tes ulang {{principle}} lulus" }, - "cohort_note": "Kohort {{people}} peserta. Bobot: report rate 40%, tidak mengklik 20%, resistansi prinsip 20%, Triase Inbox 20%; komponen tanpa data tidak dihitung." + "cohort_note": "Kohort {{people}} peserta. Bobot: report rate 40%, tidak mengklik 20%, resistansi prinsip 20%, Triase Inbox 20%; komponen tanpa data tidak dihitung.", + "latest_campaign": "kampanye terbaru" } } diff --git a/frontend/src/pages/ReadinessPage.js b/frontend/src/pages/ReadinessPage.js index 9e1743b..574d2fd 100644 --- a/frontend/src/pages/ReadinessPage.js +++ b/frontend/src/pages/ReadinessPage.js @@ -105,10 +105,15 @@ function ReportCard({ live, t }) {{t('settings.demo.desc')}
++ {state?.loaded + ? t('settings.demo.status_loaded', { date: new Date(state.seeded_at).toLocaleString() }) + : t('settings.demo.status_empty')} +
+