Question

给出架构，将验证错误附加到一个 Validator（）在以下条件下：

item_a 的值会提高对 item_c
item_a 的值是否需要提高 item_b 的价值，或者此类型的字符串更改为整数。
根据 item_a 的特定值显示 item_c 和 item_b 的错误，而不是显示依赖性的总可能性。
考虑 item_d 是每个 subitem_d
避免警告自定义方法（尚未实现）

schema_base = {
    'item_a': {
        'type': 'string',
        'allowed': ['value_x','value_y', 'value_z'],
        'required': True
    },
    'item_b':{},
    'item_c':{},
    'item_d':  {
        'type': ['list','string'],
        'required': True,
        'regex': '^[0-9a-f]{8}$',
        'schema':{
            'regex': '^[0-9a-f]{8}$',
            'type': 'string'
        }
    }
}

#......

#the folowing code, is a possible implemententation of the problem

schema_x = {
    'item_a': {
        'type':'string',
        'check_value_on_new_schema': { 
            'allowed': ['value_x','value_y', 'value_z'],
            'value_x': { 
                'item_b': {
                    'type': 'string',
                    'required':True,
                    'allowed': ['value_wrst']
                },
                'item_c':{
                    'type': 'dict',
                    'schema': {
                        'propertie_1':{
                            'type':'string',
                            'required':True
                        }
                    }
                }
            },
            'value_y':{
                'item_b': {
                    'type': 'integer',
                    'allowed': [5,7,9]
                },
                'item_c':{
                    'type': 'dict',
                    'schema': {
                        'propertie_hk':{
                            'type':'string',
                            'required':True
                        }
                    }
                }
            },
            'value_z':{
                'item_b':{},
                'item_c':{}
            }
        }
    },
    'item_b':{},
    'item_c':{},
    'item_d': {
        'type': ['list','string'],
        'required': True,
        'regex': '^[0-9a-f]{8}$',
        'schema':{
            'regex': '^[0-9a-f]{8}$',
            'type': 'string'
        }
    }
}

from cerberus import Validator

class ExtendedErrorsValidator(Validator):
    @property
    def errorsx(self):
        return self._errors

class ExtendedValidator(Validator):

    def _validate_check_value_on_new_schema(self, rulesx, field, _value):
        eev = ExtendedErrorsValidator()
        eev.allow_unknown=True
        if _value not in rulesx['allowed']:
            return self._error( field, "values must be one of permited "+str(rulesx['allowed']))
        else:
            if not eev.validate(self.document,rulesx[_value]):
                return self._error(eev.errorsx)


v = ExtendedValidator()
v.allow_unknown = True


data_x = {
    'item_a': 'value_x',
    'item_c':{}
}


if not v.validate(data_x, schema_x):
    print(v.errors)

# expected and result output
# {'item_b': ['required field'], 'item_c': [{'propertie_1': ['required field']}], 'item_d': ['required field']}


data_y = {
    'item_a': 'value_y',
    'item_c':{}
}

if not v.validate(data_y, schema_x):
    print(v.errors)

# expected and result output
# {'item_c': [{'propertie_hk': ['required field']}], 'item_d': ['required field']}


data_z = {
    'item_a': 'value_z',
    'item_c':{}
}

if not v.validate(data_z, schema_x):
    print(v.errors)

# expected and result output
# {'item_d': ['required field']}

有更好的方法做到这一点

0 个答案: