रेल समेकित प्रकार या विकल्प

Question

मैं सिर्फ रेल पर रूबी सीख रहा हूं और मेरे पास उपयोगकर्ता भूमिकाओं (मालिक, व्यवस्थापक और उपयोगकर्ता) की एक तालिका है। कोड में ऐसे स्थान होने जा रहे हैं जहां मुझे उपयोगकर्ता की भूमिका की जांच करने और विभिन्न विकल्पों को दिखाने की आवश्यकता है। क्या किसी को पता है कि जादू संख्या या अन्य बदसूरत तरीकों का उपयोग किये बिना इसे कैसे किया जाए?

public enum UserRole { Owner = 1, Admin = 2, User = 3 } 

// ... 

if (user.Role == UserRole.Admin) 
    // Show special admin options 

डेटाबेस में प्रत्येक अलग भूमिका एक मूल्य के साथ एक enumerated प्रकार के रूप में देखा जा सकता है:

ASP.Net वेब क्षुधा में मैं मैं पर काम किया है इस प्रगणित प्रकार के उपयोग के माध्यम से किया देखा है डेटाबेस में उस भूमिका की आईडी पर सेट करें। यह एक बहुत अच्छा समाधान की तरह प्रतीत नहीं होता है क्योंकि यह डेटाबेस के ज्ञान पर निर्भर करता है जो बदल सकता है। यहां तक ​​कि अगर ऐसा कुछ संभालने का उचित तरीका है, तो मुझे नहीं पता कि रेल में गणना किए गए प्रकारों का उपयोग कैसे करें।

मैं इस मामले में किसी अंतर्दृष्टि की सराहना करता हूं।

Answer 1

रूबी अपने आप में एक प्रगणित प्रकार नहीं है, लेकिन इस साइट के लिए एक विधि से पता चलता http://www.rubyfleebie.com/enumerations-and-ruby/

आप अपने उपयोगकर्ता मॉडल में कुछ इस तरह बना सकते हैं:

#constants 
OWNER = 1 
ADMIN = 2 
USER = 3 

def is_owner? 
    self.role == OWNER 
end 

def is_admin? 
    self.role == ADMIN 
end 

def is_user? 
    self.role == USER 
end 

Answer 2

मैं उपयोग करने के लिए जिसे उपयुक्त Authorization नामित पसंद करते हैं इस तरह की स्थितियों के लिए प्लगइन।

यह आपको

permit "role" 

भूमिकाओं के लिए उपयोग को प्रतिबंधित करने के हैं, और

permit? "role" 

बस पहुंच के लिए परीक्षण होगा। इन दोनों प्रतिनिधियों को User#has_role?(role) पर।

ऐसा महसूस न करें कि आपको उनके ObjectRoles कार्यान्वयन का उपयोग करना है। आप Hardwired भूमिकाओं का उपयोग कर सकते हैं और फिर अपनी मौजूदा स्कीमा का उपयोग करने के लिए अपनी खुद की User#has_role?(role) विधि लागू कर सकते हैं।

Answer 3

वहाँ ताकि आप कर rubyforge पर एक enum plugin है:

t.column :severity, :enum, :limit => [:low, :medium, :high, :critical] 

यह :limit विशेषता का उपयोग करने पैरामीटर पास करने के लिए बहुत बदसूरत है, लेकिन यह एक अधिक मानकीकृत तरीका है।

सिर्फ स्थापित करने के लिए कार्य करें:

script/plugin install svn://rubyforge.org/var/svn/enum-column/plugins/enum-column 

यह currenctly रेल 2.2.2 या बाद में साथ काम करता है। रूबीफोर्ज लिंक: www.rubyforge.org/projects/enum-column/

Answer 4

यह मेरे classy_enum मणि का उपयोग करने के लिए वास्तव में एक अच्छा मामला लगता है। यह अनिवार्य रूप से आपको विकल्पों के एक निश्चित सेट को परिभाषित करने की अनुमति देता है, जहां प्रत्येक व्यक्ति एक वर्ग है जिसमें व्यवहार और गुण विशिष्ट हैं। यह सभी सशर्त तर्कों को कम करने में मदद करता है जो पूरे आवेदन में बिखरे हुए होते हैं।

उदाहरण के लिए

, तो आप इस तरह की बातें कर रहे हैं:

class User < ActiveRecord::Base 
    def options 
    if user.is_admin? 
     [...admin options...] 
    else 
     [...non admin options...] 
    end 
    end 
end 

तब के रूप में बुला: कहीं और user.options ...

class User < ActiveRecord::Base 
    classy_enum_attr :role 

    delegate :options, :to => :role 
end 

README एक काम उदाहरण है और विस्तार से मणि वर्णन करता है:

classy_enum तो आपको एक अलग जगह पर उस तर्क के लिए कदम और कोई सशर्त तर्क के साथ ही कार्यक्षमता है करने के लिए अनुमति देता है।

Answer 5

बस रेल (सी # से) सीखना शुरू कर दिया, और यह वही सवाल था। ऐसा लगता है कि रेलों में वास्तव में enums नहीं है क्योंकि दर्शन अलग है। मैं सी # प्रोजेक्ट में सभी विवरण व्यवस्थित करने की कोशिश करने के लिए कई enums का उपयोग करता हूं, लेकिन शायद रेल आपके लिए इतना संभालती है कि वे महत्वपूर्ण नहीं हैं। यह वास्तव में एक जवाब नहीं है, सिर्फ एक अवलोकन है।

Answer 6

क्या रेलवे 4.1 में कार्यक्षमता जोड़ा गया है, जो आप खोज रहे हैं? ब्लॉग पोस्ट से

http://coherence.io/blog/2013/12/17/whats-new-in-rails-4-1.html

कॉपी:

class Bug < ActiveRecord::Base 
    # Relevant schema change looks like this: 
    # 
    # create_table :bugs do |t| 
    # t.column :status, :integer, default: 0 # defaults to the first value (i.e. :unverified) 
    # end 

    enum status: [ :unverified, :confirmed, :assigned, :in_progress, :resolved, :rejected, :reopened ] 

... 

Bug.resolved   # => a scope to find all resolved bugs 
bug.resolved?   # => check if bug has the status resolved 
bug.resolved!   # => update! the bug with status set to resolved 
bug.status    # => a string describing the bug's status 
bug.status = :resolved # => set the bug's status to resolved