WebRobot
App Builder · pagine

Documentazione · App Builder

Accesso e ruoli

Il metodo di accesso

spec.auth.method accetta uno di due valori:

ValoreCosa succede
magic_link (predefinito)Gli utenti accedono con il loro indirizzo email: nessuna password. L'intestazione mostra un pulsante Sign in.
noneL'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 }

La pagina di accesso è /login. Il flusso:

  1. L'utente scrive il suo indirizzo email e preme Send me the link.
  2. 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.
  3. 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.
  4. 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:

LinkCodice
Valido per15 minuti15 minuti (lo stesso accesso del link)
Usouna voltauna 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, e Secure su 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:

ImpostazioneEffetto
auth.anonymous.views: [<view key>, …]I visitatori possono aprire queste viste.
auth.public: trueI 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, o public: true), e solo verso una raccolta ownedBy: 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: app o shared. 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.

assignedByCome un utente ottiene il ruolo
admin_emailsL'indirizzo dell'utente è nell'elenco degli indirizzi amministratore dell'app. Questi sono gli amministratori dell'app.
signupOgni utente che accede e non ha un altro ruolo.
derivedUn record di una raccolta riporta l'email dell'utente (vedi sotto).
admin, inviteAssegnato sull'account dell'utente. Il runtime non ha ancora una pagina per assegnarli.

Il ruolo di un utente si determina in questo ordine:

  1. admin_emails, se l'indirizzo è nell'elenco degli amministratori;
  2. un ruolo assegnato sull'account dell'utente (admin / invite);
  3. il ruolo signup. Se il manifest non ha un ruolo signup, 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 ruolo signup accanto 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 vistaUtenti con accesso che possono aprirla
non impostato, o vuototutti 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 suo default.
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: app o shared: tutti li leggono;
  • ownedBy: org: solo gli amministratori;
  • le regole access danno 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.