ruby on rails has_many में रिकॉर्ड कैसे जोड़ें: रेल में एसोसिएशन के माध्यम से




ruby-on-rails activerecord (3)

class Agents << ActiveRecord::Base
  belongs_to :customer
  belongs_to :house
end

class Customer << ActiveRecord::Base
  has_many :agents
  has_many :houses, through: :agents
end

class House << ActiveRecord::Base
  has_many :agents
  has_many :customers, through: :agents
end

मैं Customer लिए Agents मॉडल में कैसे जोड़ूं?

क्या यह सबसे अच्छा तरीका है?

Customer.find(1).agents.create(customer_id: 1, house_id: 1)

उपर्युक्त कंसोल से ठीक काम करता है, हालांकि, मुझे नहीं पता कि वास्तविक एप्लिकेशन में इसे कैसे प्राप्त किया जाए।

कल्पना करें कि ग्राहक के लिए एक फॉर्म भर गया है जो इनपुट के रूप में house_id भी लेता है। तो क्या मैं अपने नियंत्रक में निम्नलिखित करता हूं?

def create 
  @customer = Customer.new(params[:customer])
  @customer.agents.create(customer_id: @customer.id, house_id: params[:house_id])
  @customer.save
end

कुल मिलाकर मैं उलझन में हूं कि has_many :through में रिकॉर्ड कैसे जोड़ना है has_many :through तालिका के has_many :through ?


'सबसे अच्छा तरीका' आपकी आवश्यकताओं पर निर्भर करता है और सबसे अधिक आरामदायक महसूस करता है। उलझन में ActiveRecord के व्यवहार के अंतर और विधियों और << ऑपरेटर के अंतर से आता है।

new तरीका

new लिए एक एसोसिएशन रिकॉर्ड नहीं जोड़ देगा। आपको House और Agent खुद को रिकॉर्ड करना होगा:

house = @cust.houses.new(params[:house])
house.save
agent = Agent(customer_id: @cust.id, house_id: house.id)
agent.save

ध्यान दें कि @cust.houses.new और House.new प्रभावी रूप से वही हैं क्योंकि आपको दोनों मामलों में Agent रिकॉर्ड बनाने की आवश्यकता है।

<< ऑपरेटर

जैसा कि मिशा का उल्लेख है, आप संग्रह पर << ऑपरेटर का भी उपयोग कर सकते हैं। यह केवल आपके लिए Agent मॉडल का निर्माण करेगा, आपको House मॉडल बनाना होगा:

house = House.create(params[:house])
@cust.houses << house
agent = @cust.houses.find(house.id)

create विधि

निर्माण आपके लिए House और Agent दोनों रिकॉर्ड create , लेकिन अगर आप इसे अपने दृश्य या एपीआई में वापस लौटने का इरादा रखते हैं तो आपको Agent मॉडल ढूंढना होगा:

house = @cust.houses.create(params[:house])
agent = @cust.agents.where(house: house.id).first

एक अंतिम नोट के रूप में, यदि आप house बनाने के दौरान उठाए जाने के अपवाद चाहते हैं तो इसके बजाय बैंग ऑपरेटरों का उपयोग करें (उदाहरण के लिए new! और create! )।


संघों को जोड़ने का एक और तरीका विदेशी कुंजी कॉलम का उपयोग करना है:

agent = Agent.new(...)
agent.house = House.find(...)
agent.customer = Customer.find(...)
agent.save

या रिकॉर्ड के बजाय संबंधित रिकॉर्ड की आईडी उत्तीर्ण, सटीक कॉलम नामों का उपयोग करें।

agent.house_id = house.id
agent.customer_id = customer.id

मुझे लगता है कि आप बस यह कर सकते हैं:

 @cust = Customer.new(params[:customer])
 @cust.houses << House.find(params[:house_id])

या जब ग्राहक के लिए नया घर बनाते हैं:

 @cust = Customer.new(params[:customer])
 @cust.houses.create(params[:house])




has-many-through