Ruby on Rails - Controller

Il controller Rails è il centro logico della tua applicazione. Coordina l'interazione tra l'utente, le viste e il modello. Il responsabile del trattamento è anche sede di una serie di importanti servizi ausiliari.

• È responsabile dell'instradamento delle richieste esterne alle azioni interne. Gestisce estremamente bene gli URL a misura di utente.

• Gestisce il caching, che può dare alle applicazioni miglioramenti delle prestazioni di ordini di grandezza.

• Gestisce i moduli di supporto, che estendono le capacità dei modelli di visualizzazione senza aumentare il loro codice.

• Gestisce le sessioni, dando agli utenti l'impressione di una continua interazione con le nostre applicazioni.

Il processo per creare un controller è molto semplice ed è simile al processo che abbiamo già utilizzato per creare un modello. Creeremo solo un controller qui -

library\> rails generate controller Book

Nota che stai usando le maiuscole Book e stai usando la forma singolare. Questo è un paradigma di Rails che dovresti seguire ogni volta che crei un controller.

Questo comando esegue diverse attività, di cui le seguenti sono rilevanti qui:

• Crea un file chiamato app/controllers/book_controller.rb

Se guardi book_controller.rb, lo troverai come segue:

class BookController < ApplicationController
end

Le classi controller ereditano da ApplicationController, che è l'altro file nella cartella controller:application.rb.

L' ApplicationController contiene codice che può essere eseguito in tutti i controller e eredita dalla classe Rails ActionController :: Base .

Non devi ancora preoccuparti di ApplicationController , quindi definiamo solo alcuni stub di metodo inbook_controller.rb. In base alle proprie esigenze, è possibile definire un numero qualsiasi di funzioni in questo file.

Modifica il file in modo che abbia l'aspetto seguente e salva le modifiche. Nota che dipende da te quale nome vuoi dare a questi metodi, ma è meglio dare nomi pertinenti.

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

Ora implementiamo tutti i metodi uno per uno.

Implementazione del metodo elenco

Il metodo elenco fornisce un elenco di tutti i libri nel database. Questa funzionalità verrà ottenuta dalle seguenti righe di codice. Modifica le seguenti righe nel file book_controller.rb.

def list
   @books = Book.all
end

La riga @books = Book.all nel metodo list dice a Rails di cercare nella tabella books e di memorizzare ogni riga che trova nell'oggetto istanza @books.

Implementazione del metodo show

Il metodo mostra mostra solo ulteriori dettagli su un singolo libro. Questa funzionalità verrà ottenuta dalle seguenti righe di codice.

def show
   @book = Book.find(params[:id])
end

La riga @book = Book.find (params [: id]) del metodo show dice a Rails di trovare solo il libro che ha l'id definito in params [: id].

L'oggetto params è un contenitore che consente di passare valori tra le chiamate di metodo. Ad esempio, quando sei sulla pagina chiamata dal metodo list, puoi fare clic su un collegamento per un libro specifico e passa l'ID di quel libro tramite l'oggetto params in modo che show possa trovare il libro specifico.

Implementazione del nuovo metodo

Il nuovo metodo fa sapere a Rails che creerai un nuovo oggetto. Quindi aggiungi il seguente codice in questo metodo.

def new
   @book = Book.new
   @subjects = Subject.all
end

Il metodo sopra verrà chiamato quando mostrerai una pagina all'utente per ricevere l'input dell'utente. Qui la seconda riga prende tutti i soggetti dal database e li inserisce in un array chiamato @subjects.

Implementazione del metodo create

Dopo aver ricevuto l'input dell'utente utilizzando il modulo HTML, è il momento di creare un record nel database. Per ottenere ciò, modifica il metodo create nel book_controller.rb in modo che corrisponda a quanto segue:

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

La prima riga crea una nuova variabile di istanza chiamata @book che contiene un oggetto Book costruito dai dati, l'utente inviato. Ilbook_params viene utilizzato per raccogliere tutti i campi dall'oggetto :books. I dati sono stati passati dal nuovo metodo per creare utilizzando l'oggetto params.

La riga successiva è un'istruzione condizionale che reindirizza l'utente al file listmetodo se l'oggetto viene salvato correttamente nel database. Se non viene salvato, l'utente viene rimandato al nuovo metodo. Il metodo redirect_to è simile all'esecuzione di un meta refresh su una pagina web: ti inoltra automaticamente alla tua destinazione senza alcuna interazione da parte dell'utente.

Quindi @subjects = Subject.all è richiesto nel caso in cui non salvi i dati correttamente e diventi simile a quello della nuova opzione.

Implementazione del metodo di modifica

Il metodo di modifica sembra quasi identico al metodo show. Entrambi i metodi vengono utilizzati per recuperare un singolo oggetto in base al suo ID e visualizzarlo su una pagina. L'unica differenza è che il metodo di visualizzazione non è modificabile.

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

Questo metodo verrà chiamato per visualizzare i dati sullo schermo che verranno modificati dall'utente. La seconda riga cattura tutti i soggetti dal database e li inserisce in un array chiamato @subjects.

Implementazione del metodo di aggiornamento

Questo metodo verrà chiamato dopo il metodo di modifica, quando l'utente modifica un dato e desidera aggiornare le modifiche nel database. Il metodo di aggiornamento è simile al metodo di creazione e verrà utilizzato per aggiornare i libri esistenti nel database.

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

Il metodo update_attributes è simile al metodo save utilizzato da create ma invece di creare una nuova riga nel database, sovrascrive gli attributi della riga esistente.

Quindi @subjects = Subject.all è richiesta la riga nel caso in cui non salvi i dati correttamente, quindi diventa simile all'opzione di modifica.

Implementazione del metodo di eliminazione

Se desideri eliminare un record dal database, utilizzerai questo metodo. Implementa questo metodo come segue.

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

La prima riga trova il classificato in base al parametro passato tramite l'oggetto params e quindi lo elimina utilizzando il metodo destroy. La seconda riga reindirizza l'utente al metodo list utilizzando una chiamata redirect_to.

Metodi aggiuntivi per visualizzare i soggetti

Supponi di voler offrire ai tuoi utenti la possibilità di sfogliare tutti i libri in base a un determinato argomento. Quindi, puoi creare un metodo all'interno di book_controller.rb per visualizzare tutti gli argomenti. Supponiamo che il nome del metodo siashow_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

Finalmente il tuo book_controller.rb il file avrà il seguente aspetto:

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

Ora salva il file del controller.

Cosa c'è dopo?

Hai creato quasi tutti i metodi, che funzioneranno sul backend. Successivamente definiremo percorsi (URL) per le azioni.