Come configurare l’autenticazione dell’utente con Devise in un’applicazione Rails 7

L’autore ha selezionato Girls Who Code per ricevere una donazione come parte del programma Write for DOnations.

Introduzione

Il gem Devise è una soluzione di autenticazione per le applicazioni Ruby on Rails; ti aiuta a configurare l’autenticazione utente pronta per la produzione nei tuoi progetti senza dover fare tutto da solo. Devise fornisce molte funzionalità utili come gestione delle sessioni utente e aggiunta del supporto per l’accesso di terze parti con OAuth utilizzando il gem OmniAuth. Devise include anche moduli integrati per funzionalità come il reset delle password dimenticate, il tracciamento del conteggio e dei timestamp di accesso, la definizione di timeout, il blocco degli account, e così via.

Devise rende l’autenticazione utente semplice come inizializzare il gem e creare un modello User con le funzionalità richieste. Se dovessi costruire l’autenticazione utente da zero, dovresti scrivere codice e test per tutte le funzionalità desiderate e gestire tutti i casi particolari nella gestione delle sessioni, memorizzazione dei cookie e mantenimento dei dati sicuri. Utilizzando il gem Devise, eviti di fare tutto questo da solo e puoi concentrarti sulla costruzione della tua app.

In questo tutorial, creerai un’applicazione web minimale con Rails e installerai Devise, che permetterà agli utenti di creare account, accedere e disconnettersi dai loro account.

Prerequisiti

Per completare questo tutorial, avrai bisogno di:

• A local development environment for Ruby on Rails. For Linux, you can follow our tutorial How To Install Ruby on Rails with rvm on Ubuntu 20.04 or use the rvm product docs for installing on Mac or Windows. You can also refer to the Ruby project docs to install Ruby directly in your system. To install the Rails gem, you can use the official Rails documentation. The Devise gem requires Ruby version 2.1.0 or greater; this tutorial was tested using Ruby version 3.0.2 and Rails version 7.0.3.
• Node.js installato sul tuo computer. Alcune funzionalità di Rails, come l’Asset Pipeline, dipendono da un runtime JavaScript. Node.js fornisce questa funzionalità. Per Ubuntu, installa Node.js utilizzando l’official PPA, come spiegato nell’opzione 2 di Come installare Node.js su Ubuntu 20.04. Per MacOS, segui la nostra guida Come installare Node.js e creare un ambiente di sviluppo locale su MacOS.
• Familiarità con Ruby e il framework Ruby on Rails. Puoi dare un’occhiata ai primi tutorial della nostra serie Rails on Containers, o puoi utilizzare le Guide ufficiali di Rails.

Passo 1 — Creare una nuova applicazione Rails

In questo passaggio, creerai una nuova applicazione Rails e la eseguirai localmente sul tuo computer. Utilizzerai l’utilità da riga di comando rails per inizializzare il progetto.

Esegui il seguente comando da terminale:

rails new blog

Il comando rails new creerà un nuovo progetto Rails nella directory blog, che include diversi file e cartelle generate. Una di queste è il Gemfile, che contiene le dipendenze del progetto. Configurerai il Gemfile per utilizzare Devise in Passo 3 — Installazione e Configurazione di Devise.

Puoi aprire questa directory nel tuo editor di testo preferito o navigarvi usando il terminale:

cd blog

Per avviare l’applicazione Rails, avvia il server di sviluppo con il comando rails server dalla directory del progetto:

bundle exec rails server

Questo comando avvierà il server di sviluppo di Rails. Apri http://localhost:3000 nel tuo browser per accedere alla pagina di benvenuto di Rails. Rails utilizza la porta 3000 per eseguire l’applicazione se non hai fornito un numero di porta alternativo.

Hai ora inizializzato una nuova applicazione Rails, a cui aggiungerai l’autenticazione dell’utente in un passo successivo. Nel prossimo passo, sostituirai la homepage predefinita fornita da Rails con una landing page personalizzata, che renderà più semplice navigare attraverso l’applicazione di esempio una volta aggiunto Devise. Dopo aver creato una nuova landing page, aggiungerai collegamenti per far accedere e registrare l’utente nell’applicazione.

