Files
sales-trainer/backend/app/services/sessions.py
T
Macky 3c22d88bcd feat: demo SaaS + training flow security hardening (8/8 review gate passed)
- Demo accounts: super_admin-only provisioning into isolated DEMO_ORG_ID tenant,
  30-day UTC trial on first login, revocable, one-time credential delivery via
  optional SES/webhook (never persisted). Adds boto3 dependency.
- Analytics/report/export/privacy: shared bounded scan budget across users/groups/
  sessions, tenant-consistent session/user/group joins, scalar-only CSV export
  (no nested persisted-value stringification).
- Ownership/tenant isolation: canonical owner-tenant predicate for list/read/chat;
  client sees is_owned only, never owner_user_id.
- Lifecycle/races: status transition validation, analyzing is an in-progress gate
  (no duplicate reanalysis), structured-ready publication, stale-variant revalidation.
- Auth/setup/consent/JWT/OAuth/config: fail-closed consent, bounded JWT lifetime,
  provider-subject atomic OAuth identity, repeated-secret rejection, strict Persona
  trait validation.
- Chat/session/privacy: pre-seller opener redaction, corrupt-session recovery,
  role-aware completed-chat dashboard routing.
- Frontend: Training→product→personas→practice flow, demo/role/demo guards,
  is_owned-based ownership display, 320×568 and 500×768 responsive E2E.
- 8 independent exact-five-key review scopes passed; backend 509, frontend 26,
  production build 1775 modules, isolated E2E 15.
2026-08-25 06:39:06 +07:00

279 lines
9.1 KiB
Python

"""Training session store.
A session is identified by the full tenant scope ``(org, user, group, persona)``
plus its mode. A trainee session is one-shot; preview sessions are deliberately
outside that invariant so instructors can test a persona without consuming a
trainee attempt. The scope scan and create happen under one collection lock so
two worker threads/processes cannot create competing active sessions.
"""
from __future__ import annotations
import datetime
from pathlib import Path
from typing import Any
from ..storage.store import JsonStore, new_id
def _now() -> str:
return datetime.datetime.now(datetime.timezone.utc).isoformat()
class SessionStore:
def __init__(self, data_dir: Path) -> None:
self.sessions = JsonStore(data_dir / "sessions")
def create(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
persona_name: str,
persona_meta: dict[str, Any] | None = None,
mode: str = "trainee",
messages: list[dict[str, Any]] | None = None,
internal: dict[str, Any] | None = None,
scenario: str | None = None,
locale: str | None = None,
) -> dict[str, Any]:
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
sid = new_id("session")
session = {
"id": sid,
"org_id": org_id,
"user_id": user_id,
"group_id": group_id,
"persona_id": persona_id,
"persona_name": persona_name,
"persona_meta": persona_meta or {},
"scenario": scenario,
"locale": locale,
"mode": mode,
"status": "active", # active | finished
"outcome": None, # won | lost | abandoned
"messages": list(messages or []), # [{role, text, ts}]
"internal": dict(internal or {"trust": 50, "pain_progress": {}, "buying_signals": [], "tier": None}),
"debrief": None,
"created_at": _now(),
"updated_at": _now(),
}
return self.sessions.create(session, key=sid)
@staticmethod
def _validate_scope(
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
mode: str,
) -> None:
if not all(isinstance(value, str) and value.strip() for value in (
org_id, user_id, group_id, persona_id,
)):
raise ValueError("session scope is invalid")
if mode not in ("trainee", "preview"):
raise ValueError("session mode is invalid")
@staticmethod
def _mode(row: dict[str, Any]) -> str:
# Records created before the explicit mode field are normal trainee attempts.
mode = row.get("mode")
if mode is None:
return "trainee"
return mode if isinstance(mode, str) else ""
def _raw_scope_rows(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
) -> list[dict[str, Any]]:
return self.sessions.where(
lambda row: isinstance(row, dict)
and row.get("org_id") == org_id
and row.get("user_id") == user_id
and row.get("group_id") == group_id
and row.get("persona_id") == persona_id
)
def _scope_rows(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
mode: str,
) -> list[dict[str, Any]]:
return [
row
for row in self._raw_scope_rows(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
)
if isinstance(row, dict) and self._mode(row) == mode
]
def start(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
persona_name: str,
persona_meta: dict[str, Any] | None = None,
mode: str = "trainee",
messages: list[dict[str, Any]] | None = None,
internal: dict[str, Any] | None = None,
scenario: str | None = None,
locale: str | None = None,
) -> tuple[dict[str, Any], bool]:
"""Atomically resume or create a session in one canonical scope.
Returns ``(session, resumed)``. Only trainee sessions enforce the
one-shot finished-session rule; preview sessions can be started again.
"""
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
with self.sessions.collection_lock():
raw_rows = [
row
for row in self._raw_scope_rows(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
)
if isinstance(row, dict)
]
for row in raw_rows:
row_mode = self._mode(row)
status = row.get("status")
outcome = row.get("outcome")
if (
row_mode not in ("trainee", "preview")
or status not in ("active", "finished")
or outcome not in (None, "won", "lost", "abandoned")
or (status == "active" and outcome is not None)
or (status == "finished" and outcome not in ("won", "lost", "abandoned"))
):
raise ValueError("invalid persisted session state")
rows = self._scope_rows(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
mode=mode,
)
active = next((row for row in rows if row.get("status") == "active"), None)
if active is not None:
return active, True
if mode == "trainee" and any(
row.get("status") == "finished"
or row.get("outcome") in ("won", "lost", "abandoned")
for row in rows
):
raise ValueError("you have already trained on this persona (one-shot)")
return self.create(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
persona_name=persona_name,
persona_meta=persona_meta,
mode=mode,
messages=messages,
internal=internal,
scenario=scenario,
locale=locale,
), False
def get(self, sid: str) -> dict[str, Any]:
return self.sessions.get(sid)
def get_or_none(self, sid: str) -> dict[str, Any] | None:
return self.sessions.get_or_none(sid)
def update(self, sid: str, **fields: Any) -> dict[str, Any]:
fields.setdefault("updated_at", _now())
return self.sessions.update(sid, **fields)
def mutation_lock(self, sid: str):
"""Serialize a full session transaction across threads and workers."""
return self.sessions.record_lock(sid)
def active_for_scope(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
mode: str = "trainee",
) -> dict[str, Any] | None:
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
hits = [
row for row in self._scope_rows(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
mode=mode,
)
if isinstance(row, dict) and row.get("status") == "active"
]
return hits[0] if hits else None
def latest_for_scope(
self,
*,
org_id: str,
user_id: str,
group_id: str,
persona_id: str,
mode: str = "trainee",
) -> dict[str, Any] | None:
"""Return the newest record in one scope, including finished sessions."""
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
rows = [
row
for row in self._scope_rows(
org_id=org_id,
user_id=user_id,
group_id=group_id,
persona_id=persona_id,
mode=mode,
)
if isinstance(row, dict)
]
return max(rows, key=lambda row: row.get("updated_at", ""), default=None)
def list_for_user(
self,
user_id: str,
*,
org_id: str | None = None,
include_preview: bool = False,
) -> list[dict[str, Any]]:
rows = [
row
for row in self.sessions.where(
lambda row: isinstance(row, dict)
and row.get("user_id") == user_id
and (org_id is None or row.get("org_id") == org_id)
and (include_preview or self._mode(row) == "trainee")
)
if isinstance(row, dict)
]
return sorted(
rows,
key=lambda r: r.get("created_at", ""),
)