Files
plm-lottery/docs/sito-e-app.md
T

264 lines
26 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Sito, web app e console operativa
Prefisso: `WEB`. Origine: [../TODO.md](../TODO.md). Scelte: [ADR-54](adr/ADR-54-django-unico-framework-web-tre-aree.md)
(framework e aree), [ADR-56](adr/ADR-56-staff-account-individuali-permessi-mfa-dopo-pilota.md)
(staff), [ADR-57](adr/ADR-57-due-pause-distinte-dopo-round-e-incidente.md) (pause),
[ADR-60](adr/ADR-60-pilota-solo-italiano.md) (lingua).
I requisiti sono `*Stato:* da implementare` salvo dove indicato diversamente; la
sequenza è in [../roadmap.md](../roadmap.md). Il vecchio sito è `index.html` con
backend FastAPI (vedi [architettura.md](architettura.md)).
## 1 · Struttura
- **[WEB-01]** Un solo dominio e un solo progetto Django servono tre aree:
pubblica, giocatore e staff, con uno stile condiviso:
| Percorso | Accesso | Funzione |
|---|---|---|
| `/` | pubblico | stato del round, quota, montepremi confermato, chiusura, «Partecipa» |
| `/guida/`, `/regole/` | pubblico | funzionamento, custodia, conferme, commissioni, vincita, prelievo |
| `/risultati/`, `/risultati/<round_id>/` | pubblico | archivio estrazioni, esito, prova, stato del pagamento |
| `/accedi/`, `/registrati/` | pubblico | accesso e registrazione, con ritorno alla destinazione interna |
| `/app/` | giocatore | round corrente, disponibilità, propria partecipazione |
| `/app/portafoglio/` | giocatore | saldo spendibile, fondi in conferma, indirizzo con QR, prelievo |
| `/app/movimenti/` | giocatore | storico di depositi, puntate, vincite, prelievi |
| `/app/profilo/` | giocatore | impostazioni, password, segnalazioni, logout |
| `/ops/` | staff | supervisione e azioni operative autorizzate |
| `/admin/` | staff con permessi sui modelli | utenti e segnalazioni; record di gioco in sola lettura |
*Stato:* scheletro (A1): progetto Django, `/` segnaposto, `/admin/` ·
*Codice:* `config/urls.py`, `apps/web/urls.py` · *Test:* `tests/django/test_scaffold.py::test_home_answers_on_localhost`
- **[WEB-02]** L'autenticazione usa le sessioni Django; ogni scrittura è
protetta da CSRF e il cookie di sessione ha gli attributi `Secure`,
`HttpOnly` e `SameSite`.
*Stato:* implementato (A5): sessione di 24 ore, cookie `Secure`/`HttpOnly`/`SameSite=Lax`, CSRF su ogni modulo con
pagina di errore leggibile ·
*Codice:* `config/settings.py`, `apps/web/views.py:csrf_failure` ·
*Test:* `tests/django/test_accounts.py::test_the_session_cookie_is_httponly_secure_and_samesite`, `test_a_form_without_the_csrf_token_is_refused`
- **[WEB-03]** Ogni richiesta dell'area giocatore legge o modifica soltanto i
dati dell'utente autenticato; **nessuna vista prende un utente dalla richiesta**: un parametro `user` costruito a mano non cambia nulla.
*Stato:* implementato per l'area giocatore (A7) ·
*Test:* `tests/django/test_player.py::test_a_player_never_sees_another_players_data`, `test_user_ids_in_the_request_are_ignored`, `test_every_player_page_needs_a_session`
- **[WEB-04]** Importi e saldi si rappresentano in unità minime intere
([ADR-35](adr/ADR-35-aritmetica-satoshi-interi.md)); i parametri economici e
temporali del round sono fissati alla sua apertura ([ADR-10](adr/ADR-10-parametri-round-fotografati-all-apertura.md)).
*Stato:* colonne e vincoli implementati (A2, [DAT-76]…[DAT-78]); la copia all'apertura con A4 ·
*Test:* `tests/django/test_models.py::test_amounts_are_integers_only`
- **[WEB-05]** I dati che cambiano (stato del round, saldo, esito) si
aggiornano con richieste periodiche mirate e si recuperano al rientro nella
pagina; ricaricare non perde lo stato salvato.
*Stato:* implementato per la home (A6, [WEB-14]) e per l'area giocatore (A7, [WEB-27]).
- **[WEB-06]** Le pagine sono utilizzabili da smartphone e da desktop e
navigabili da tastiera, con stati distinti di errore, attesa e conferma.
*Stato:* base implementata (A5): layout fluido da 400 px, foglio di stile unico con tema chiaro/scuro, collegamento «Vai al
contenuto», focus sempre visibile, etichette su ogni campo, errori annunciati (`role="alert"`), nessuno script né stile
inline, pagine d'errore in italiano; la verifica su telefono e desktop con le schermate finali è l'A10 ·
*Codice:* `apps/web/templates/web/base.html`, `apps/web/static/web/site.css` ·
*Test:* `tests/django/test_accounts.py::test_every_page_is_responsive_and_keyboard_friendly`, `test_every_input_has_its_label`, `test_pages_use_no_inline_scripts_or_styles`
- **[WEB-07]** Il sito si avvia e si naviga in locale su `http://localhost`
(stesso `docker-compose.yml` di sempre, `SITE_ADDRESS` non impostato) con
regtest e ledger simulato, senza dominio né configurazioni esterne. Il
dominio definitivo si aggiunge solo con la configurazione (`SITE_ADDRESS`,
`ALLOWED_HOSTS`, `CSRF_TRUSTED_ORIGINS`), senza modifiche al codice, e i
cookie `Secure` valgono solo dove c'è HTTPS ([WEB-02]).
*Stato:* implementato (A1) ·
*Codice:* `config/settings.py`, `docker-compose.yml`, `Caddyfile` ·
*Test:* `tests/django/test_scaffold.py::test_domain_comes_from_configuration_only`, `test_unknown_host_is_refused`
## 2 · Area pubblica
- **[WEB-10]** `/` mostra quota, montepremi **confermato** e chiusura, con
l'ora del server come riferimento, e uno fra gli stati: nessun round,
puntate aperte, in chiusura, estrazione in corso, pagamento in attesa,
manutenzione.
Gli stati: **nessun round** (fra due round, con l'orario di apertura quando è noto), **puntate aperte** (quota, chiusura e
conto alla rovescia), **in chiusura** (anche oltre la scadenza se lo scheduler è in ritardo, [ADR-23](adr/ADR-23-limite-scommettere-scadenza-round-stesso-suo.md)),
**estrazione in corso**, **pagamento in attesa**, **manutenzione** (nessun round si aprirà, oppure puntate sospese;
[ADR-57](adr/ADR-57-due-pause-distinte-dopo-round-e-incidente.md)). Un round in corso con la «pausa dopo il round» resta «puntate
aperte» e avvisa che poi la lotteria si ferma. Il **montepremi confermato** è la quota del vincitore (70%) di ciò che è già
confermato: mai più di ciò che sarà pagato; le puntate in volo si indicano a parte («+N in conferma»). La quota è quella del round,
non quella corrente della configurazione. La pagina è renderizzata dal server, quindi funziona anche senza JavaScript.
*Stato:* implementato (A6); il collegamento a «dove controllare il risultato» arriva con l'A8 ·
*Codice:* `apps/lottery/status.py:public_state`, `apps/web/views.py:home`, `apps/web/templates/web/home.html` ·
*Test:* `tests/django/test_home.py` (un test per stato, il montepremi confermato, la quota del round)
- **[WEB-11]** «Partecipa» porta a `/app/`; se serve il login, dopo
l'accesso riporta alla schermata di gioco. Il pulsante apre il flusso: la
puntata richiede una conferma esplicita.
*Stato:* implementato (A5, [WEB-52], e A6): «Partecipa» compare solo quando le puntate sono aperte e porta a `/app/` ·
*Test:* `tests/django/test_home.py::test_participate_leads_to_the_player_area`, `test_participate_is_hidden_when_betting_is_not_possible`
- **[WEB-12]** `/risultati/` elenca i round conclusi (dal più recente, a pagine) e `/risultati/<id>/` pubblica esito e prova
dell'estrazione, riproducibile con i dati del protocollo ([RND-14]…[RND-20]), senza username né dati dell'account: i
partecipanti e il vincitore compaiono solo con l'indirizzo pseudonimo della lista pubblica ([DAT-65]). La pagina mostra
l'impegno, la lista ordinata, l'impronta, l'altezza e l'hash del blocco, il segreto rivelato, il seme e la posizione estratta,
con il ricalcolo (impegno, ordine, impronta, vincitore) e i passi per rifarlo da soli; `/risultati/<id>/prova.json` dà gli stessi
dati in JSON. Ciò che non esiste ancora è «non ancora disponibile», mai un valore inventato. Il pagamento risulta confermato solo
quando lo è. Un round che non esiste dà 404.
*Stato:* implementato (A8) ·
*Codice:* `apps/lottery/proof.py:round_proof`, `apps/web/public_views.py` ·
*Test:* `tests/django/test_public.py`
- **[WEB-13]** Guida (`/guida/`) e regole (`/regole/`) usano gli stessi termini dell'area giocatore
(quota, ripartizione 70/30, commissioni, attesa delle conferme) e non
promettono l'accredito immediato. Le cifre (quota, ripartizione, durata) sono lette dalla configurazione, non scritte a mano.
*Stato:* implementato (A8) · *Test:* `tests/django/test_public.py`
- **[WEB-14]** **Aggiornamento della home.** `GET /stato/` restituisce, pubblico e mai in cache, lo stesso stato che la pagina
mostra (una sola funzione li alimenta: non possono raccontare cose diverse), senza dati di account né del segreto del round;
porta l'ora del server. `home.js` (esterno, senza dipendenze) fa scorrere il conto alla rovescia sull'**ora del server**, non su
quella del visitatore; interroga `/stato/` ogni 5 secondi mentre la pagina è visibile, subito quando torna visibile o quando il
conto arriva a zero, e più di rado dopo errori (fino a 30 s), mostrando «Connessione persa». Il testo del conto alla rovescia è lo
stesso con e senza JavaScript.
*Stato:* implementato (A6) ·
*Codice:* `apps/web/views.py:state`, `apps/web/static/web/home.js` ·
*Test:* `tests/django/test_home.py::test_the_endpoint_and_the_page_tell_the_same_story`, `test_the_endpoint_exposes_no_account_data`, `test_the_script_is_valid_and_its_clock_arithmetic_is_right`, `test_the_server_and_the_script_write_the_countdown_the_same_way`
## 3 · Area giocatore
- **[WEB-20]** «Gioca», «Portafoglio» e «Movimenti» sono schermate separate;
nel flusso principale hanno priorità quota, stato del round e puntata dell'utente. Il menu segna la sezione corrente (`aria-current`).
*Stato:* implementato (A7) · *Codice:* `apps/web/player_views.py:play`, `apps/web/templates/web/app_home.html` ·
*Test:* `tests/django/test_player.py::test_the_play_screen_shows_the_round_the_funds_and_the_bet_button`, `test_the_bet_button_is_hidden_without_funds_and_says_why`
- **[WEB-21]** Saldo spendibile e fondi in conferma sono distinti. Il deposito
mostra rete, indirizzo, QR, copia e stato delle conferme.
Il **QR** è sempre quello dell'indirizzo del giocatore (mai un indirizzo preso dalla richiesta); «Copia» è un pulsante che compare solo con
JavaScript, e senza di esso l'indirizzo resta un campo di sola lettura da selezionare. Il saldo mostrato include i fondi in conferma
ma la puntata usa solo il saldo spendibile ([BET-07], [ADR-34](adr/ADR-34-saldo-spendibile-saldo-mostrato-due-numeri.md)). Il prelievo arriva con la Fase B (B9).
*Stato:* implementato (A7; indirizzo simulato fino alla B4) ·
*Codice:* `apps/web/player_views.py:wallet`, `wallet_qr`, `apps/web/static/web/wallet.js` ·
*Test:* `tests/django/test_player.py::test_the_wallet_separates_spendable_funds_from_funds_in_confirmation`, `test_the_wallet_shows_network_address_qr_and_a_copy_control`, `test_the_qr_takes_no_address_from_the_request`
- **[WEB-22]** Prima di inviare una puntata si mostrano round e importo; il
server valida disponibilità, quota, limiti e stato del round. Dopo l'invio
si mostra lo stato effettivo (attesa, conferma, rifiuto o esclusione).
*Stato:* validazione e stati implementati nel ledger (A3: round, scadenza, quota del round, limiti, fondi,
`round_closing`, `already_betting`, `round_full`, `bets_suspended`, `balance_pending_confirmation`, rifiuto ed esclusione);
anche la schermata (A7): la puntata è in due passi — la schermata di conferma mostra round e importo e non invia nulla; l'invio avviene solo
con «Conferma e punta», e il server ricontrolla tutto (una pagina rimasta aperta mentre il round cambiava è rifiutata con un messaggio chiaro).
Dopo l'invio la pagina mostra lo stato reale e un aggiornamento della pagina, anche da un altro browser, lo ritrova ·
*Codice:* `apps/lottery/ledger.py:SimulatedLedger.place_bet`, `apps/web/player_views.py:bet` ·
*Test:* `tests/django/test_ledger.py`, `tests/django/test_player.py::test_the_confirmation_screen_shows_round_amount_and_funds_and_sends_nothing`, `test_a_stale_confirmation_is_refused_by_the_server_with_a_clear_message`, `test_a_page_reload_recovers_the_saved_state`
- **[WEB-23]** Un doppio invio della stessa richiesta produce una sola
operazione logica (chiave di idempotenza associata alla richiesta).
*Stato:* implementato nel ledger (A3, [ARC-76]) e nel modulo di invio (A7): ogni schermata di conferma porta una chiave nuova, e inviarla due volte
è una sola puntata; la stessa conferma aperta in due schede è rifiutata come «hai già una puntata» ·
*Test:* `tests/django/test_ledger.py::test_the_same_bet_request_is_one_bet`, `tests/django/test_player.py::test_sending_the_same_confirmation_twice_makes_one_bet`, `test_the_same_confirmation_opened_in_two_tabs_makes_one_bet`
- **[WEB-24]** Il prelievo mostra, prima della conferma, indirizzo, importo
richiesto, commissione e importo netto previsto. Lo storico distingue lo stato
dell'operazione dal TXID corrente e lo collega all'explorer quando disponibile.
- **[WEB-25]** **Movimenti.** `/app/movimenti/` elenca depositi, puntate, vincite, rimborsi e prelievi del solo giocatore, dal più recente, a pagine di 25,
con data (UTC), operazione, stato (in conferma, confermato, non riuscito), importo con segno e transazione: il TXID abbreviato, collegato all'explorer
se `EXPLORER_TX_URL` è configurato, e marcato «simulata» sul ledger simulato. Da telefono le righe diventano schede, così l'importo non esce mai
dallo schermo; la tabella ha didascalia e intestazioni di colonna.
*Stato:* implementato (A7) ·
*Codice:* `apps/web/player_views.py:movements`, `apps/web/templates/web/movements.html` ·
*Test:* `tests/django/test_player.py::test_the_movements_are_listed_newest_first_with_sign_and_status`, `test_movements_are_paged`, `test_the_txid_links_to_the_explorer_when_one_is_configured`
- **[WEB-26]** **Fondi di prova.** Con il ledger simulato il portafoglio offre un deposito di prova da 10, 50 o 100 PLM che arriva «in conferma» e il worker conferma
pochi secondi dopo ([RND-42]); un importo diverso da quelli offerti non dà nulla, il doppio invio è un solo deposito, e con un ledger reale l'indirizzo non esiste (404)
e il modulo non compare.
*Stato:* implementato (A7) ·
*Codice:* `apps/web/player_views.py:simulated_deposit` ·
*Test:* `tests/django/test_player.py::test_a_test_deposit_arrives_in_confirmation_and_becomes_spendable`, `test_only_the_offered_amounts_are_accepted`, `test_test_deposits_exist_only_on_the_simulated_ledger`
- **[WEB-27]** **Stato del giocatore.** `GET /app/stato/` (solo con sessione, mai in cache) è lo stato pubblico ([WEB-14]) più un blocco `me` con i soli dati del giocatore:
saldo spendibile e in conferma, la sua puntata nel round (stato e testo), se può puntare e perché no, e come è finito il suo ultimo round («hai vinto 21 PLM»,
«non hai vinto»). Una sola funzione (`player_state`) alimenta la pagina e l'endpoint; `home.js` aggiorna lo stato della puntata e i saldi senza ricaricare.
*Stato:* implementato (A7); verificato in un browser reale: dalla conferma «In attesa» a «Confermata» in circa 9 secondi senza ricaricare ·
*Codice:* `apps/lottery/player.py:player_state`, `apps/web/player_views.py:player_state_json`, `apps/web/static/web/home.js` ·
*Test:* `tests/django/test_player.py::test_the_page_and_the_endpoint_tell_the_same_story`, `test_the_player_is_told_how_their_round_ended`
## 4 · Console operativa
- **[WEB-30]** Ogni operatore ha un account staff individuale; `/ops/` e
`/admin/` richiedono i permessi espliciti, verificati nelle viste e nelle azioni.
*Stato:* implementato (A9): quattro permessi `lottery.view_console`, `pause_after_round`, `suspend_new_bets`, `suspend_withdrawals`; un giocatore o uno staff senza permesso riceve 403, un anonimo è rimandato ad `/accedi/` · *Codice:* `apps/ops/views.py`, `apps/lottery/console.py:can_view`, `can_run` · *Test:* `tests/django/test_console.py::test_a_player_cannot_open_the_console`, `test_staff_without_the_permission_cannot_open_the_console`
- **[WEB-31]** `/ops/` mostra round in corso, prossima scadenza, salute di
Electrum e del worker, operazioni in ritardo, ultima riconciliazione e il
motivo di eventuali pause.
*Stato:* implementato (A9) per round, scadenza, worker (battito scritto a ogni tick, «fermo» oltre 30 s), operazioni in ritardo (in attesa da oltre 10 minuti) e motivo delle pause; Electrum e ultima riconciliazione arrivano con la fase B (la pagina lo dice) · *Codice:* `apps/lottery/console.py:console_state`, `beat`, `late_operations` · *Test:* `tests/django/test_console.py::test_the_worker_tick_leaves_a_heartbeat`, `test_a_silent_worker_is_reported_as_stopped`, `test_operations_pending_for_too_long_are_listed`, `test_the_pause_reason_is_shown_while_it_lasts`
- **[WEB-32]** Django Admin gestisce utenti e segnalazioni; round chiusi,
transazioni e audit sono in sola lettura. Le azioni operative passano dai
servizi della lotteria e registrano attore, data, azione, motivo ed esito.
*Stato:* implementato (A9): round, partecipazioni, movimenti, transazioni e audit senza aggiunta, modifica o cancellazione; l'utente non si cancella, la scheda mostra puntate e movimenti in sola lettura, e un cambio di `is_active`/`is_staff`/`is_superuser` è nell'audit ([AUD-48](audit-log.md)) · *Codice:* `apps/lottery/admin.py`, `apps/accounts/admin.py` · *Test:* `tests/django/test_console.py::test_game_records_are_read_only_in_the_admin`, `test_a_user_page_shows_game_records_and_cannot_delete_the_user`
- **[WEB-33]** Il recupero delle chiavi non è esposto dal pannello web: è una
procedura dedicata fuori dal web.
- **[WEB-34]** La MFA TOTP e il recupero dell'accesso sono requisiti di uscita
della Fase C, non del pilota ([ADR-56](adr/ADR-56-staff-account-individuali-permessi-mfa-dopo-pilota.md)).
Il token `ADMIN_TOKEN` sparisce al passaggio alla nuova area.
## 5 · Pause
- **[WEB-40]** «Pausa dopo il round in corso»: il round attivo continua fino
al pagamento, il successivo resta sospeso.
*Stato:* implementato (A9) · *Codice:* `apps/lottery/console.py:COMMANDS`, `apps/lottery/lifecycle.py:open_new_round_if_needed` · *Test:* `tests/django/test_console.py::test_pausing_after_the_round_stops_the_next_one_from_opening`
- **[WEB-41]** «Sospendi nuove puntate»: comando distinto per gli incidenti;
nessuna nuova puntata, ma le operazioni già inviate restano monitorate.
*Stato:* implementato (A9): la home mostra «Manutenzione» e la puntata è rifiutata dal servizio · *Test:* `tests/django/test_console.py::test_suspending_bets_shows_maintenance_on_the_site_and_refuses_a_bet`
- **[WEB-42]** La sospensione dei prelievi è un comando separato dalle altre due.
*Stato:* implementato (A9) come interruttore separato con il proprio permesso; i prelievi esistono solo dalla fase B, quindi per ora ne cambia solo lo stato · *Test:* `tests/django/test_console.py::test_a_permission_for_one_command_does_not_open_the_others`
- **[WEB-43]** Pausa, ripresa e modifiche critiche richiedono conferma e
motivazione; la console mostra quali operazioni continuano e quali verifiche
servono prima della ripresa. Le pause automatiche si riesaminano dal servizio applicativo.
*Stato:* implementato (A9): la pagina del comando elenca cosa continua e, per la ripresa, le verifiche da fare con lo stato di worker e ritardi; servono motivo e conferma, e un invio ripetuto non rigira l'interruttore · *Test:* `tests/django/test_console.py::test_a_command_needs_a_reason_and_a_confirmation`, `test_the_command_page_says_what_continues_and_what_to_check_before_resuming`, `test_repeating_a_command_changes_nothing_and_adds_no_audit_row`
- **[WEB-44]** Ogni comando operativo è negato a un giocatore e a uno staff
senza il permesso specifico, si riflette sul sito con l'effetto previsto e
compare nell'audit.
*Stato:* implementato (A9): il permesso è controllato nella vista e di nuovo nel servizio, il rifiuto è nell'audit con esito `denied` · *Test:* `tests/django/test_console.py::test_a_player_cannot_run_a_command_and_the_refusal_is_audited`, `test_the_service_itself_refuses_without_the_permission`, `test_a_command_without_the_csrf_token_is_refused`
## 6 · Avvio in locale
Per navigare il sito su `https://localhost` (certificato autofirmato: l'avviso del browser alla prima visita è atteso):
```bash
mkdir -p data/db
cp .env.example .env # poi impostare DJANGO_SECRET_KEY (almeno 50 caratteri):
python3 -c "import secrets; print(secrets.token_urlsafe(64))"
docker compose up -d --build
```
Servizi: `web` (Django + gunicorn, applica le migrazioni), `worker` ([ARC-71]) e `caddy`.
Con un dominio reale basta `SITE_ADDRESS=lottery.example.com docker compose up -d`
([WEB-07]). Il vecchio `docs/setup.md` e `docs/running-the-server.md` descrivono lo stack
FastAPI, che non è più nel compose.
## 7 · Accesso e account
- **[WEB-50]** **Registrazione.** `/registrati/` crea un account con nome utente di 3–32 caratteri `[A-Za-z0-9_.-]`, unico
**senza distinzione fra maiuscole e minuscole** e salvato come digitato ([ADR-38](adr/ADR-38-username-unico-spazio-nomi-senza-distinzione.md)),
e password di 8–256 caratteri da ripetere due volte ([SEC-17]). Non si raccoglie alcuna email, quindi non esiste un recupero
automatico ([ADR-37](adr/ADR-37-nessun-recupero-password-reset.md)). Alla fine l'utente è già connesso e la
registrazione è nell'audit (`user_registered`). La password è salvata con Argon2 ([ADR-36](adr/ADR-36-password-argon2-sessioni-jwt-hs256-24.md)).
*Stato:* implementato (A5) ·
*Codice:* `apps/accounts/views.py:register_view`, `apps/accounts/forms.py:RegisterForm`, `apps/accounts/validators.py` ·
*Test:* `tests/django/test_accounts.py::test_registering_creates_the_account_and_signs_in`, `test_a_name_that_differs_only_by_case_is_taken`, `test_password_length_limits`
- **[WEB-51]** **Accesso.** `/accedi/` ammette il nome utente in qualunque combinazione di maiuscole e minuscole e risponde
**allo stesso modo** a un nome inesistente e a una password sbagliata ([SEC-19]); al login la sessione riceve una chiave nuova;
un account disattivato non entra; un utente già connesso che apre `/accedi/` o `/registrati/` è rimandato avanti.
*Stato:* implementato (A5) ·
*Codice:* `apps/accounts/views.py:login_view`, `apps/accounts/backends.py:CaseInsensitiveBackend` ·
*Test:* `tests/django/test_accounts.py::test_unknown_name_and_wrong_password_look_the_same`, `test_signing_in_gives_a_fresh_session`, `test_login_ignores_the_case_of_the_name`
- **[WEB-52]** **Destinazione dopo l'accesso.** `?next=` (e il campo nascosto che lo porta attraverso un errore o il passaggio alla
registrazione) è rispettato **solo se è un percorso del sito**: un indirizzo esterno, `//host`, una barra rovesciata o uno schema
(`javascript:`) ricadono su `/app/`, così la pagina di accesso non può mandare altrove. `/app/` e `/app/profilo/` senza sessione
rimandano ad `/accedi/?next=…`.
*Stato:* implementato (A5) ·
*Codice:* `apps/accounts/views.py:safe_next` ·
*Test:* `tests/django/test_accounts.py::test_an_open_redirect_is_refused`, `test_an_internal_destination_is_honoured`, `test_the_destination_survives_a_wrong_password_and_the_trip_to_registration`
- **[WEB-53]** **Limiti ai tentativi, condivisi fra i processi.** Lo stato sta nel database (`ThrottleEvent`), non in memoria
([ARC-72]). *Accesso:* dopo 5 errori sullo stesso nome (20 sullo stesso indirizzo) ogni tentativo deve attendere
`2 s · 2^(errori − soglia)`, fino a 300 s dall'ultimo errore; la serie finisce dopo 900 s di quiete; un accesso riuscito azzera il
nome ma **non** l'indirizzo; durante l'attesa non si guarda nemmeno la password (risposta `429` con `Retry-After`).
*Registrazione:* al massimo 5 account all'ora per indirizzo, contando gli account creati e non i tentativi. *Cambio password:*
5 errori sulla password attuale per utente, poi attesa ([SEC-54]). L'indirizzo del cliente è l'**ultimo** elemento di
`X-Forwarded-For`, quello scritto dal nostro proxy ([B-54]).
*Stato:* implementato (A5) ·
*Codice:* `apps/accounts/throttle.py`, `apps/accounts/client_ip.py` ·
*Test:* `tests/django/test_accounts.py::test_five_wrong_guesses_lock_the_name_for_a_while`, `test_the_wait_doubles_with_every_further_failure_and_is_capped`, `test_spraying_one_password_over_many_names_is_caught_by_the_address`, `test_one_address_can_register_five_accounts_an_hour`, `test_a_forged_forwarded_header_cannot_dodge_the_ip_controls`
- **[WEB-54]** **Uscita e cambio password.** L'uscita è solo `POST` (con CSRF) e chiude la sessione. Il cambio password chiede la password
attuale, chiude **tutte le altre sessioni** (una sessione è legata all'impronta della password con cui nasce, [B-34]), lascia
connessa quella corrente e scrive `password_changed` nell'audit. `/app/profilo/` mostra solo i dati dell'utente connesso ([WEB-03]).
*Stato:* implementato (A5); le segnalazioni del profilo sono in [WEB-55] ·
*Codice:* `apps/accounts/views.py:logout_view`, `apps/accounts/views.py:profile_view` ·
*Test:* `tests/django/test_accounts.py::test_a_password_change_signs_out_every_other_session`, `test_signing_out_ends_the_session_and_only_by_post`, `test_the_profile_shows_only_the_owner`
- **[WEB-55]** **Segnalazioni.** Dal profilo (`/app/profilo/`) l'utente invia una segnalazione di un problema e vede lo stato delle proprie
(aperta, letta, risolta); lo staff le gestisce da `/admin/` ([WEB-32]) cambiandone lo stato, e ogni cambio è nell'audit. Il testo ha
una lunghezza massima e l'invio è limitato per utente ([SEC-55]). Un utente vede solo le proprie segnalazioni ([WEB-03]).
*Stato:* implementato (A9): massimo 1000 caratteri, 10 invii all'ora per utente (un invio rifiutato dalla validazione non conta); il testo non è modificabile da `/admin/` · *Codice:* `apps/lottery/models.py:Report`, `apps/accounts/views.py:report_view`, `apps/lottery/admin.py:ReportAdmin` · *Test:* `tests/django/test_console.py::test_a_player_sends_a_report_and_sees_its_status`, `test_a_player_sees_only_their_own_reports`, `test_reports_are_limited_per_user`, `test_changing_a_report_status_in_the_admin_is_audited`