Passo 2 — Creazione di una Pagina di Atterraggio

Ora che hai un’applicazione di base di Rails, sostituirai la pagina predefinita fornita da Rails con la tua pagina di atterraggio. Una pagina di atterraggio personalizzata renderà più semplice mostrare all’utente i collegamenti per l’accesso e la registrazione all’URL radice dell’applicazione. Aggiungerai collegamenti per accesso e registrazione nei passi successivi.

Per creare la tua pagina di atterraggio, dovrai eseguire i seguenti passaggi:

• Aggiungi la rotta nel file config/routes.rb.
• Crea un HomeController che gestirà le richieste a questa rotta.
• Crea un file di visualizzazione da renderizzare quando si colpisce la rotta.

Inizierai aggiungendo il percorso principale al file routes.rb che è stato generato quando hai creato il progetto.

Utilizzando nano o il tuo editor di testo preferito, apri il file config/routes.rb che è stato generato in precedenza:

nano config/routes.rb

Aggiungi la riga evidenziata:

Rails.application.routes.draw do
  root to: "home#index" 
end

root to: definisce quale azione del controller gestirà le richieste al percorso principale – in questo caso, la rotta sarà http://localhost:3000, che è la porta predefinita per le app Rails. Le richieste a questa rotta saranno gestite dall’azione index nel controller home. Questo file non esiste ora, quindi creerai il file app/controllers/home_controller.rb successivamente.

Salva e chiudi config/routes.rb. Utilizzando nano, premi CTRL+X per uscire, Y per salvare e INVIO per confermare il nome del file e chiudere il file.

Successivamente, crea il file app/controllers/home_controller.rb e aggiungi le seguenti righe:

class HomeController < ApplicationController
  def index
    render
  end
end

Questo è un HomeController di base con un metodo index che fa una cosa: rendere il file di visualizzazione associato all’azione del controller.

In questo caso, il file di visualizzazione sarà il file `app/views/home/index.html.erb`. Dovrai creare questo file così come la directory `home` all’interno della directory `app/views`.

Salva e chiudi il file del controller `home`.

Successivamente, crea la directory `home` nella directory `app/views`:

mkdir app/views/home/

La directory `home` conterrà tutte le viste per un particolare controller Rails.

Quindi, crea il file `app/views/home/index.html.erb` e aggiungi le seguenti righe:

<h1>Hello DigitalOcean!</h1>

`app/views/home/index.html.erb` è il file di visualizzazione che l’azione `index` del controller `Home` renderizzerà. Si tratta di un file HTML in cui puoi incorporare codice Ruby. Quando viene attivata la route definita per l’azione del controller specifico, questo file di visualizzazione viene renderizzato nel browser dell’utente.

Salva e chiudi il tuo file.

Per vedere le modifiche nell’URL radice, apri `http://localhost:3000` nel tuo browser (o aggiorna la pagina se è già aperta). La pagina iniziale aggiornata sarà simile a questa:

Puoi personalizzare ulteriormente questa pagina se necessario, ma questo è tutto ciò di cui hai bisogno per questo tutorial.

Ora che hai un’applicazione Rails semplice con la propria pagina iniziale, aggiungerai l’autenticazione dell’utente con il gemma Devise.

Passaggio 3 — Installazione e Configurazione di Devise

In questo passaggio, installerai e configurerai Devise nella tua applicazione Rails in modo da poter utilizzare i metodi e gli helper forniti dalla gemma. Utilizzerai il metodo user_signed_in? per verificare le informazioni di sessione di qualsiasi utente connesso memorizzate nei cookie del browser. Utilizzerai anche l’helper current_user per ottenere i dettagli dell’account attualmente connesso. Entrambi i metodi sono incorporati in Devise e puoi utilizzarli direttamente nella tua applicazione senza dover scrivere codice aggiuntivo. Puoi saperne di più su questi metodi di aiuto dalla pagina GitHub del progetto Devise.

