मजबूत पैरामीटर का उपयोग करके नेस्टेड मॉडल के साथ बनाएं और अपडेट करें रेल

Question

यहां मेरे 3 मॉडल हैं।

User 
    has_many :memberships 
    has_many :teams, through: :memberships, dependent: :destroy 
    accepts_nested_attributes_for :memberships 

Team 
    has_many :memberships 
    has_many :users, through: :memberships, dependent: :destroy 
    accepts_nested_attributes_for :memberships 

Membership 
    belongs_to :team 
    belongs_to :user 

यहाँ मेरी टीम नियंत्रक के कुछ अंश हैं। मेरा उद्देश्य यहां एक निश्चित टीम में सदस्यों को जोड़ने/अपडेट करना है। ध्यान दें कि सदस्यों को जोड़ने के लिए स्रोत पहले से ही उपयोगकर्ताओं के समूह के रूप में मौजूद है। टीम नियंत्रक

#parameters for team details 
def team_params 
    params.require(:team).permit(:name, :department) 
end 

#parameters for members (includes leader) 
def members_params 
    params.require(:team).permit(:leader, members:[]) 
end 

#get id values from members_params and store in an array 
def member_ids 
    members_params.values.flatten 
end 

प्रपत्र के लिए के लिए

TeamsController 
    def create 
     @team = Team.new(team_params) 
     @team.users << User.find(member_ids) #add leader and members to team 
     if @team.save 
      #redirect to created team 
     else 
      #show errors 
     end 
    end 

    def update 
     #TO DO: update team roster here 
     if @team.update(team_params) 
      #redirect to updated team 
     else 
      #show errors 
     end 
    end 

मजबूत मापदंडों, मैं सिर्फ है:

1. नाम (पाठ क्षेत्र)
2. विभाग (कॉम्बो बॉक्स)
3. नेता (कॉम्बो बॉक्स, चयनित विभाग के आधार पर जेनरेट किए गए विकल्पों के साथ, चयनित उपयोगकर्ता की उपयोगकर्ता आईडी के रूप में सबमिट करता है)
4. सदस्य, चयनित विभाग के आधार पर उत्पन्न विकल्पों के साथ (कॉम्बो बॉक्स, कई, चयनित उपयोगकर्ताओं के उपयोगकर्ता आईडी की एक सरणी के रूप में प्रस्तुत)

मैं सफलतापूर्वक एक टीम बना सकते हैं, एक साथ सत्यापन के गुजरने के साथ (दोनों टीम और सदस्यता मॉडल), मेरे निर्माण पर। हालांकि, मुझे इस बात को लेकर कोई जानकारी नहीं है कि टीम को कैसे अपडेट किया जाए, क्योंकि अगर मैं @team.users.clear का उपयोग करता हूं और फिर बस वही काम करता हूं (मुझे पता है, यह करने के लिए यह थोड़ा बेवकूफ है), यह मान्य होगा, लेकिन यह इसे बिना सहेजेगा अगर कोई त्रुटि है या नहीं।

फार्म कोड फार्म के लिए

<%= form_for(@team, remote: true) do |f| %> 

    <%= f.label :name, "Name" %> 
    <%= f.text_field :name %> 

    <%= f.label :department, "Department" %> 
    <%= f.select :department, options_for_select(["Architectural", "Interior Design"], department), include_blank: true %> 

    <%= f.label :leader, "Leader" %> 
    <%= f.select :leader, select_leaders(department, @team.id), {include_blank: true, selected: pre_select(:leader)} %> 

    <%= f.label :members, "Members" %> 
    <%= f.select :members, select_members(department, @team.id), {include_blank: true}, {id: "team_members", multiple: :multiple, data: {member_ids: pre_select(:members)}}%> 

<% end %> 

नोट:

1. यह फार्म दोनों खाली और आबादी वाले रूपों के लिए काम करता है।
2. :members फ़ील्ड select2 सक्षम है।

तो मेरे सवालों यहां हैं:

1. मैं टीम के सदस्यों कैसे कर सकते हैं? क्या वर्तमान में मेरे मजबूत पैरामीटर के आधार पर अद्यतन करना संभव है, या क्या उन्हें संशोधित करने की आवश्यकता है?
2. क्या मेरी निर्माण विधि को भी संशोधित किया जाना चाहिए?

कुछ विकल्प समाधान के लिए

विकल्प # 1 (सबसे अच्छा समाधान अब तक)

मैं केवल इस के लिए एक प्राथमिक चिकित्सा समाधान था, इसलिए मुझे लगता है कि क्या तुलना में एक बेहतर दृष्टिकोण के अग्रणी मैंने नीचे किया मैंने यहां क्या किया है, सदस्य_ड्स से प्राप्त उपयोगकर्ताओं के साथ उपयोगकर्ता पैराम बनाने के लिए मूल्यों के रूप में। समाधान 1 से

