[Ruby on Rails] 1 modèle CRUD (routage principal)

L'opportunité d'écrire cet article

Récemment, j'ai commencé à répondre à des questions chez tetatail pour approfondir ma compréhension des rails. Quand je regarde les questions là-bas, certaines personnes peuvent penser qu'il leur manque des connaissances de base lors de la mise en œuvre de CRUD, et il semble qu'elles se regardaient il y a environ un an, alors j'espère que cela aide. J'ai écrit cet article. Qu'est-ce que CRUD De plus, en comprenant ce CRUD, même lorsque le nombre de modèles augmente à deux ou trois, on a l'impression de l'appliquer en se basant sur ces connaissances de base, donc je pense qu'il est bon de commencer par apprendre fermement le CRUD d'un modèle. ..

Public cible

• Ceux qui veulent en savoir plus sur le routage
• Ceux qui ne savent pas à quoi se réfère params [: id] ――J'étais il y a environ un an

Aperçu

Il décrit la fonction CRUD d'un modèle (nom du modèle: article, colonne: titre, contenu) avec le plus de détails possible. La description du modèle est rarement mentionnée dans cet article. Le routage et le contrôleur seront les principaux. À propos, le routage apparaît de manière persistante. Veuillez également pardonner ce point car le code est également décrit tel quel, là où il est généralement résumé.

Flux de cet article

1. Créez un nouveau projet
2. Création d'un modèle de poteau
3. Paramètres de routage
4. Créer un contrôleur de messages
5. définition de l'action d'index (pas de description du contenu)
6. Nouvelle définition d'action, création d'un nouveau formulaire d'inscription
7. créer une définition d'action
8. description du contenu de l'action d'index
9. montrer la définition de l'action, la création de la page de détail
10. Modifier la définition de l'action, modifier la création du formulaire
11. Mettre à jour la définition de l'action 10.Définition de l'action de destruction Je vais expliquer dans l'ordre de.

environnement

% ruby -v
ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-darwin19]

% rails -v
Rails 6.0.3.2

% postgres --version
postgres (PostgreSQL) 9.6.18

1. Créez un nouveau projet

Créez une application avec la commande rails new. Cette fois, le nom de l'application sera ʻone_model_crud`.