Il primo passo per installare Devise è aggiungere la gemma al tuo Gemfile, che contiene informazioni su tutte le dipendenze necessarie per eseguire il tuo progetto Ruby. In questo caso, quando inizializzi l’applicazione Rails, il Gemfile generato ha già tutte le gemme di base necessarie per eseguire Rails.

Ma prima di apportare modifiche al tuo Gemfile, interrompi il server di sviluppo che hai avviato nell’ultimo passaggio premendo CTRL+C nel terminale dove è in esecuzione.

Quindi, apri il tuo Gemfile per modificarlo. Per aggiungere la gemma Devise, aggiungi la riga evidenziata verso la fine del file, ma al di fuori dei gruppi development e test:

# ...

# Riduce i tempi di avvio attraverso la memorizzazione nella cache; richiesto in config/boot.rb
gem "bootsnap", require: false

# Utilizza varianti di Active Storage [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
# gem "image_processing", "~> 1.2"

gem "devise" 

group :development, :test do
  # Vedere https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
  gem "debug", platforms: %i[ mri mingw x64_mingw ]
end

# ...

Salvare e chiudere il file.

Successivamente, installerai la gemma appena aggiunta eseguendo il comando bundle install nel terminale. Dalla directory del tuo progetto (blog), esegui il seguente comando:

bundle install

Questo comando installerà la gemma Devise nel tuo progetto, che ti permetterà di utilizzare il comando devise con l’utilità da riga di comando rails e configurare l’autenticazione.

Per configurare Devise nel tuo progetto, esegui il comando del generatore:

bundle exec rails g devise:install

Il flag g nel comando sopra sta per generate e viene utilizzato per invocare i generatori di Rails. I generatori creeranno file che possono servire come punto di partenza. Puoi leggere le guide di Rails per ulteriori informazioni sui generatori di Rails.

Il comando precedente genererà diversi file, inclusi il file inizializzatore e il file delle localizzazioni i18n per Devise. Il file inizializzatore, spiegato dettagliatamente di seguito, viene utilizzato per configurare Devise quando avvii l’applicazione per la prima volta. i18n rappresenta l’internazionalizzazione, che è uno standard per aiutarti a eseguire la tua app in lingue diverse.

A questo punto, verranno stampate anche alcune istruzioni nel terminale, come segue:

Output
===============================================================================

Depending on your application's configuration some manual setup may be required:

  1. Ensure you have defined default url options in your environments files. Here
     is an example of default_url_options appropriate for a development environment
     in config/environments/development.rb:

       config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

     In production, :host should be set to the actual host of your application.

     * Required for all applications. *

  2. Ensure you have defined root_url to *something* in your config/routes.rb.
     For example:

       root to: "home#index"

     * Not required for API-only Applications *

  3. Ensure you have flash messages in app/views/layouts/application.html.erb.
     For example:

       <p class="notice"><%= notice %></p>
       <p class="alert"><%= alert %></p>

     * Not required for API-only Applications *

  4. You can copy Devise views (for customization) to your app by running:

       rails g devise:views

     * Not required *

===============================================================================

Sebbene questa configurazione manuale non sia richiesta per questo tutorial, aggiungerai messaggi flash per notice e alert in seguito in questa fase.

Hai completato l’installazione di Devise. Successivamente, sarà necessario configurare alcune cose nel file inizializzatore di Devise appena generato.

Quando hai eseguito il comando devise:install, hai generato il file config/initializers/devise.rb, che è il file inizializzatore per Devise. Ogni volta che avvii la tua applicazione Rails, Rails caricherà tutte le gemme e i plugin, e poi caricherà tutti i file inizializzatori. Puoi configurare impostazioni specifiche per diverse parti della tua applicazione da questi file inizializzatori. Tutti questi inizializzatori risiedono nella directory config/initializers/, ed è lì che la gemma Devise crea il suo inizializzatore.

Apri config/initializers/devise.rb per modificarlo. Nel file, individua il blocco Devise.setup e aggiungi la seguente riga evidenziata (potrebbero esserci altri blocchi di codice all’interno del blocco Devise.setup, ma puoi ignorarli):

