数据校验

validator

class DataValidator(object):
    def __init__(self, values, validators, force=False, callback=None):
        self.values = values
        self.validators = validators
        self.callback = callback
        self.force = force

    def check(self):
        values = self.values.copy()
        for k, v in self.validators.items():
            # 只验证validators中有的
            # 得到要验证的值
            value = self.get_value(k)
            validator = self.get_validator(k)
            if not validator(value):
                callback = self.get_callback(validator, k)
                return callback()
            if self.force:
                values[k] = validator.value
        return values

    def get_value(self, key):
        value = self.values.get(key)
        return value

    def get_validator(self, key):
        validator = self.validators.get(key)
        return validator

    def get_callback(self, validator, key):
        callback = validator.callback or self.callback
        if callback is not None:
            return callback
        return lambda: '{0} validator error'.format(key)


class Validator(object):
    def __init__(self, **kwargs):
        callback = kwargs.get('callback')
        self.callback = callback
        self.kwargs = kwargs

    @property
    def value(self):
        return self.to_value


class DataTime(Validator):
    def __call__(self, value):
        format = self.kwargs.pop('format', '%Y-%m-%d %H:%M:%S')
        start = self.kwargs.pop('start', None)
        end = self.kwargs.pop('end', None)
        try:
            self.to_value = datetime.strptime(value, format)
        except ValueError:
            return False
        if (start is not None) and (start > self.value):
            return False
        if (end is not None) and (end < self.value):
            return False
        return True


class Integer(Validator):
    def __call__(self, value):
        min = self.kwargs.pop('min', None)
        max = self.kwargs.pop('max', None)
        try:
            self.to_value = int(value)
        except ValueError:
            return False
        except TypeError:
            return False
        if (min is not None) and (min > self.value):
            return False
        if (max is not None) and (max < self.value):
            return False
        return True


class String(Validator):
    def __call__(self, value):
        self.to_value = str(value)
        if not isinstance(value, (str, )):
            return False
        return True

    @property
    def value(self):
        return self.to_value


class Length(Validator):
    def __call__(self, value):
        min = self.kwargs.pop('min', None)
        max = self.kwargs.pop('max', None)
        self.to_value = value
        if (min is not None) and (min > len(value)):
            return False
        if (max is not None) and (max < len(value)):
            return False
        return True


class Require(Validator):
    def __call__(self, value):
        self.to_value = value
        if not value:
            return False
        return True


class And(Validator):
    def __init__(self, *args):
        self.args = args

    def __call__(self, value):
        for arg in self.args:
            self.callback = arg.callback
            if not arg(value):
                return False
            self.to_value = arg.value
        return True


class Or(And):
    def __call__(self, value):
        for arg in self.args:
            if arg(value):
                self.to_value = arg.value
                return True
            self.callback = arg.callback
        return False