Separazione: le aree riservate diventano un'app propria (apps/platforms)
Campus, Stress Index e Longevity escono dal sito e diventano apps.insanitylab.it, con utenti, sessioni, login e database propri. Deciso da Adriano il 03/09/2026: una repo sola, due applicazioni autosufficienti, cosi' che ognuna resti estraibile. Misura che ha guidato il taglio: le tre aree condividevano col sito SOLO l'identita' - ~170 righe fra auth.ts, middleware.ts e safe-next.ts. Layout, librerie e dati erano gia' disgiunti. Lato piattaforme: - ruoli piattaforme/cliente/trainer/admin, senza quelli redazionali - canAccessPath con default CHIUSO (nel sito era aperto: li' le rotte non elencate erano di chiunque fosse loggato, qui ogni sezione e' di qualcuno) - tutta l'app protetta, si elencano le eccezioni invece dei prefissi protetti - /api risponde 401/403, non un redirect verso una pagina di login - tre database distinti: utenti, dati clinici senza nomi, mappatura coi nomi Lato sito: - ROLES tornano i tre redazionali; via le regole e il login pubblico - il login del pannello RESPINGE un account emigrato invece di aprirgli una sessione: senza, landingFor lo mandava su /admin, il middleware glielo negava, e si formava un ciclo di redirect che sembra un guasto del sito - l'header non mostra piu' un menu delle piattaforme: un link che esce Verificato: sito 20 file / 146 test, piattaforme 26 file / 197 test, entrambi i build passano, e l'app girata davvero in locale - il ruolo piattaforme entra in Campus e viene rimbalzato da Longevity, il cliente il contrario. Non ancora in produzione: manca il record DNS di apps.insanitylab.it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EndnceRA5WnA6rvA5iV9WL
This commit is contained in:
AdrianoDev
@@ -0,0 +1,250 @@
|
||||
//
|
||||
// La vista che il questionario in pagina usa. Due responsabilità:
|
||||
// - campiDelQuestionario: i campi del modulo, letti dal registro (mai una lista nel
|
||||
// codice) — aggiungere o disattivare una domanda resta una modifica ai dati.
|
||||
// - salvaDalForm: il salvataggio, con la sola regola che conta davvero — il consenso al
|
||||
// trattamento dei dati sanitari va DATO, non solo compilato. Il prototipo del cliente
|
||||
// salvava anche con "No" perché controllava solo che il campo non fosse vuoto: qui il
|
||||
// consenso si verifica PRIMA di scrivere qualsiasi altra cosa, e un rifiuto non apre
|
||||
// nessuna sessione. Il rifiuto stesso si registra comunque: è un fatto (chi, quando, a
|
||||
// cosa) che un domani va dimostrato tanto quanto un assenso.
|
||||
import type Database from 'better-sqlite3';
|
||||
import { testAttivi, pesiDi, MODEL_VERSION } from './registro';
|
||||
import { salvaCompilazione, CONSENT_VERSION } from './questionario';
|
||||
import { leggiScore, calcolaSessione, salvaScore } from './motore';
|
||||
|
||||
export type CampoQuestionario = {
|
||||
id: string;
|
||||
etichetta: string;
|
||||
tipo: 'num' | 'txt';
|
||||
unita?: string;
|
||||
min?: number;
|
||||
max?: number;
|
||||
sottoDominio?: string;
|
||||
};
|
||||
|
||||
/** I campi del modulo alla data indicata: solo i test_id del questionario (prefisso
|
||||
* `q_`, per non confonderli con quelli dei test fisici), attivi a quella data. */
|
||||
export function campiDelQuestionario(db: Database.Database, alla: string): CampoQuestionario[] {
|
||||
return testAttivi(db, alla)
|
||||
.filter((v) => v.test_id.startsWith('q_'))
|
||||
.map((v) => ({
|
||||
id: v.test_id,
|
||||
etichetta: v.etichetta,
|
||||
tipo: v.tipo_valore,
|
||||
unita: v.unita,
|
||||
min: v.range_min,
|
||||
max: v.range_max,
|
||||
sottoDominio: v.sotto_dominio,
|
||||
}));
|
||||
}
|
||||
|
||||
export type EsitoSalvataggio =
|
||||
| { ok: true; sessioneId: number }
|
||||
| { ok: false; errore: string };
|
||||
|
||||
const CONSENSI_AFFERMATIVI = new Set(['si', 'sì']);
|
||||
|
||||
function consensoDato(risposta: string): boolean {
|
||||
return CONSENSI_AFFERMATIVI.has(risposta.trim().toLowerCase());
|
||||
}
|
||||
|
||||
/** Registra il fatto del consenso — chi, quando, a che versione del TESTO del consenso
|
||||
* (CONSENT_VERSION, non QUEST_VERSION: il consenso può cambiare formulazione senza che
|
||||
* cambi una domanda) — indipendentemente dall'esito. Legata al cliente sempre; alla
|
||||
* sessione solo quando il consenso è affermativo e la sessione esiste davvero. */
|
||||
function registraConsenso(
|
||||
db: Database.Database, clientCode: string, sessioneId: number | null, risposta: string
|
||||
): void {
|
||||
const esito = risposta.trim() === '' ? '(non risposto)' : risposta.trim();
|
||||
const oggi = new Date().toISOString().slice(0, 10);
|
||||
const testo = `Consenso al trattamento dei dati sanitari: ${esito} — consenso ${CONSENT_VERSION}, registrato il ${oggi}`;
|
||||
db.prepare(
|
||||
`INSERT INTO profilo_note (client_code, sessione_id, campo_id, testo) VALUES (?, ?, ?, ?)`
|
||||
).run(clientCode, sessioneId, 'consenso_sanitario', testo);
|
||||
}
|
||||
|
||||
/**
|
||||
* Il salvataggio dal form del questionario. Il consenso si controlla PRIMA di scrivere
|
||||
* qualunque altra cosa: se non è affermativo, non si apre nessuna sessione — né misure né
|
||||
* note di profilo — e la compilazione non entra nel fascicolo. La nota del consenso si
|
||||
* scrive comunque, con l'esito letterale ricevuto.
|
||||
*
|
||||
* Quando il consenso è affermativo, TUTTO il resto avviene in un'unica transazione (il
|
||||
* salvataggio dei dati sanitari, il calcolo dei punteggi e il congelamento in `score`, la
|
||||
* nota di consenso): o entra tutto nel fascicolo, o non entra niente. Prima di questa
|
||||
* correzione il calcolo restava scollegato dal salvataggio — nessuno chiamava
|
||||
* calcolaSessione/salvaScore in produzione — e la nota di consenso si scriveva fuori dalla
|
||||
* transazione, quindi un fallimento lì poteva lasciare dati sanitari senza il consenso che
|
||||
* li giustifica. `db.transaction` di better-sqlite3 annida automaticamente con savepoint
|
||||
* quelle interne di `salvaCompilazione` e `salvaScore`.
|
||||
*/
|
||||
export function salvaDalForm(
|
||||
db: Database.Database,
|
||||
input: {
|
||||
client_code: string; data: string; eta?: number;
|
||||
risposte: Record<string, number>;
|
||||
consensoSanitario: string;
|
||||
liberi?: Record<string, string>;
|
||||
}
|
||||
): EsitoSalvataggio {
|
||||
if (!consensoDato(input.consensoSanitario)) {
|
||||
registraConsenso(db, input.client_code, null, input.consensoSanitario);
|
||||
return {
|
||||
ok: false,
|
||||
errore: 'Senza consenso al trattamento dei dati sanitari la compilazione non viene salvata.',
|
||||
};
|
||||
}
|
||||
|
||||
const tx = db.transaction(() => {
|
||||
const sessioneId = salvaCompilazione(db, {
|
||||
client_code: input.client_code,
|
||||
data: input.data,
|
||||
eta: input.eta,
|
||||
risposte: input.risposte,
|
||||
liberi: input.liberi,
|
||||
});
|
||||
|
||||
// Il calcolo e il congelamento dei punteggi sono parte del salvataggio, non un passo
|
||||
// successivo affidato a chi legge: senza questo, una compilazione restava per sempre
|
||||
// senza i suoi punteggi.
|
||||
salvaScore(db, sessioneId, calcolaSessione(db, sessioneId));
|
||||
|
||||
registraConsenso(db, input.client_code, sessioneId, input.consensoSanitario);
|
||||
|
||||
return sessioneId;
|
||||
});
|
||||
|
||||
return { ok: true, sessioneId: tx() };
|
||||
}
|
||||
|
||||
//
|
||||
// Il referto che il cliente legge: il radar a sette assi e le carte dei macro-score.
|
||||
// Due regole non negoziabili, entrambe già chiuse a monte, non da questo modulo:
|
||||
// - il valore viene da `leggiScore` (punteggi congelati in `score`), mai da un
|
||||
// ricalcolo — cambiare i pesi non deve mai cambiare un referto già emesso;
|
||||
// - un asse/macro insufficiente non porta un `valore` (resta `null`): è il tipo
|
||||
// `Punteggio` del motore che lo rende impossibile da violare per distrazione.
|
||||
//
|
||||
|
||||
/** Un asse del radar: il valore (assente se il dato non basta), la copertura di peso
|
||||
* disponibile e — solo quando manca — l'elenco leggibile di cosa lo completerebbe. */
|
||||
export type AsseVista = { nome: string; valore: number | null; copertura: number; mancano: string[] };
|
||||
|
||||
/** Una carta di macro-score: stesso principio degli assi, senza l'elenco di cosa manca
|
||||
* (il "cosa manca" si legge scendendo ai sette assi, non qui). */
|
||||
export type MacroVista = { nome: string; valore: number | null; copertura: number };
|
||||
|
||||
/**
|
||||
* Le etichette leggibili dei sotto-domini che alimentano un asse: le chiavi sono quelle
|
||||
* di `PESI_ASSE` in registro.ts. Non tutte hanno oggi una riga in `registro_test` — i
|
||||
* test fisici (handgrip, VO2max, plank...) arrivano con un piano successivo, il
|
||||
* questionario è l'unica fonte di misure che esiste davvero — quindi la traduzione non
|
||||
* può venire da lì: è dato locale a questo modulo, non duplica il registro, lo completa
|
||||
* dove il registro non arriva ancora.
|
||||
*/
|
||||
const ETICHETTE_SOTTO_DOMINIO: Record<string, string> = {
|
||||
handgrip: 'Forza di presa (handgrip)',
|
||||
spinta: 'Test di spinta (push-up o panca)',
|
||||
trazione: 'Test di trazione',
|
||||
arti_inferiori: 'Test arti inferiori',
|
||||
core: 'Test del core (plank)',
|
||||
grasso: 'Composizione corporea — massa grassa',
|
||||
muscolo: 'Composizione corporea — massa muscolare',
|
||||
whr: 'Rapporto vita-fianchi (WHR)',
|
||||
vo2max: 'Test cardio (VO2max)',
|
||||
spirometria: 'Spirometria',
|
||||
wellness_tower_cardio: 'Wellness Tower — cardio',
|
||||
hrv: 'Variabilità della frequenza cardiaca (HRV)',
|
||||
pressione: 'Pressione arteriosa',
|
||||
hrr: 'Frequenza cardiaca di recupero (HRR)',
|
||||
questionario_sonno: 'Questionario del sonno',
|
||||
questionario_energia_stress: 'Questionario energia e stress',
|
||||
flamingo: 'Test di equilibrio (flamingo)',
|
||||
sit_and_reach: 'Test di flessibilità (sit and reach)',
|
||||
plank: 'Plank (tenuta)',
|
||||
back_scratch: 'Test di mobilità delle spalle (back scratch)',
|
||||
wellness_tower_shoulder: 'Wellness Tower — spalla',
|
||||
questionario_lifestyle: 'Questionario di stile di vita',
|
||||
};
|
||||
|
||||
/** I contenitori (assi o macro-score) dichiarati nei pesi per il model version corrente,
|
||||
* nell'ordine in cui compaiono nella tabella — che è l'ordine di inserimento di `seedPesi`,
|
||||
* cioè quello dichiarato in registro.ts. Non un elenco duplicato qui: si legge dal dato. */
|
||||
function contenitoriDi(db: Database.Database, livello: 'asse' | 'macro'): string[] {
|
||||
return (db.prepare(
|
||||
`SELECT contenitore FROM pesi WHERE model_version = ? AND livello = ?
|
||||
GROUP BY contenitore ORDER BY MIN(rowid)`
|
||||
).all(MODEL_VERSION, livello) as { contenitore: string }[]).map((r) => r.contenitore);
|
||||
}
|
||||
|
||||
/** I sotto-domini con almeno una misura valida (nel range atteso) in questa sessione:
|
||||
* l'informazione grezza da cui `mancano` si costruisce, non un punteggio — leggere quali
|
||||
* test sono stati fatti non è ricalcolare come pesano. */
|
||||
function sottoDominiPresenti(db: Database.Database, sessioneId: number): Set<string> {
|
||||
const righe = db.prepare(
|
||||
`SELECT DISTINCT rt.sotto_dominio AS sd
|
||||
FROM misure m JOIN registro_test rt ON rt.test_id = m.test_id
|
||||
WHERE m.sessione_id = ? AND m.fuori_range = 0 AND m.valore_num IS NOT NULL
|
||||
AND rt.sotto_dominio IS NOT NULL`
|
||||
).all(sessioneId) as { sd: string }[];
|
||||
return new Set(righe.map((r) => r.sd));
|
||||
}
|
||||
|
||||
/** Cosa manca per completare un asse insufficiente: i sotto-domini pesati per quell'asse
|
||||
* che questa sessione non ha, tradotti nell'etichetta leggibile. */
|
||||
function mancanoPer(db: Database.Database, sessioneId: number, nomeAsse: string, presenti: Set<string>): string[] {
|
||||
const pesi = pesiDi(db, MODEL_VERSION, 'asse', nomeAsse);
|
||||
return Object.keys(pesi)
|
||||
.filter((sd) => !presenti.has(sd))
|
||||
.map((sd) => ETICHETTE_SOTTO_DOMINIO[sd] ?? sd);
|
||||
}
|
||||
|
||||
/**
|
||||
* Il referto di una sessione: i sette assi del radar, i macro-score e la Fitness Age.
|
||||
* Legge SOLO `leggiScore` per i valori (punteggi congelati): non chiama mai
|
||||
* `calcolaSessione`, quindi un peso cambiato dopo il fatto non altera un referto già
|
||||
* emesso. `mancano` guarda invece le misure grezze della sessione (quali test ci sono),
|
||||
* non il punteggio — è informazione su cosa manca, non un ricalcolo di quanto vale.
|
||||
*/
|
||||
export function refertoDi(
|
||||
db: Database.Database,
|
||||
sessioneId: number
|
||||
): { assi: AsseVista[]; macro: MacroVista[]; fitnessAge: number | null; fitnessAgeCopertura: number } {
|
||||
const punteggi = leggiScore(db, sessioneId);
|
||||
const presenti = sottoDominiPresenti(db, sessioneId);
|
||||
|
||||
const assi: AsseVista[] = contenitoriDi(db, 'asse').map((nome) => {
|
||||
const p = punteggi.assi[nome];
|
||||
if (p?.stato === 'ok') return { nome, valore: p.valore, copertura: p.copertura, mancano: [] };
|
||||
return {
|
||||
nome, valore: null, copertura: p?.copertura ?? 0,
|
||||
mancano: mancanoPer(db, sessioneId, nome, presenti),
|
||||
};
|
||||
});
|
||||
|
||||
const macro: MacroVista[] = contenitoriDi(db, 'macro').map((nome) => {
|
||||
const p = punteggi.macro[nome];
|
||||
return p?.stato === 'ok'
|
||||
? { nome, valore: p.valore, copertura: p.copertura }
|
||||
: { nome, valore: null, copertura: p?.copertura ?? 0 };
|
||||
});
|
||||
|
||||
const fitnessAge = punteggi.fitnessAge?.stato === 'ok' ? punteggi.fitnessAge.valore : null;
|
||||
// Prima apertura: con poche misure la Fitness Age manca quasi sempre. La pagina deve
|
||||
// poter dire QUANTO manca (come fa già ogni carta di macro-score), non solo che manca:
|
||||
// la copertura resta leggibile anche quando lo stato è 'insufficiente'.
|
||||
const fitnessAgeCopertura = punteggi.fitnessAge?.copertura ?? 0;
|
||||
|
||||
return { assi, macro, fitnessAge, fitnessAgeCopertura };
|
||||
}
|
||||
|
||||
/** L'ultima sessione di un cliente (la più recente per data, a parità di data la più
|
||||
* recente per id). `null` se il cliente non ha ancora nessuna sessione — la pagina del
|
||||
* referto la usa per non dover interrogare `sessioni` da sola. */
|
||||
export function ultimaSessioneDi(db: Database.Database, clientCode: string): number | null {
|
||||
const r = db.prepare(
|
||||
`SELECT id FROM sessioni WHERE client_code = ? ORDER BY data DESC, id DESC LIMIT 1`
|
||||
).get(clientCode) as { id: number } | undefined;
|
||||
return r?.id ?? null;
|
||||
}
|
||||
Reference in New Issue
Block a user