Devise.setup do |config|
  # ...

  config.navigational_formats = ['*/*', :html, :turbo_stream]

  # ...
end

Questa riga aggiunge turbo_stream come formato di navigazione. Gli stream Turbo sono parte di Turbo, che ti consente di inviare HTML renderizzato lato server e renderizzare pagine senza utilizzare molto JavaScript. È necessario aggiungere questo per far funzionare Devise 4.8.1 con Rails 7; in caso contrario, si otterrebbe un errore undefined method user_url.

Salva e chiudi il file.

Successivamente, aggiungerai anche i messaggi di avviso e di alert che sono stati evidenziati nelle istruzioni stampate in precedenza. I tag alert e notice sono dove apparirebbero i messaggi come “Password non corretta” e simili nell’interfaccia utente. Puoi sempre implementare messaggi di alert personalizzati nella tua applicazione (ad esempio, se stai utilizzando interceptor Axios con React come frontend), ma per questo tutorial, completerai la configurazione minima di Devise.

Apri app/views/layouts/application.html.erb per la modifica. Aggiungi i tag per i messaggi "notice" e "alert" all’interno del tag body, proprio sopra <%= yield %>:

...
<body>
  <p class="notice"><%= notice %></p> 
  <p class="alert"><%= alert %></p> 
  <%= yield %>
</body>

Quando la vista viene renderizzata nel browser, il <%= yield %> blocco sarà sostituito dal contenuto dei tuoi file di vista. Nel tuo file di vista, avevi solo il tag p. Questo tag yield verrà sostituito con tale contenuto.

Salva e chiudi il tuo file.

In questo passaggio, hai installato e configurato Devise nel tuo progetto. Nel prossimo passaggio, creerai il modello utente per la tua applicazione con Devise e configurerai l’autenticazione dell’utente.

Passaggio 4 — Creazione del Modello Utente con Devise

Ora sei pronto a generare il modello utente con Devise, che creerà il file di modello necessario e genererà una migrazione che potrai eseguire per creare una tabella users nella tua applicazione. Ogni volta che qualcuno si registra, dovrai creare un nuovo record nella tabella users nel database. Con il modello utente, puoi manipolare questi record del database dalla tua vista frontend.

In questo passaggio, genererai un modello utente, ispezionerai la configurazione predefinita e quindi eseguirai la migrazione per aggiornare il tuo database.

Dato che Rails è un framework modello-vista-controller (MVC), ogni tabella del database ha associata una classe, che può essere utilizzata per lavorare con i dati nella tabella. In questo caso, se crei una tabella users, puoi utilizzare il modello User per eseguire operazioni come User.first o User.find_by_email("[email protected]"). Puoi creare questo modello creando una normale classe ereditata da ApplicationRecord in Rails, ma generare un modello utente con Devise ti fornisce molti metodi che puoi utilizzare per l’autenticazione.

Per creare il tuo utente di Devise, esegui il seguente comando del generatore:

bundle exec rails g devise user

L’output seguente verrà stampato sullo schermo:

Output
invoke  active_record
create    db/migrate/20220908152949_devise_create_users.rb
create    app/models/user.rb
invoke    test_unit
create      test/models/user_test.rb
create      test/fixtures/users.yml
insert    app/models/user.rb
route  devise_for :users

L’output mostra che Devise ha generato diversi file, creato test e aggiunto percorsi. Il primo file, db/migrate/20220908152949_devise_create_users.rb, è un file di migrazione per la creazione della tabella users nel tuo database. Un file di migrazione Rails descrive le modifiche che devono essere apportate nel database. Il nome del file di ogni migrazione conterrà un timestamp in modo che Rails sappia in quale ordine eseguire tali modifiche.

Devise ha anche creato il file del modello utente (app/models/user.rb), insieme ai test per lo stesso. L’ultima riga dell’output indica che è stato aggiunto un percorso al file config/routes.rb esistente. Devise aggiunge automaticamente tutti i percorsi come /users/sign_up e /users/sign_out utilizzando l’helper devise_for :users.

