Comment créer plusieurs boutons d'envoi pour le même formulaire dans Rails?

J'ai besoin de plusieurs boutons d'envoi.

J'ai un formulaire qui crée une instance de Contact_Call.

Un bouton le crée normalement.

L'autre bouton le crée mais doit avoir une valeur d'attribut différente de la valeur par défaut, et il doit également définir l'attribut sur un modèle différent, mais lié, utilisé dans le contrôleur.

Comment je fais ça? Je ne peux pas changer l'itinéraire, alors existe-t-il un moyen d'envoyer une variable différente qui est captée par [: params]?

Et si je fais alors, que dois-je faire dans le contrôleur, mettre en place une déclaration de cas?

Vous pouvez créer plusieurs boutons d'envoi et fournir une valeur différente à chacun:

<% form_for(something) do |f| %>
    ..
    <%= f.submit 'A' %>
    <%= f.submit 'B' %>
    ..
<% end %>

Cela produira:

<input type="submit" value="A" id=".." name="commit" />
<input type="submit" value="B" id=".." name="commit" />

À l'intérieur de votre contrôleur, la valeur du bouton soumis sera identifiée par le paramètre commit. Vérifiez la valeur pour effectuer le traitement requis:

def <controller action>
    if params[:commit] == 'A'
        # A was pressed 
    elsif params[:commit] == 'B'
        # B was pressed
    end
end

Cependant, rappelez-vous que cela couple étroitement votre vue au contrôleur, ce qui peut ne pas être très souhaitable.

Il existe également une autre approche, utilisant l'attribut formaction sur le bouton d'envoi:

<% form_for(something) do |f| %>
    ...
    <%= f.submit "Create" %>
    <%= f.submit "Special Action", formaction: special_action_path %>
<% end %>

Le code reste propre, car le bouton de création standard ne nécessite aucune modification, vous insérez uniquement un chemin de routage pour le bouton spécial:

formaction:
L'URI d'un programme qui traite les informations soumises par l'élément d'entrée, s'il s'agit d'un bouton ou d'une image d' envoi . S'il est spécifié, il remplace l'attribut action du propriétaire du formulaire de l'élément . Source: MDN

Vous pouvez également reconnaître quel bouton a été enfoncé en changeant son nom d'attribut.

<% form_for(something) do |f| %>
    ..
    <%= f.submit 'A', name: 'a_button' %>
    <%= f.submit 'B', name: 'b_button' %>
    ..
<% end %>

C'est un peu inconfortable car vous devez vérifier la présence des touches de paramètres au lieu de simplement vérifier la params[:commit]valeur: vous recevrez params[:a_button]ou en params[:b_button]fonction de celle qui a été pressée.

Solution similaire à celle suggérée par @ vss123 sans utiliser de gemmes:

resources :plan do
  post :save, constraints: lambda {|req| req.params.key?(:propose)}, action: :propose
  post :save, constraints: lambda {|req| req.params.key?(:finalize)}, action: :finalize
end

Notez que j'évite d'utiliser la valeur et d'utiliser le nom d'entrée à la place, car la valeur du bouton d'envoi est souvent internationalisée / traduite. De plus, j'éviterais de trop l'utiliser car cela encombrera rapidement votre fichier de routes.

Nous avons résolu en utilisant des contraintes avancées dans les rails.

L'idée est d'avoir le même chemin (et donc la même route & action nommée) mais avec des contraintes de routage vers différentes actions.

resources :plan do
  post :save, constraints: CommitParamRouting.new("Propose"), action: :propose
  post :save, constraints: CommitParamRouting.new("Finalize"), action: :finalize
end

CommitParamRouting est une classe simple qui a une méthode matches? qui renvoie true si le paramètre de validation correspond à l'instance attr. valeur.

Ceci est disponible sous forme de gem commit_param_matching .

Une vieille question, mais comme je fais face à la même situation, j'ai pensé afficher ma solution. J'utilise des constantes de contrôleur pour éviter d'introduire une différence entre la logique du contrôleur et le bouton d'affichage.

class SearchController < ApplicationController
  SEARCH_TYPES = {
    :searchABC => "Search ABCs",
    :search123 => "Search 123s"
  }

  def search
    [...]
    if params[:commit] == SEARCH_TYPES[:searchABC]
      [...]
    elsif params[:commit] == SEARCH_TYPES[:search123]
      [...]
    else
      flash[:error] = "Search type not found!"]
      [...]
    end
  end
  [...]          
end

Et puis dans la vue:

<% form_for(something) do |f| %>
    [...]
    <%= f.submit SearchController::SEARCH_TYPES[:searchABC] %>
    <%= f.submit SearchController::SEARCH_TYPES[:search123] %>
    [...]
<% end %>

De cette façon, le texte ne vit qu'à un seul endroit - en tant que constante dans le contrôleur. Cependant, je n'ai pas encore essayé de comprendre comment y parvenir.

J'ai un nombre variable de boutons d'envoi sur mon formulaire grâce à nested_form_fields, donc utiliser le nom ne me suffisait pas. J'ai fini par inclure un champ de saisie caché dans le formulaire et utiliser Javascript pour le remplir lorsque l'un des boutons de soumission du formulaire était enfoncé.