रेल मुहावरा has_many में डुप्लिकेट से बचने के लिए:

Question

के माध्यम से मैं एक मानक है, जिनमें कई करने वाली कई उपयोगकर्ताओं और मेरे रेल अनुप्रयोग में भूमिकाओं के बीच के रिश्ते:

class User < ActiveRecord::Base 
    has_many :user_roles 
    has_many :roles, :through => :user_roles 
end 

मुझे लगता है कि यदि कोई उपयोगकर्ता केवल सौंपा जा सकता है यह सुनिश्चित करना चाहते एक बार कोई भूमिका। डुप्लिकेट डालने का कोई भी प्रयास अनुरोध को अनदेखा करना चाहिए, त्रुटि फेंकना या सत्यापन विफलता का कारण नहीं होना चाहिए। जो मैं वास्तव में प्रस्तुत करना चाहता हूं वह एक "सेट" है, जहां सेट में पहले से मौजूद तत्व को सम्मिलित करना कोई प्रभाव नहीं पड़ता है। {1,2,3} यू {1} = {1,2,3}, {1,1,2,3} नहीं।

मुझे लगता है कि मैं इसे इस तरह कर सकते हैं:

user.roles << role unless user.roles.include?(role) 

या एक आवरण विधि (जैसे add_to_roles(role)) बनाने के द्वारा, लेकिन मैं कुछ मुहावरेदार जिस तरह से यह संघ के माध्यम से स्वत: बनाने के लिए के लिए उम्मीद की गई थी, ताकि मैं लिख सकता हूं:

user.roles << role # automatically checks roles.include? 

और यह मेरे लिए काम करता है। इस तरह, मुझे डुप्लिकेट की जांच करने या कस्टम विधि का उपयोग करने के लिए याद रखना नहीं है। क्या ढीले ढांचे में कुछ है जो मुझे याद आ रही है? मैंने पहले सोचा था कि: uniq विकल्प है_मैनी ऐसा करेगा, लेकिन यह मूल रूप से बस "विशिष्ट चुनें"।

क्या यह घोषणा करने का कोई तरीका है? यदि नहीं, तो शायद एक एसोसिएशन एक्सटेंशन का उपयोग कर?

 >> u = User.create 
     User Create (0.6ms) INSERT INTO "users" ("name") VALUES(NULL) 
    => #<User id: 3, name: nil> 
    >> u.roles << Role.first 
     Role Load (0.5ms) SELECT * FROM "roles" LIMIT 1 
     UserRole Create (0.5ms) INSERT INTO "user_roles" ("role_id", "user_id") VALUES(1, 3) 
     Role Load (0.4ms) SELECT "roles".* FROM "roles" INNER JOIN "user_roles" ON "roles".id = "user_roles".role_id WHERE (("user_roles".user_id = 3)) 
    => [#<Role id: 1, name: "1">] 
    >> u.roles << Role.first 
     Role Load (0.4ms) SELECT * FROM "roles" LIMIT 1 
     UserRole Create (0.5ms) INSERT INTO "user_roles" ("role_id", "user_id") VALUES(1, 3) 
    => [#<Role id: 1, name: "1">, #<Role id: 1, name: "1">]

Answer 1

जब तक संलग्न भूमिका एक ActiveRecord वस्तु, तुम क्या कर रहे है:

user.roles << role 

चाहिए :has_many संघों के लिए स्वचालित रूप से डी-डुप्लिकेट।

has_many :through के लिए, कोशिश:

class User 
    has_many :roles, :through => :user_roles do 
    def <<(new_item) 
     super(Array(new_item) - proxy_association.owner.roles) 
    end 
    end 
end 

अगर सुपर काम नहीं करता है, तो आप एक alias_method_chain स्थापित करने के लिए आवश्यकता हो सकती है।

validates_uniqueness_of :user_id, :scope => [:role_id] 

Answer 2

शायद यह सत्यापन नियम

validates_uniqueness_of :user_roles 

बनाने के लिए तो सत्यापन अपवाद को पकड़ने और शान से पर ले जाने के लिए संभव है:

यहाँ कैसे डिफ़ॉल्ट व्यवहार में विफल रहता है, इसका एक उदाहरण। हालांकि, यह वास्तव में हैकी लगता है और यदि संभव हो तो बहुत ही सुरुचिपूर्ण है।

Answer 3

मुझे लगता है कि उचित सत्यापन नियम अपने users_roles में है मॉडल में शामिल होने के मॉडल में शामिल हों।

validates_uniqueness_of :user_id, :scope => [:role_id] 

class User 
    has_many :roles, :through => :user_roles do 
    def <<(*items) 
     super(items) rescue ActiveRecord::RecordInvalid 
    end 
    end 
end 

Answer 4

आप मुख्य मॉडल में validates_uniqueness_of और अधिभावी < < के संयोजन का उपयोग कर सकते हैं, हालांकि यह भी किसी अन्य मान्यता त्रुटियां पकड़ सकता है:

Answer 5

मुझे लगता है कि आप की तरह कुछ करना चाहता हूँ:

user.roles.find_or_create_by(role_id: role.id) # saves association to database 
user.roles.find_or_initialize_by(role_id: role.id) # builds association to be saved later 

Answer 6

मैं आज में पड़ गए और #replace है, जो "एक diff प्रदर्शन कर दिए जाएंगे और/केवल रिकॉर्ड बदलने के बाद कि जोड़ें" का उपयोग कर समाप्त हो गया ।

इसलिए, आप (ताकि वे हटा दिया जाता है नहीं है) मौजूदा भूमिका के लिए संघ पास करनी होगी और अपनी नई भूमिका (ओं):

new_roles = [role] 
user.roles.replace(user.roles | new_roles) 

यह है कि दोनों इस जवाब ध्यान देना महत्वपूर्ण है और स्वीकार किया गया है कि एरे diff (-) और यूनियन (|) करने के लिए स्वीकृत roles ऑब्जेक्ट्स को स्मृति में लोड कर रहे हैं। यदि आप बड़ी संख्या में संबंधित रिकॉर्ड से निपट रहे हैं तो यह प्रदर्शन समस्याओं का कारण बन सकता है।

यदि यह कोई चिंता है, तो आप उन विकल्पों को देखना चाहते हैं जो पहले प्रश्नों के माध्यम से अस्तित्व की जांच करते हैं, या डालने के लिए INSERT ON DUPLICATE KEY UPDATE (mysql) प्रकार क्वेरी का उपयोग करते हैं।