JSON tv4 object valid if true and if other object is present

Question

is possible to validate JSON, if value of object is true, then this object is valid, and if Obj2.included == true is valid, if Obj1.included == true ?

This is small piece of schema:

'attachments': {
                    'type': 'object',
                    'properties': {
                        'ZalA': {
                            'type': 'object',
                            'properties': {
                                'included': {
                                    'type': 'boolean'
                                },
                                'version': {
                                    'type': 'integer'
                                }
                            },
                            'required': [
                                'included',
                                'version'
                            ]
                        },
                        'ZalB': {
                            'type': 'object',
                            'properties': {
                                'version': {
                                    'type': 'integer'
                                },
                                'included': {
                                    'type': 'boolean'
                                },
                                'required': [
                                    'included',
                                    'version'
                                ]
                            }
                        }
                    }
                }

I would like to check:

if ZalA.included == true, then valid.
if ZalA.included == true and ZalB.included == true, then valid.
if ZalA.included == false and ZalB.included == true, then invalid.

Is it possible to check these constraints with tv4 JSON validator ?

This object-properties checking is build-in to TV4, or should I make my own function - let's name it 2nd validation level - to check values of these attachments and set valid if (attachment.ZalA.included == true and (attachment.ZalB.included == true || false) ) ? My schema is work, but I should add constraints - if ZalA is not included - then you can't include ZalB. — InnerWorld, Feb 02 '15 at 12:34

Blauharley · Accepted Answer · 2015-02-03T17:28:14.483

I've got a solution for you. But first of all you had a little mistake in your schema, because of required-property that was within properties:

'ZalB': {
            'type': 'object',
            'properties': {
                     'version': {
                         'type': 'integer'
                     },
                     'included': {
                         'type': 'boolean'
                     },
                     'required': [
                         'included',
                         'version'
                     ]
             }
 }

When you use it you have to define it outside before or after properties. As you have done this with ZalA :) otherwise it does not work.

Now to your answer, I did a little experiment with this very interesting validator and came up with this:

// schema to be used for validating
var schema = {
  'type': 'object',
  'properties': {
    'ZalA': {
      'type': 'object',
      'properties': {
        'included': {
          'type': 'boolean',
          'enum': [
            true
          ]
        },
        'version': {
          'type': 'integer'
        }
      },
      'required': [
        'included',
        'version'
      ]
    },
    'ZalB': {
      'type': 'object',
      'properties': {
        'version': {
          'type': 'integer'
        },
        'included': {
          'type': 'boolean',
          'enum': [
            true
          ]
        }
      },
      'required': [
        'included',
        'version'
      ]
    },
    'required': [
      'ZalA'
    ],
  }
};

// data to be checked against
var data = {
  'ZalA': {
    'version': 1,
    'included': true
  },
  'ZalB': {
    'version': 2,
    'included': true
  }
}

tv4.validateResult(data, schema); // Object { missing=[0], valid=true, error=null}

Schema has to be configured so that it matches your check-list:

if ZalA.included == true, then valid.
```
'required': [
  'ZalA'
],
```
Requires ZalA at the end of schema after properties so that ZalA has to be present, so you can repeat this option as often as you want in each level. But this is not enougth to fulfill your check-list. Next configurations are:
```
'required': [
    'included',
    'version'
]
```
plus
```
'included': {
  'type': 'boolean',
  'enum': [true]
},
```
included-property (and actually version-property as well, it was already in your question) of ZalA must be present and true so that ZalA can be considered valid. You can define an array of different types to check whether the property has a certain value or you can use pattern-option.

These configurations are applied for ZalB too but with one difference:

'required': [
   'ZalA'
],

Only ZalA is required and not ZalB at the end.

And we are done! With these configurations all your next conditions are fulfilled:

if ZalA.included == true and ZalB.included == true, then valid.
if ZalA.included == false and ZalB.included == true, then invalid.

And if ZalB.included is granted to be false as well as true then just do this:

 'enum': [
      true, false
 ]

Or omit enum-option completely so that it must be a boolean on the first place.

This is really a good validator. Thanks for your question, I'll use it for furture projects.

P.S. You may can spare yourself to define a second schema for ZalB and just referencing(using $ref) to the schema for ZalA, but I did not test this. On the other hand you could use this little schema:

var schema = {
  'type': 'object',
  'properties': {
    'included': {
      'type': 'boolean',
      'enum': [
        true
      ]
    },
    'version': {
      'type': 'integer'
    }
  },
  'required': [
    'included',
    'version'
  ]
};

And use it in this way:

// a bundle of objects to be checked
var data = [{
    'version': 1,
    'included': true
},{
    'version': 2,
    'included': true
}];

// iterate through each object
for(var i=0; i < data.length;i++){

    var obj = data[i];

    // validate each object
    var result = tv4.validateResult(obj, schema);

    if(!result.valid){
      console.log("not valid: ",result.error);
    }

}

I just speak for myself but for me this is the most important side of the validator-documentation. Because it contains all options you can define for certain properties to be valided:

http://json-schema.org/latest/json-schema-validation.html

It means, that I should use my own function, runned independently with tv4 validation ? There is not any JSON v4 schema options, that could help me check these dependences ? — InnerWorld, Feb 02 '15 at 21:35
Sorry, you can. Hindsight is easier than foresight. I read the doc. — Blauharley, Feb 03 '15 at 17:18
Thank you. I haven't noticed, that I make mistake in schema. About enum in ZalA - I found this solution, but I had no idea how to check the second condition. — InnerWorld, Feb 05 '15 at 13:30

JSON tv4 object valid if true and if other object is present

1 Answers1

Linked