Prima di eseguire il file di migrazione e creare la tabella users nel database, rivediamo questi file generati. Questo ti aiuterà a comprendere la configurazione che Devise ha generato in modo che tu sappia cosa sta succedendo quando esegui la migrazione.

Inizia aprendo il file di migrazione (db/migrate/20220908152949_devise_create_users.rb) per rivedere il codice predefinito:

# frozen_string_literal: true

class DeviseCreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      ## Database autenticabile
      t.string :email,              null: false, default: ""
      t.string :encrypted_password, null: false, default: ""

      ## Recuperabile
      t.string   :reset_password_token
      t.datetime :reset_password_sent_at

      ## Memorizzabile
      t.datetime :remember_created_at

      ## Tracciabile
      # t.integer  :numero_accessi, default: 0, null: false
      # t.datetime :ultimo_accesso
      # t.datetime :ultimo_accesso_precedente
      # t.string   :ip_corrente
      # t.string   :ultimo_ip_accesso

      ## Confermabile
      # t.string   :token_conferma
      # t.datetime :confermato_il
      # t.datetime :data_invio_conferma
      # t.string   :email_non_confermata # Solo se si utilizza la riconferma

Devise include molte opzioni utili, come campi per il token di reset della password e il tempo di invio dell’ultimo token, e così via. Ci sono anche righe per funzionalità come la conferma dell’email, il blocco dell’utente dopo tentativi di accesso falliti e persino il tracciamento dei dettagli del login.

Dato che non è necessario apportare alcuna modifica, chiudi il file di migrazione.

Devise ha generato anche il file del modello User. Questo sarà disponibile nella directory app/models/.

Apri il file del modello app/models/user.rb per esaminare il codice predefinito:

class User < ApplicationRecord
# Includi i moduli di Devise predefiniti. Altri disponibili sono:
# :confirmable, :lockable, :timeoutable, :trackable e :omniauthable
devise :database_authenticatable, :registerable,
       :recoverable, :rememberable, :validatable
end

A few options are added by Devise to configure how the user model works. The basic modules (database_authenticatable, registerable, recoverable, rememberable, and validatable) are already included. There are some additional options commented out, corresponding to the extra features you saw in the migration file. You can add these modules to the model file and configure the migration, depending on how much functionality you need in your application.

Ecco cosa fanno i moduli di base:

• database_authenticatable: Gli utenti possono autenticarsi con un campo di login e password. La loro password criptata verrà memorizzata nel tuo database.
• registerable: Gli utenti possono registrarsi e possono modificare o eliminare i loro account.
• recoverable: Gli utenti possono reimpostare la loro password e recuperare i loro account se dimenticano le loro credenziali.
• rememberable: Questo modulo ricorda le sessioni di un utente salvando le informazioni in un cookie del browser.
• validatable: Questo modulo fornisce le validazioni per i campi email e password dell’utente. (Ad esempio, la tua applicazione richiede che la password sia lunga almeno sei caratteri, anche se non hai definito alcuna validazione personalizzata nel tuo modello.)

Questi moduli di base sono inclusi nel modello User che hai appena generato. Puoi trovare un elenco completo dei moduli forniti da Devise nel repository di Devise su GitHub.

Non è necessario apportare alcuna modifica, quindi chiudi il file del modello User.

Un altro aggiornamento è che il file config/routes.rb è stato modificato per aggiungere una riga devise_for per gli utenti:

Rails.application.routes.draw do
  devise_for :users

  root "home#index"
end

Questo è un metodo utile che definisce tutte le rotte richieste relative all’autenticazione dell’utente come /users/sign_in, /users/sign_out e /users/password/new. Devise si occupa di tutto questo per te e tiene anche pulito il file delle rotte. Se vuoi capire come l’aggiunta di devise_for :users si traduce automaticamente in tutte queste rotte, puoi controllare il codice sorgente del metodo nel repository GitHub di Devise.

Qui non è necessario apportare modifiche, quindi chiudi il file config/routes.rb.

Per scoprire quali rotte sono definite nella tua applicazione, puoi elencarle eseguendo il seguente comando:

