Documentazione · App Builder
Accesso e ruoli
Il metodo di accesso
spec.auth.method accetta uno di due valori:
| Valore | Cosa succede |
|---|---|
magic_link (predefinito) | Gli utenti accedono con il loro indirizzo email: nessuna password. L'intestazione mostra un pulsante Sign in. |
none | L'intestazione non mostra il pulsante Sign in, e i visitatori possono aprire ogni vista. Ciò che richiede un utente manda comunque il visitatore ad accedere: le viste di storico e account, i moduli non aperti ai visitatori, l'avvio di un'esecuzione, la chat, il caricamento di un file, la prenotazione. |
auth:
method: magic_link
anonymous: { views: [home, pricing] }
roles:
- { key: admin, assignedBy: admin_emails }
- { key: user, assignedBy: signup }
Accesso con link o codice via email
La pagina di accesso è /login. Il flusso:
- L'utente scrive il suo indirizzo email e preme Send me the link.
- L'app invia un'email con due modi per accedere: un link e un codice di 6 cifre. L'email arriva da WebRobot per conto dell'app e ne riporta il nome. L'oggetto è "Sign-in link for «App name» (via WebRobot)". L'email è in italiano quando la pagina è in italiano, altrimenti in inglese.
- L'utente apre il link, oppure scrive il codice nella pagina ancora aperta. Il codice serve per l'app per telefono: su un telefono il link apre il browser, non l'app.
- L'app imposta la sessione e apre la pagina da cui l'utente proveniva (la pagina
next), o la home page.
Regole del link e del codice:
| Link | Codice | |
|---|---|---|
| Valido per | 15 minuti | 15 minuti (lo stesso accesso del link) |
| Uso | una volta | una volta |
| Tentativi sbagliati | — | dopo 5 codici sbagliati l'accesso viene annullato (anche il link smette di funzionare): chiedine uno nuovo |
Quando ci sono più accessi in attesa per lo stesso indirizzo, il codice viene confrontato con il più recente.
Gli errori che un utente può vedere: link already used, link expired, invalid link, wrong code,
code expired: ask for a new one, too many attempts: ask for a new code, invalid email.
Limiti sugli accessi
Per proteggere le caselle di posta e l'app, il runtime limita le richieste di accesso:
- 10 richieste all'ora da un indirizzo di rete, per app;
- 3 email all'ora verso un indirizzo, per app. Le richieste successive ricevono la stessa risposta "inviato", ma nessuna email parte;
- un tetto per app e per ora al numero di email di accesso;
- 20 verifiche di codice all'ora da un indirizzo di rete, per app.
Una richiesta bloccata riceve too many requests, try again later.
Il primo accesso crea l'account
Non c'è una registrazione separata. La prima volta che un indirizzo accede, l'app ne crea l'utente. Se
billing.signupCredits è impostato, il nuovo utente riceve quei crediti in quel momento. Vedi Pagamenti e crediti.
Sessioni
Dopo l'accesso il browser conserva un cookie di sessione per l'app:
- dura 30 giorni;
- è
HttpOnly(gli script della pagina non possono leggerlo),SameSite=Lax, eSecuresu https; - è legato a una sola app: la sessione di un'app non apre mai un'altra app, nemmeno sullo stesso dominio padre;
- il ruolo dell'utente viene ricalcolato a ogni richiesta, quindi un cambio di ruolo ha effetto subito, senza accedere di nuovo.
L'anteprima della bozza aperta da App Studio usa sessioni proprie, separate dagli utenti dell'app pubblicata. L'anteprima si apre solo per gli amministratori dell'app, o da App Studio. Vedi App Studio.
Uscita
Sign out nell'intestazione cancella il cookie di sessione in quel browser e torna alla home page. Nell'app per telefono interrompe anche le notifiche push per quell'utente su quel dispositivo.
Visitatori senza accesso
Per impostazione predefinita ogni vista richiede un utente che ha fatto l'accesso. Un visitatore che ne apre una viene
mandato a /login e ritorna dopo l'accesso.
Due impostazioni aprono le viste ai visitatori:
| Impostazione | Effetto |
|---|---|
auth.anonymous.views: [<view key>, …] | I visitatori possono aprire queste viste. |
auth.public: true | I visitatori possono aprire ogni vista. Pensata per app le cui pagine si leggono senza login. |
Con public: true (e con method: none) i roles di una vista non impediscono ai visitatori di aprirla. Ciò che la
vista mostra segue comunque le regole dei dati: un visitatore non legge mai i record degli utenti né il back office
del proprietario.
Cosa un visitatore non può comunque fare:
- Moduli. Un visitatore può inviare un modulo solo se la vista del modulo è aperta ai visitatori (elencata in
anonymous.views, opublic: true), e solo verso una raccoltaownedBy: org(la casella del proprietario). Al massimo 5 invii all'ora da un indirizzo di rete per modulo. I visitatori non possono allegare file. Vedi Dati. - Esecuzioni, chat, prenotazioni, file. Richiedono sempre un utente che ha fatto l'accesso.
- Dati. I visitatori leggono solo raccolte
ownedBy: apposhared. Vedi Dati. - Pagine che appartengono a un utente (storico, account, il report di un'esecuzione) vengono escluse da una pagina mostrata a un visitatore.
auth.anonymous.agents elenca gli agenti che i visitatori possono usare senza accesso. La validazione verifica che
questi agenti non abbiano strumenti che raggiungono i dati privati del proprietario o scrivono dati condivisi. Oggi la
chat web non usa questo elenco: la chat richiede sempre un utente che ha fatto l'accesso.
Ruoli
spec.auth.roles elenca i ruoli dell'app. Ogni ruolo ha una key, una label facoltativa (traducibile) e
assignedBy, che dice come un utente lo ottiene.
assignedBy | Come un utente ottiene il ruolo |
|---|---|
admin_emails | L'indirizzo dell'utente è nell'elenco degli indirizzi amministratore dell'app. Questi sono gli amministratori dell'app. |
signup | Ogni utente che accede e non ha un altro ruolo. |
derived | Un record di una raccolta riporta l'email dell'utente (vedi sotto). |
admin, invite | Assegnato sull'account dell'utente. Il runtime non ha ancora una pagina per assegnarli. |
Il ruolo di un utente si determina in questo ordine:
admin_emails, se l'indirizzo è nell'elenco degli amministratori;- un ruolo assegnato sull'account dell'utente (
admin/invite); - il ruolo
signup. Se il manifest non ha un ruolosignup, il ruolo dell'utente èuser.
Poi, se vale il ruolo del passo 3, il runtime controlla i ruoli derived.
Ruoli derivati
Un ruolo derivato segue i tuoi dati. L'utente lo possiede finché un record riporta la sua email:
auth:
roles:
- { key: admin, assignedBy: admin_emails }
- { key: client, assignedBy: signup }
- { key: consultant, assignedBy: derived, from: collection:consultants.email }
fromècollection:<name>.<emailField>, o un elenco di questi: una qualsiasi corrispondenza dà il ruolo.- Il campo può contenere un indirizzo o un elenco di indirizzi. Gli indirizzi si confrontano ignorando maiuscole e spazi attorno.
- I ruoli si controllano nell'ordine del manifest; vince la prima corrispondenza.
- Ottiene un ruolo derivato solo un utente che altrimenti avrebbe il ruolo
signup. Conserva il ruolosignupaccanto a quello derivato: una vista, un campo di un modulo o una regola di accesso per l'uno o l'altro ruolo vale per lui. - Il ruolo si controlla a ogni richiesta. Elimina o modifica il record, e il ruolo sparisce.
Gli amministratori dell'app
Gli amministratori di un'app sono gli utenti il cui ruolo ha assignedBy: admin_emails e il cui indirizzo è
nell'elenco degli indirizzi amministratore dell'app. L'elenco non fa parte del manifest: la piattaforma lo fornisce al
runtime insieme all'app. Se nessun ruolo ha assignedBy: admin_emails, l'app non ha amministratori.
Cosa possono fare gli amministratori e gli altri utenti no:
- leggere e modificare ogni record di ogni raccolta, chiunque ne sia il proprietario (vedi Dati);
- aprire il report di ogni esecuzione e ogni file caricato;
- la pagina Data (
/admin/data), per gestire cataloghi e dati di back office a mano o da un CSV; - la pagina Notifications (
/admin/push) quando l'app invia notifiche push; - una vista di tipo
admin: utenti, saldi, aggiunta di crediti, le ultime esecuzioni (vedi Viste); - decidere ogni approvazione, tranne quelle che decide l'utente richiedente (
decidedBy: requester); - eseguire agenti senza pagare, e senza i limiti di
spec.limits; - usare campi e opzioni riservati a un piano, e vedere blocchi di dati riservati a un piano;
- aprire l'anteprima della bozza dell'app.
Gli amministratori non scavalcano i roles di una vista. Una vista con roles: [user] è nascosta a un
amministratore il cui ruolo è admin. Aggiungi il ruolo amministratore alle viste che gli servono:
roles: [user, admin]. Il controllo di progettazione dà un avviso quando il ruolo amministratore non è in nessuna
vista del menu.
Cosa vede ogni ruolo
I roles di una vista decidono chi la apre:
roles sulla vista | Utenti con accesso che possono aprirla |
|---|---|
| non impostato, o vuoto | tutti quelli che hanno fatto l'accesso |
[a, b] | gli utenti che hanno il ruolo a o b (il loro ruolo, o il ruolo signup conservato accanto a un ruolo derivato) |
Un utente che non può aprire una vista riceve "not found". Un visitatore viene mandato ad accedere.
Lo stesso controllo decide:
- quali viste compaiono nel menu (vedi Viste);
- quali viste compaiono dentro una pagina, una dashboard o delle schede;
- quali campi dei moduli sono mostrati: un campo con
rolesè nascosto agli altri ruoli. Nel modulo di esecuzione, un campo nascosto riceve il suodefault.
views:
- { key: requests, type: table, source: collection:requests, roles: [consultant, admin] }
- { key: new_request, type: form, collection: requests, roles: [client] }
Cosa cambia con il proprietario
I ruoli decidono quali pagine apre un utente. Quali record l'utente vede in quelle pagine dipende dal proprietario della raccolta e dalle sue regole di accesso:
ownedBy: user: ogni utente vede i propri record;ownedBy: apposhared: tutti li leggono;ownedBy: org: solo gli amministratori;- le regole
accessdanno a un ruolo più record, es. le richieste assegnate a un consulente.
Le regole complete sono in Dati.
Lingua
Quando metadata.langs ha più di una lingua, l'intestazione mostra un pulsante per lingua (EN, IT…). Premerne uno
memorizza la scelta nel browser per un anno e ricarica la stessa pagina. Senza una scelta, l'app usa la prima lingua
delle preferenze del browser se l'app la prevede, altrimenti metadata.defaultLang. Vedi
Il manifest.