TeamsController 
    def create 
     team = Team.new(team_params.merge({users: User.find(member_ids)})) 
     ... 
    end 

    def update 
     ... 
     if @team.update(team_params.merge({users: User.find(member_ids)})) 
     .. 
    end 

विकल्प # 2

स्वतंत्र, मैं केवल team_params के रूप में मजबूत पैरामीटर था।

TeamsController 
    ... 
    private 
     def team_params 
      params.require(:team).permit(:name, :department, :leader, members:[]) 
     end 

मैंने नेता और सदस्यों दोनों के लिए सेटटर विधियां बनाई हैं। लेकिन ऐसा लगता है कि सदस्य नेता सेटर को ओवरराइट करते हैं क्योंकि मैंने दोनों सेटर्स के लिए update विधि का उपयोग किया था, और अपडेट उसी संसाधन का उपयोग करता है जो उपयोगकर्ता है। इस विकल्प के साथ एक कामकाज संभव है।

Team 
    ... 
    def leader=(leader_id) 
     #self.update(users: User.find(leader_id)) 
    end 

    def members=(members_ids) 
     #self.update(users: User.find(members_id)) 
    end 

Answer 1

चूंकि, नेता और सदस्य आपके परिदृश्य में इतने अलग नहीं हैं। आप कुछ इस तरह करने के लिए अपने मॉडल और दृश्य रूप बदल सकते हैं:

class Team < ActiveRecord::Base 
    has_many :memberships 
    has_many :users, through: :memberships, dependent: :destroy 
    accepts_nested_attributes_for :memberships 
end 

class User < ActiveRecord::Base 
    has_many :memberships 
    has_many :teams, through: :memberships, dependent: :destroy 
end 

class Membership < ActiveRecord::Base 
    belongs_to :team 
    belongs_to :user 
    accepts_nested_attributes_for :user 
end 

और फार्म दृश्य कोड:

# GET /teams/new 
def new 
    @team = Team.new 
    3.times do # number of members you need to generate! 
    @team.memberships.build{ |m| m.build_user } 
    end 
end 

# GET /teams/1/edit 
def edit 
end 

# POST /teams 
# POST /teams.json 
def create 
    @team = Team.new(team_params) 

    respond_to do |format| 
    if @team.save 
     format.html { redirect_to @team, notice: 'Team was successfully created.' } 
     format.json { render action: 'show', status: :created, location: @team } 
    else 
     format.html { render action: 'new' } 
     format.json { render json: @team.errors, status: :unprocessable_entity } 
    end 
    end 
end 

private 
    # Use callbacks to share common setup or constraints between actions. 
    def set_team 
    @team = Team.find(params[:id]) 
    end 

    # Never trust parameters from the scary internet, only allow the white list through. 
    def team_params 
    params.require(:team).permit(:name, memberships_attributes: [:id, :name, user_attributes: [:id, :name]]) 
    end 

:

<%= form_for(@team) do |f| %> 
    <% if @team.errors.any? %> 
    <div id="error_explanation"> 
     <h2><%= pluralize(@team.errors.count, "error") %> prohibited this team from being saved:</h2> 

     <ul> 
     <% @team.errors.full_messages.each do |msg| %> 
     <li><%= msg %></li> 
     <% end %> 
     </ul> 
    </div> 
    <% end %> 

    <div class="field"> 
    <%= f.label :name %><br> 
    <%= f.text_field :name %> 
    </div> 

    <%= f.fields_for :memberships do |m| %> 
    <div class="field"> 
     <%= m.label :memberships_name %><br> 
     <%= m.text_field :name %> 
    </div> 

    <%= m.fields_for :user do |u| %> 
     <div class="field"> 
     <%= u.label :user_name %><br> 
     <%= u.text_field :name %> 
     </div>  
    <% end %> 
    <% end %> 


    <div class="actions"> 
    <%= f.submit %> 
    </div> 
<% end %> 

इसके अलावा, आप अपने नियंत्रक में बदल सुनिश्चित करें

हालांकि आप इसे त्वरित कोड सत्यापन करने के लिए रेल कंसोल में कर सकते हैं:

team_params = {"name"=>"Team", "memberships_attributes"=>{"0"=>{"name"=>"Membership 1", "user_attributes"=>{"name"=>"User 1"}}, "1"=>{"name"=>"Membership 2", "user_attributes"=>{"name"=>"User 2"}}, "2"=>{"name"=>"Membership 3", "user_attributes"=>{"name"=>"User 3"}}}} 

team = Team.new(team_params) 
team.save 
team.users 
#=> #<ActiveRecord::Associations::CollectionProxy [#<User id: 1, name: "User 1", email: nil, created_at: "2014-09-04 11:25:48", updated_at: "2014-09-04 11:25:48">, #<User id: 2, name: "User 2", email: nil, created_at: "2014-09-04 11:25:48", updated_at: "2014-09-04 11:25:48">, #<User id: 3, name: "User 3", email: nil, created_at: "2014-09-04 11:25:48", updated_at: "2014-09-04 11:25:48">]> 

मुझे उम्मीद है कि यह मदद करता है।