रिकर्सिव/पेड़ मजबूत पैरामीटर की तरह?

Question

क्या रेल 4 में वृक्ष संरचनाओं के लिए मनमाने ढंग से गहरे मजबूत मानकों को निर्दिष्ट करने का कोई तरीका है? उदाहरण के लिए, मैं कैसे कुछ इस प्रकार निर्दिष्ट करना होगा:

{ 
    "node": { 
    "name": "parent", 
    "nodes": [ 
     { "name": "child1", "nodes": []}, 
     { "name": "child2", "nodes": [ 
     {"name": "grandchild", "nodes": []} 
     ]} 
    ] 
    } 
} 

प्रत्येक नोड एक नाम विशेषता है करने के लिए अनुमति देने के लिए, और एक नोड्स विशेषता?

Answer 1

मजबूत पैरामीटर के साथ यह संभव नहीं है। इसके लिए आपको सादे रूबी का उपयोग करना चाहिए, यानी अपने पैरा को to_hash के साथ हैश में परिवर्तित करना और प्रारूप को स्वयं सत्यापित करना।

Answer 2

इसे हल करने के लिए एक क्लीनर समाधान हो सकता है लेकिन यह मेरा वर्तमान काम है। सामान्य विचार यह है कि मेरी घोंसले कितनी गहरी हो जाती है और फिर ऑटो उस संख्या के आधार पर सही नेस्टेड हैश उत्पन्न करता है। तो अपने उदाहरण का अनुसरण करने:

def count_levels(node_params) 
    if !node_params[:nodes].nil? 
    max = 0 
    node_params[:node_parameters].each do |child_params| 
     count = count_levels(child_params[1]) 
     max = count if count > max 
    end 
    return max + 1 
    else 
    return 0 
    end 
end 

def node_params 
    node_attributes_base = [:id, :name] 
    nodes = [] 
    (1..count_levels(params[:node])).each do |val| 
    nodes = node_attributes_base + [node_attributes: nodes] 
    end 
    params.require(:node).permit(:id, :name, node_attributes: nodes) 
end 

(ऊपर के उदाहरण साफ किया जा सकता और अधिक जहां शीर्ष स्तर समान पैरामीटर नहीं था, क्योंकि यह मेरे कोड पर आधारित है मैं इसे छोड़ दिया के रूप में मैं यह था के बाद से यह पर काम किया। अपने सिस्टम।)

Answer 3

आप तथ्य यह है कि अनुमति स्तर की संख्या, स्तरों आप वास्तव में जरूरत से ज्यादा हो सकता है तो आप अपने हैश और उपयोग में पुनरावर्ती कुंजी nodes कुंजी की घटना भरोसा कर सकते हैं पर निर्भर करता है के द्वारा हल कर सकते हैं यह स्तर की संख्या के रूप में गिनती है।

ध्यान दें कि यह गिनती स्तरों आप वास्तव में जरूरत से अधिक हो जाएगा, लेकिन यह आसान है की तुलना में रिकर्सिवली अपने नियंत्रक में हैश में स्तरों की संख्या की गणना

तो आप निम्न कर सकते हैं:

# your_controller.rb 
# include RecursiveParametersBuilder 
recursive_nodes_attr = build_recursive_params(
    recursive_key: 'nodes', 
    parameters: params, 
    permitted_attributes: [:name] 
) 
params.require(:model_name).permit(:name, nodes: recursive_nodes_attr) 

और कोड बनाने के वास्तविक मजबूत पैरामीटर निम्नलिखित

# helper module 
module RecursiveParametersBuilder 
    # recursive_path = [:post] 
    # recursive_key = :comment_attributes 
    # recursive_node_permitted_params = [:id, :_destroy, :parameterized_type, :parameterized_id, :name, :value, :is_encrypted, :base_param_id, :parent_param_id] 
    # 
    def build_recursive_params(recursive_key:, parameters:, permitted_attributes:) 
    template = { recursive_key => permitted_attributes } 

    nested_permit_list = template.deep_dup 
    current_node = nested_permit_list[recursive_key] 

    nested_count = parameters.to_s.scan(/#{recursive_key}/).count 
    (1..nested_count).each do |i| 
     new_element = template.deep_dup 
     current_node << new_element 
     current_node = new_element[recursive_key] 
    end 
    nested_permit_list 
    end 
end