मैं स्कीमा के सशर्त सत्यापन को व्यक्त करना चाहता हूं जिसमें क्रॉस कुंजी स्थितियां हैं। क्या JSON स्कीमा में उपलब्ध सशर्त कीवर्ड के साथ इसके लिए कोई समर्थन है ( allOf/anyOf/if/then/else)

JSON स्कीमा:

{
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "x": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "value": {
                    "type": "string"
                }
            }
        },
        "y": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "key1": {
                    "type": "string",
                    "enum": ["a", "b", "c", "d", "e"]
                },
                "key2": {
                    "type": "string",
                    "enum": ["x", "y", "m", "n", "r", "s"]
                }
            },
            "anyOf": [{
                    "allOf": [{
                            "if": {
                                "properties": {
                                    "key1": {
                                        "enum": ["a", "b"]
                                    }
                                }
                            },
                            "then": {
                                "properties": {
                                    "key2": {
                                        "enum": ["x", "y"]
                                    }
                                }
                            }
                        },
                        {
                            "if": {
                                "x": {
                                    "properties": {
                                        "value": {
                                            "const": "myVal"
                                        }
                                    }
                                }
                            },
                            "then": {
                                "properties": {
                                    "key2": {
                                        "enum": ["x", "y"]
                                    }
                                }
                            }
                        }
                    ]
                },
                {
                    "if": {
                        "properties": {
                            "key1": {
                                "enum": ["c", "d"]
                            }
                        }
                    },
                    "then": {
                        "properties": {
                            "key2": {
                                "type": "string",
                                "enum": ["m", "n"]
                            }
                        }
                    }
                }
            ]
        }
    }
}

नमूना JSON उदाहरण इस तरह दिखेगा

{
    "x": {
        "value": "myVal"
    },
    "y": {
        "key1": "a",
        "key2": "x"
    }
}

मैं जो शर्त व्यक्त करना चाहता हूं वह निम्नलिखित 2 शर्तें हैं

  1. यदि (x.value == "myVal" और (y.key1 == "a" या y.key1 == "b") तब y.key2 ही चाहिए "x" या "y" है
    (या)

  2. यदि ( y.key1 == "c" या y.key1 == "d") तब y.key2 में केवल "m" या "n" होना चाहिए।

    (या)

  3. y.key2 y.key2 संपत्ति में परिभाषित किसी भी अनुमत एनम मान को ले सकता है।

सशर्त मैंने JSON स्कीमा का उपयोग किया है काम नहीं करता है। मैंने https://www.jsonschemavalidator.net/ का उपयोग करके सत्यापन करने का प्रयास किया।

किसी भी मदद की गहराई से सराहना की जाएगी :)

धन्यवाद

3
shyam0191 30 जिंदा 2020, 14:22

1 उत्तर

सबसे बढ़िया उत्तर

इसलिए मुझे लगता है कि यह उन मामलों में से एक है जहां if/then/else कीवर्ड को भूल जाना बेहतर है और केवल oneOf में अच्छे राज्यों को परिभाषित करें। (मैं anyOf के बजाय oneOf का सुझाव देता हूं क्योंकि इनमें से बिल्कुल एक का मिलान होना चाहिए।)

तो आपकी स्कीमा के लिए, आप एक चाहते हैं

  1. के सभी
    • x.value == "myVal"
    • y.key1 in ["a", "b"]
    • y.key2 in ["x", "y"]
  2. के सभी
    • y.key1 in ["c", "d"]
    • y.key2 in ["m", "n"]
  3. के सभी
    • नहीं <उल>
    • एक <उल>
    • सभी के <उल>
    • x.value == "myVal"
    • y.key1 in ["a", "b"]
  4. y.key1 in ["c", "d"]
  5. true (या {} अगर आप प्री-ड्राफ्ट-6) हैं

ऐसा लगता है कि आपने #1 और #2 पर काम कर लिया है; बस सशर्त तर्क छोड़ दो। यह #3 में नहीं है जो काम करता है। यहां हम कह रहे हैं कि अगर #1 के लिए कंडीशन गलत है और तो #2 के लिए कंडीशन गलत है, तो y.key2 के लिए एनम में पहले से परिभाषित कोई भी वैल्यू ठीक है।

हमें स्पष्ट रूप से यह व्यक्त करने का कारण है कि हम # 1 और # 2 के लिए शर्तें नहीं चाहते हैं कि उनके बिना, हमारे पास केवल एक true स्कीमा है, जो सब कुछ की अनुमति देता है (जो पहले प्रतिबंधित नहीं है)।

अब यहां दूसरा गोचा यह है कि आपके पास x का उपयोग आपकी किसी एक स्थिति में किया जा रहा है, लेकिन आपकी anyOf उपयोजना y की परिभाषा के अंतर्गत है, इसलिए यह x बिलकुल। इसे ठीक करने के लिए, आप उस उपस्कीमा को एक सहोदर के रूप में properties पर ले जाना चाहेंगे। यहां यह संपूर्ण उदाहरण देख सकता है, न कि केवल y गुण में मान।

3
gregsdennis 31 जिंदा 2020, 14:18