bundle exec rails routes

Questo comando stampa tutte le rotte dell’applicazione e i controller con cui vengono elaborate queste rotte. Nel caso dell’autenticazione, tutte queste rotte sono state create da Devise e non è stato necessario aggiungerle manualmente.

L’output sarà lungo, ma qui c’è un frammento che mostra alcune delle rotte:

Le rotte elencate nell’output sono le rotte che sono state aggiunte da Devise quando hai incluso la linea devise_for :users nel tuo file delle rotte. Queste sono le rotte per azioni come accesso, registrazione, reset password, e così via.

Ora che hai esaminato i file e la configurazione generati da Devise, puoi eseguire la migrazione che hai generato all’inizio di questo passaggio con il seguente comando:

bundle exec rails db:migrate

Il comando sopra eseguirà tutte le modifiche in ciascuno dei file di migrazione nel tuo database. Le modifiche devono essere apportate una dopo l’altra, proprio come sono definite nei file. Rails ha bisogno di conoscere la sequenza in cui le migrazioni dovrebbero essere eseguite, ecco perché i file sono creati con timestamp nei loro nomi.

Sull’output, apparirà qualcosa di simile a quanto segue:

Output
== 20220908152949 DeviseCreateUsers: migrating ================================
-- create_table(:users)
 -> 0.0040s
-- add_index(:users, :email, {:unique=>true})
 -> 0.0012s
-- add_index(:users, :reset_password_token, {:unique=>true})
 -> 0.0011s
== 20220908152949 DeviseCreateUsers: migrated (0.0074s) =======================

Una volta eseguita la migrazione, il tuo database è pronto. Hai fatto tutto il necessario per configurare l’autenticazione dell’utente nel tuo progetto.

A questo punto, riavvia il tuo server Rails:

bundle exec rails server

Il file inizializzatore menzionato in precedenza viene caricato solo quando Rails si avvia. Devi riavviare il server in modo che Rails possa caricare il nuovo file inizializzatore di Devise e configurare tutto per far funzionare l’autenticazione dell’utente.

Vai su http://localhost:3000/users/sign_up nel tuo browser, dove troverai un modulo di registrazione per creare un account inserendo un’email e una password. (Nel prossimo passaggio, aggiungerai pulsanti per la registrazione e l’accesso alla pagina di destinazione, in modo che sia più facile per il lettore navigare a questo URL.)

Per testare l’autenticazione, inserisci una email di test come [email protected] e una password.

Una volta registrato, verrai reindirizzato alla pagina principale, che visualizza Ciao DigitalOcean! oltre a un messaggio che conferma la tua registrazione con successo, così:

Questa notifica di successo della registrazione è resa nel tag <p class="notice"><%= notice %></p> che hai aggiunto nel file application.html.erb.

A questo punto, hai configurato l’autenticazione dell’utente con Devise nel tuo progetto e ti sei registrato utilizzando un account di esempio. Hai configurato Devise per soddisfare le esigenze della tua applicazione, mentre Devise ha generato le route, le viste e i controller che facilitano questa esperienza di registrazione dell’utente.

Ora che hai confermato che il processo di registrazione funziona come previsto, il tuo prossimo passo è aggiungere questa autenticazione alla pagina di atterraggio che hai creato nel Passo 2. Nel prossimo passo, linkerai la pagina di registrazione alla pagina di atterraggio in modo che gli utenti non debbano navigare verso un URL specifico per registrarsi, come hai dovuto fare qui.

Passaggio 5 — Collegamento dell’Autenticazione alla Pagina di Atterraggio

Hai tutte le funzionalità impostate nel tuo progetto, ma devi ancora collegare le pagine create da Devise con la tua pagina di destinazione. Nel passaggio precedente, hai visitato manualmente la pagina /users/sign_up per accedere. In questo passaggio, collegherai tutte le pagine aggiungendo i collegamenti richiesti alla tua pagina di destinazione. Mostrerai inoltre condizionalmente agli utenti i collegamenti per accedere o uscire dall’applicazione in base al loro stato.

