0

我有一种情况，我需要再次验证 json json 模式，具体取决于其中一个属性中的值，在 json 模式术语中，enum 属性

这是json

 { 
  "req":
   {
   user:"",
   company:"",
   dept:"",
   class:""
   reqType:"account"     
   }
 }

reqType 可以采用不同的值，例如 account、dept 和 classes，基于应该需要的字段之一

我曾尝试使用 anyOf 相同但它不能正确验证 ex - 我尝试过以下模式

            {
                "$id": "http://example.com/example.json",
                "type": "object",
                "definitions":
                {},
                "$schema": "http://json-schema.org/draft-07/schema#",
                "properties":
                {
                    "req":
                    {
                        "$id": "/properties/req",
                        "type": "object",
                        "properties":
                        {
                            "user":
                            {
                                "$id": "/properties/req/properties/user",
                                "type": "string",
                                "title": "The User Schema ",
                                "default": "",
                                "examples": [
                                    "a"
                                ]
                            },
                            "company":
                            {
                                "$id": "/properties/req/properties/company",
                                "type": "string",
                                "title": "The Company Schema ",
                                "default": "",
                                "examples": [
                                    "b"
                                ]
                            },
                            "dept":
                            {
                                "$id": "/properties/req/properties/dept",
                                "type": "string",
                                "title": "The Dept Schema ",
                                "default": "",
                                "examples": [
                                    "c"
                                ]
                            },
                            "class":
                            {
                                "$id": "/properties/req/properties/class",
                                "type": "string",
                                "title": "The Class Schema ",
                                "default": "",
                                "examples": [
                                    "d"
                                ]
                            },
                            "reqType":
                            {
                                "$id": "/properties/req/properties/reqType",
                                "type": "string",
                                "title": "The Reqtype Schema ",
                                "default": "",
                                "examples": [
                                    "account"
                                ],
                                "enum": [
                                    "account", "dept", "class"
                                ]
                            }
                        },
                        "required": [
                            "reqType"
                        ],
                        "anyOf": [
                        {

                            "properties":
                            {
                                "reqType":
                                {
                                    "enum": ["account"]
                                }
                            },
                            "required": ["user", "company"]
                        },
                        {
                            "properties":
                            {
                                "reqType":
                                {
                                    "enum": ["dept"]
                                }
                            },
                            "required": ["dept"]
                        }]
                    }
                },
                "required": [
                    "req"
                ]
            }

当它满足所有条件时，这似乎工作正常，但是当我检查其中一种情况失败时，它会给我一个错误，如下所示

            [ { keyword: 'required',
                dataPath: '.req',
                schemaPath: '#/properties/req/anyOf/0/required',
                params: { missingProperty: 'user' },
                message: 'should have required property \'user\'',
                schema: [ 'user', 'company' ],
                parentSchema: { properties: [Object], required: [Array] },
                data: { company: 'b', dept: 'c', class: 'd', reqType: 'account' } },
              { keyword: 'enum',
                dataPath: '.req.reqType',
                schemaPath: '#/properties/req/anyOf/1/properties/reqType/enum',
                params: { allowedValues: [Array] },
                message: 'should be equal to one of the allowed values',
                schema: [ 'dept' ],
                parentSchema: { enum: [Array] },
                data: 'account' },
              { keyword: 'anyOf',
                dataPath: '.req',
                schemaPath: '#/properties/req/anyOf',
                params: {},
                message: 'should match some schema in anyOf',
                schema: [ [Object], [Object] ],
                parentSchema:
                 { '$id': '/properties/req',
                   type: 'object',
                   properties: [Object],
                   required: [Array],
                   anyOf: [Array] },
                data: { company: 'b', dept: 'c', class: 'd', reqType: 'account' } } ]

它应该只给出第一个错误，应该验证第二种情况，而不是它说它没有得到枚举值，我在这里做错了吗

4

1 回答 1

2

你做对了。关键字表示一个或多个给anyOf定模式必须有效。

它检查第一个并发现enum关键字通过，但required关键字失败。因此，此架构失败。

因此，它移动到下一个模式并发现enum关键字失败并且required关键字通过。因此，此架构也失败了。

anyOf没有找到有效的模式，所以它失败并报告两个模式都没有通过验证。

你看，anyOf不知道enum在这个模式中有什么特殊含义。两种模式都有一个关键字通过，一个关键字失败。，anyOf它们是相同的。

这是一种替代方法，可以为您提供更好的错误消息。错误消息最终仍然非常神秘，但它们集中在问题的真正所在。

{
  "type": "object",
  "properties": {
    "req": {
      "type": "object",
      "properties": {
        "reqType": { "enum": ["account", "dept", "class"] }
      },
      "required": ["reqType"],
      "allOf": [
        {
          "anyOf": [
            {
              "not": {
                "properties": {
                  "reqType": { "enum": ["account"] }
                }
              }
            },
            { "required": ["user", "company"] }
          ]
        },
        {
          "anyOf": [
            {
              "not": {
                "properties": {
                  "reqType": { "enum": ["dept"] }
                }
              }
            },
            { "required": ["dept"] }
          ]
        }
      ]
    }
  },
  "required": ["req"]
}
于 2018-06-26T01:53:18.580 回答