rails new [nom de l'application](one_model_crud) -d postgresql

Modifier database.yml

database.yml

default: &default
  adapter: postgresql
  encoding: unicode
  username: <%= ENV['PG_USERNAME'] %> #nom d'utilisateur défini dans postgresql
  password: <%= ENV['PG_PASSWORD'] %> #mot de passe défini dans postgresql
  # For details on connection pooling, see Rails configuration guide
  # https://guides.rubyonrails.org/configuring.html#database-pooling
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>

% rails db:create
Created database 'one_model_crud_development'
Created database 'one_model_crud_test'

% rails s

Accédez à http: // localhost: 3000 /.

Bien qu'elle s'écarte du sujet principal, cette vue temporelle utilise slim, bootstrap pour le style et les leviers comme outil de débogage.

conversion mince

Introduction de bootstrap

Vous êtes maintenant prêt.

2. Création d'un modèle de poteau

rails g modèle Créez un modèle avec le nom du modèle (forme unique).

% rails g model post

Ajoutez un titre et des colonnes de contenu.

XXXX_create_posts.rb

class CreatePosts < ActiveRecord::Migration[6.0]
  def change
    create_table :posts do |t|
      t.string :title
      t.text   :content

      t.timestamps
    end
  end
end

Reflète les informations de base de données créées.

% rails db:migrate
== 20200815005104 CreatePosts: migrating ======================================
-- create_table(:posts)
   -> 0.0271s
== 20200815005104 CreatePosts: migrated (0.0272s) =============================

Vérifions-le sur la console.

% rails c
irb(main):001:0> Post.new
=> #<Post id: nil, title: nil, content: nil, created_at: nil, updated_at: nil>
irb(main):002:0> Post.new(title: 'Titre 1', content: 'Contenu 1').save
   (0.3ms)  BEGIN
  Post Create (7.9ms)  INSERT INTO "posts" ("title", "content", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["title", "Titre 1"], ["content", "Contenu 1"], ["created_at", "2020-08-15 01:03:24.246072"], ["updated_at", "2020-08-15 01:03:24.246072"]]
   (6.8ms)  COMMIT
=> true

Vous avez créé un modèle Post. Maintenant, faisons cela dans le navigateur.

3. Paramètres de routage

Définissez le routage pour accéder à posts # index lors de l'accès à http: // localhost: 3000 /.

routes.rb

Rails.application.routes.draw do
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
  root to: "posts#index"
  resources :posts
end

resources: model (plural) générera le routage pour les sept actions de base de ce modèle: indexer, nouveau, créer, montrer, éditer, mettre à jour, détruire.

Vous pouvez également limiter les actions en écrivant resources: model (pluriel), only :: index ou resources: model (plural), only:% i [index].

Jetons un coup d'œil au routage généré sur la console.

% rails routes
     Prefix Verb       URI Pattern               Controller#Action
       root  GET      /                           posts#index
       posts GET      /posts(.:format)            posts#index
             POST     /posts(.:format)            posts#create
    new_post GET      /posts/new(.:format)        posts#new
   edit_post GET      /posts/:id/edit(.:format)   posts#edit
        post GET      /posts/:id(.:format)        posts#show
             PATCH    /posts/:id(.:format)        posts#update
             PUT      /posts/:id(.:format)        posts#update
             DELETE   /posts/:id(.:format)        posts#destroy

Un routage comme celui ci-dessus a été créé.

• 'Préfixe' sera expliqué plus tard. --Verb est une méthode HTTP. --'URI Pattern pointe vers l'URL après http: // localhost: 3000. --Controller # Action` fait référence à quelle action sur quel contrôleur est effectuée lors de l'accès à l'URL.

Dans cet esprit, jetons un œil à http: // localhost: 3000 /.

• prefix root
• Verb GET
• URI Pattern /
• Controller#Action posts#index

Cela signifie que lorsque vous visitez http: // localhost: 3000 /, vous exécuterez l'action d'indexation sur le contrôleur de messages.

4. Créer un contrôleur de messages

Créez un contrôleur avec le modèle de contrôleur rails g (pluriel).

% rails g controller posts
Running via Spring preloader in process 31151
      create  app/controllers/posts_controller.rb
      invoke  erb
      create    app/views/posts
      invoke  test_unit
      create    test/controllers/posts_controller_test.rb
      invoke  helper
      create    app/helpers/posts_helper.rb
      invoke    test_unit
      invoke  assets
      invoke    scss
      create      app/assets/stylesheets/posts.scss

Seuls ʻapp / controllers / posts_controller.rb et ʻapp / views / posts sont utilisés, vous pouvez donc les supprimer.

5. définition de l'action d'index (pas de description du contenu)

PostsController.rb

class PostsController < ApplicationController
  def index
  end
end

Le contenu sera défini après la création de la publication.

Créez index.slim dans app / views / posts / et écrivez ce qui suit

index.slim

h1 Posts#index

Vous êtes maintenant prêt. Accédez maintenant à http: // localhost: 3000 /

% rails s

Flux lors de l'accès

1. Exécutez l'action d'index PostsController
2. Afficher views / posts / index.slim Ce sera.

Lorsque vous y accédez réellement, l'écran suivant s'affiche.

6. Nouvelle définition d'action, création d'un nouveau formulaire d'inscription

En tant que flux de mise en œuvre

1. Installation du lien
2. Nouvelle action de PostsController
3. Transition vers new.slim
4. PostsController créer une action On dirait.

1. Installation du lien

Tout d'abord, créez un lien pour accéder au nouvel écran d'inscription. Ce dont vous avez besoin ici, c'est de ** Préfixe **. Le lien peut être créé en écrivant le formulaire suivant. = link_to'character to display ', Prefix_path En écrivant comme ça, vous pouvez générer un lien pour accéder au modèle URI de Prefix_path. Je vais vraiment le décrire.

index.slim

h1 Posts#index
= link_to 's'inscrire', new_post_path

Ce lien sera le lien où Prefix passe à ʻURI Pattertn` de ** new_post **. Jetons un coup d'œil au routage de la nouvelle action.

Prefix Verb       URI Pattern               Controller#Action
new_post GET      /posts/new(.:format)        posts#new

Vous avez maintenant créé un lien pour accéder au nouvel écran d'inscription.

Cliquer sur le nouveau lien d'inscription changera l'URL en / posts / new. (* J'obtiens une erreur car je n'ai pas encore défini de nouvelle action)

2. Nouvelle action de PostsController

PostsController.rb

def new
  @post = Post.new
end

Post.new crée une instance du modèle Post et attribue cette instance à @post.

3. Transition vers new.slim

new.slim

.container
  h1.mt-4 Nouvelle inscription
  = form_with url: posts_path, model: @post do |form|
    .form-group
      = form.label :title, 'Titre'
      = form.text_field :title, class: 'form-control'
    .form-group
      = form.label :content, 'Contenu'
      = form.text_area :content, class: 'form-control'
    = form.submit 'enregistrement', class: 'btn btn-primary'

Cliquez ici pour form_with => Comment utiliser form_with

Pour expliquer brièvement = Vous pouvez définir la destination de la transition lorsque vous appuyez sur envoyer avec form_with posts_path.

J'aimerais voir le routage de l'action de création ici.

Prefix Verb       URI Pattern               Controller#Action
posts GET      /posts(.:format)            posts#index
      POST     /posts(.:format)            posts#create

Si rien n'est décrit dans Préfixe, ce sera le Préfixe qui existe au début en suivant ce qui précède. Dans ce cas, le préfixe correspond aux messages. Par conséquent, il existe deux types de posts_path, posts # index et posts # create. Verb (** méthode HTTP **) est comment juger ces deux. Pour form_with, la méthode HTTP par défaut est définie sur POST. Cela signifie que ** posts_path ** écrit dans new.slim signifie ʻexécuter l'action de création de PostsController`.

4. PostsController créer une action

Tout d'abord, vérifiez le type de paramètres envoyés.

PostsController.rb

def create
  binding.pry
end

Voyons dans la console comment les données sont envoyées par écrit.

 9: def create
 => 10:   binding.pry
    11: end

[1] pry(#<PostsController>)> params
=> <ActionController::Parameters {"authenticity_token"=>"d9j/87bg84JqMg5cPr7HwMKi8PIbw8gmEhMj4EvgIblmRKqdmGAdmk1THcW9095M2cBdQxGigM/PZ+VYl9ZGYA==", "post"=>{"title"=>"Titre 2", "content"=>"Contenu 2"}, "commit"=>"enregistrement", "controller"=>"posts", "action"=>"create"} permitted: false>
[2] pry(#<PostsController>)> params[:post][:title]
=> "Titre 1"
[3] pry(#<PostsController>)> params[:post][:content]
=> "Contenu 2"

En écrivant comme ça, j'ai pu confirmer le contenu. Puis enregistrez ceci.

PostsController.rb

def create
  @post = Post.new(title: params[:post][:title], content: params[:post][:content])
  @post.save
end

Ensuite, vous pouvez l'enregistrer. Cependant, cette fois, nous l'enregistrerons en utilisant un mécanisme appelé paramètres forts qui empêchent les paramètres invalides.

PostsController.rb

def create
  @post = Post.new
  @post.save(post_params)
  redirect_to posts_path
end

private

def post_params
  params.require(:post).permit(:title, :content)
end

Le code modifié ressemble à ceci. Cette fois, le titre et le contenu peuvent être enregistrés même s'ils sont vides, de sorte que le code de branche conditionnel n'est pas écrit dans l'instruction if. La description finale de l'action de création redirect_to posts_path provoque la transition de l'URL vers /, c'est-à-dire l'exécution de l'action d'index de PostsController.

6. description du contenu de l'action d'index

Maintenant que les données ont été générées par l'action de création, l'étape suivante consiste à acquérir et à afficher les données.

PostsController.rb

def index
 @posts = Post.all
end

Vous pouvez obtenir toutes les données du modèle avec model .all et affecter les données obtenues à @posts. @posts est au pluriel car il est censé contenir plusieurs données. À propos, les données sont incluses dans le formulaire suivant.

[#<Post:0x00007f94bc4d83b8 id: 1, title: "Titre 1", content: "Contenu 1", created_at: Sat, 15 Aug 2020 05:19:09 UTC +00:00, updated_at: Sat, 15 Aug 2020 05:19:09 UTC +00:00>,
 #<Post:0x00007f94bc4ae838 id: 2, title: "Titre 2", content: "Contenu 2", created_at: Sat, 15 Aug 2020 05:19:22 UTC +00:00, updated_at: Sat, 15 Aug 2020 05:19:22 UTC +00:00>]

Montrons-les.

index.slim

.container
  h1.mt-4 Posts#index
  = link_to 's'inscrire', new_post_path

  //Postscript
  - @posts.each do |post|
    .card.my-4
      .card-header
        = post.title
      .card-body
        p.card-text
          = post.content

@posts est défini dans l'action d'index. Il est récupéré un par un avec chaque méthode et les données récupérées sont placées dans la publication. = post.title, = post.content fait référence à la colonne de titre et à la colonne de contenu des données de publication. L'écran ressemblera à celui ci-dessous.

7. montrer la définition de l'action, la création de la page de détail

Tout d'abord, configurez un bouton pour passer à l'écran des détails sous chaque donnée.

index.slim

.container
  h1.mt-4 Posts#index
  = link_to 's'inscrire', new_post_path

  - @posts.each do |post|
    .card.my-4
      .card-header
        = post.title
      .card-body
        p.card-text
          = post.content
        //Postscript
        = link_to 'Détails', post_path(post), class: 'btn btn-success mr-2'

Notez qu'il prend post comme ** argument de post_path **. Jetons un coup d'œil au routage de l'action show.

Prefix Verb       URI Pattern               Controller#Action
    post GET      /posts/:id(.:format)        posts#show

Le modèle d'URI a un: id et cette valeur change dynamiquement. (Exemple: / posts / 1, / posts / 7) Si seul post_path est utilisé, l'id est inconnu, prenez donc un argument. (Cet article de temps) En faisant cela, vous pouvez obtenir l'identifiant du message et vous pouvez passer à / posts /: id. Voyons maintenant quels paramètres sont envoyés à l'action show.

PostsController.rb

def show
  binding.pry
end

Arrêtez-vous à binding.pry et vérifiez la console

pry(#<PostsController>)> params
=> <ActionController::Parameters {"controller"=>"posts", "action"=>"show", "id"=>"1"} permitted: false>
[2] pry(#<PostsController>)> params[:id]
=> "1"

Vous pouvez obtenir l'identifiant en écrivant params [: id] comme ceci. Utilisez cet identifiant pour obtenir une donnée à partir des données du modèle Post.

PostsController.rb

def show
  @post = Post.find(params[:id])
end

En le définissant comme modèle .find (numéro d'identification), une donnée correspondant à l'id et au numéro d'identification du modèle est acquise. Vient ensuite show.slim.

show.slim

.container
  .card.my-4
    .card-header
      = @post.title
    .card-body
      p.card-text
        = @post.content

Un écran comme celui-ci s'affiche lorsque la transition se produit.

8. Modifier la définition de l'action, modifier la création du formulaire

Tout d'abord, configurez le bouton d'édition de la même manière que le bouton de détail.

index.slim

.container
  h1.mt-4 Posts#index
  = link_to 's'inscrire', new_post_path

  - @posts.each do |post|
    .card.my-4
      .card-header
        = post.title
      .card-body
        p.card-text
          = post.content
        = link_to 'Détails', post_path(post), class: 'btn btn-success mr-2'
        //Postscript
        = link_to 'Éditer', edit_post_path(post), class: 'btn btn-primary mr-2'

Jetons un coup d'œil au routage de l'action d'édition.

Prefix Verb       URI Pattern               Controller#Action
edit_post GET      /posts/:id/edit(.:format)   posts#edit

Définissez ensuite l'action d'édition.

PostsController.rb

def edit
  @post = Post.find(params[:id])
end

La description est la même que l'action show. Ensuite, écrivez edit.slim.

edit.slim

.container
  h1.mt-4 Modifier
  = form_with url: post_path(@post), model: @post do |form|
    .form-group
      = form.label :title, 'Titre'
      = form.text_field :title, class: 'form-control'
    .form-group
      = form.label :content, 'Contenu'
      = form.text_area :content, class: 'form-control'
    = form.submit 'mise à jour', class: 'btn btn-primary'

Le contenu est presque le même que new.slim, donc l'explication est omise. post_path (@post) est le même que lorsqu'il est défini dans new.slim, et cette méthode HTTP est PATCH. Je vais également regarder le routage pour le moment.

Prefix Verb       URI Pattern               Controller#Action
   post GET      /posts/:id(.:format)        posts#show
        PATCH    /posts/:id(.:format)        posts#update
        PUT      /posts/:id(.:format)        posts#update

Puisque la méthode HTTP est PATCH, l'action à exécuter lorsque le bouton de mise à jour est enfoncé cette fois est l'`` action de mise à jour de PostsController ''.

9. Mettre à jour la définition de l'action

Définissez l'action de mise à jour.

PostsController.rb

def update
  @post = Post.find(params[:id])
  @post.update(post_params)
  redirect_to posts_path
end

C'est presque la même chose que l'action de création. La différence avec l'action de création est de savoir si le modèle est nouveau ou trouvé.

10.Définition de l'action de destruction

Supprimez enfin les données. Configurez un bouton de suppression ainsi qu'un bouton d'édition. Jetons un coup d'œil à l'acheminement de l'action de destruction.

Prefix Verb       URI Pattern               Controller#Action
　post GET      /posts/:id(.:format)        posts#show
       DELETE   /posts/:id(.:format)        posts#destroy

Comme il s'agit du même post_path, ils se distinguent par la méthode HTTP. En définissant method :: HTTP method, l'action de la méthode HTTP spécifiée dans le chemin spécifié sera exécutée. Je vais vraiment le décrire.

index.slim

.container
  h1.mt-4 Posts#index
  = link_to 's'inscrire', new_post_path

  - @posts.each do |post|
    .card.my-4
      .card-header
        = post.title
      .card-body
        p.card-text
          = post.content
        = link_to 'Détails', post_path(post), class: 'btn btn-success mr-2'
        = link_to 'Éditer', edit_post_path(post), class: 'btn btn-primary mr-2'
        //Postscript
        = link_to 'Effacer', post_path(post), method: :delete, class: 'btn btn-danger'

Définissez ensuite l'action de destruction.

PostsController.rb

def destroy
  @post = Post.find(params[:id])
  @post.destroy
  redirect_to posts_path
end

Vous avez maintenant implémenté un modèle de CRUD.

Code complété

Pour le moment, le code complété est listé ci-dessous.

Postscontroller.rb

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end

  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)
    @post.save
    redirect_to posts_path
  end

  def show
    @post = Post.find(params[:id])
  end

  def edit
    @post = Post.find(params[:id])
  end

  def update
    @post = Post.find(params[:id])
    @post.update(post_params)
    redirect_to posts_path
  end

  def destroy
    @post = Post.find(params[:id])
    @post.destroy
    redirect_to posts_path
  end

  private

  def post_params
    params.require(:post).permit(:title, :content)
  end
end

en conclusion

Pour l'instant, j'ai pu écrire tout le contenu que je voulais me montrer il y a un an.