Lo farai con alcuni metodi di aiuto di Devise. Il gemma di Devise include molti metodi di aiuto che puoi utilizzare senza dover implementare tutto da solo. Questo rende anche il codice più facile da leggere e mantenere.

Inizierai aggiungendo del codice per verificare se l’utente è loggato. Se lo sono, la pagina di destinazione mostrerà la loro email e un collegamento per uscire dall’applicazione. Se l’utente non è loggato, la pagina di destinazione mostrerà un collegamento per andare alla pagina di accesso.

Apri il file app/views/home/index.html.erb per modificarlo e aggiungi le linee evidenziate:

<% if user_signed_in? %> 
 <div> Welcome <%= current_user.email %> </div> 
  <%= button_to "Sign out", destroy_user_session_path, method: :delete %> 
<% else %>
  <%= button_to "Sign in", new_user_session_path %> 
<% end %>
<h1>Hello DigitalOcean!</h1>

user_signed_in? proviene dai metodi di aiuto associati ai controller di Devise. Controlla se l’utente è loggato o meno e restituisce un valore booleano true o false. Puoi utilizzare questo risultato per programmare altre funzionalità nella tua app, come mostrare le informazioni dell’account dell’utente se sono loggati. Per ulteriori dettagli su questo metodo di aiuto, puoi controllare il codice sorgente nel Repository GitHub di Devise.

Il `current_user` è un aiutante di Devise che accede ai dettagli dell’utente attualmente connesso all’applicazione. Ad esempio, se accedi con `[email protected]`, l’helper `current_user` restituirebbe il modello utente per `[email protected]`. Quindi, utilizzando `current_user.email`, otterresti `[email protected]` come risultato. Utilizzando Devise, eviti di dover implementare questa logica da zero, risparmiando tempo e sforzo.

Infine, con questo codice, hai aggiunto i pulsanti Accedi e Esci alla pagina di destinazione. In base al risultato del metodo di aiuto `user_signed_in?`, mostrerai l’opzione per accedere o uscire utilizzando i nuovi pulsanti Accedi e Esci.

Stai utilizzando il metodo `button_to` per definire un pulsante che porta l’utente a un percorso specifico. Stai anche utilizzando metodi di aiuto per ottenere questi percorsi: `destroy_user_session_path` risolve a `/users/sign_out` e `new_user_session_path` risolve a `/users/sign_in`. (Puoi rivedere l’elenco completo degli aiutanti degli URL del percorso eseguendo `bundle exec rails routes` come menzionato in un passaggio precedente.)

Salva e chiudi il file.

Aggiorna la pagina nel browser per rivedere le modifiche.

Se non hai ancora provato a registrarti per la tua applicazione, puoi visitare il percorso /users/sign_in cliccando sul pulsante Accedi sulla tua pagina. Da qui, puoi procedere creando un nuovo account cliccando sul collegamento Registrati in fondo. Inserisci una email di prova come [email protected] e una password. Una volta registrato, torni alla pagina iniziale. Ora la pagina iniziale mostra l’indirizzo email dell’utente attualmente loggato, insieme a un pulsante Esci, come mostrato qui:

Ricevi anche un messaggio che dice, Ti sei registrato con successo.

E con questo, hai integrato con successo il gemma Devise e configurato l’autenticazione dell’utente nella tua applicazione.

Conclusione

In questo tutorial, hai usato Devise per aggiungere l’autenticazione dell’utente a un’app Rails. Utilizzando i metodi di supporto di Devise, hai creato un’app in cui gli utenti possono creare account, registrarsi ed effettuare il logout.

Per comprendere meglio Devise e ottenere ulteriori assistenze e metodi, dai un’occhiata al file README nel repository GitHub di Devise. Come prossimo passo a questo tutorial, puoi provare a rendere condizionalmente il saluto “Ciao Mondo!” sulla pagina con qualcosa del genere Ciao nomeutente a seconda che l’utente sia loggato o meno.

Puoi trovare il codice per questo progetto nel repo GitHub della Community di DigitalOcean.