def parse_process(self, key, value):
assert key in self.PROCESSES
values = [item.strip() for item in value.split(self.value_separator)]
if not values:
raise ValidationError(
u'{0} must not empty, your value is {1}'.format(key, value))
if key == '__show':
invalid_item = set(values) - set(self.columns)
if invalid_item:
raise ValidationError(u'{0} of your __show columns {1} is not'
u' an attribute of {2} '.format(
u','.join(invalid_item), value,
self.name))
return values
elif key == '__order':
order_by_columns = []
for val in values:
if val.endswith(('.desc', '.asc')):
attr, order = val.split('.')
else:
attr, order = val, self.default_order
if attr not in self.columns:
raise ValidationError(u'{0} of your __order_by columns '
u'is not an attribute of {1}'.format(
attr, value, self.name))
order_by_columns.append(_Order(key=attr, order=order))
return order_by_columns
def parse_paginate(self, key, value):
assert key in self.PAGINATE
page_error = u'param __page must be a positive integer,' \
u'your value is {0}'.format(value)
page_size_error = u'param __page_size must be a positive ' \
u'integer between ({0}, {1}), your value is {2}'.\
format(self.min_page_size, self.max_page_size, value)
if key == '__page':
try:
page = int(value)
except ValueError:
raise ValidationError(page_error)
if page < 1:
raise ValidationError(page_error)
return page
elif key == '__page_size':
try:
page_size = int(value)
except ValueError:
raise ValidationError(page_size_error)
return max(min(page_size, self.max_page_size), self.min_page_size)
def validate_keys(table_name, columns, keys):
invalid_keys = frozenset(keys) - frozenset(columns)
if invalid_keys:
raise ValidationError(u'{0} is not attributes of {1}'.format(
u','.join(invalid_keys), table_name))
return True
def http_post(self, data):
if data.pop('id', None):
raise ValidationError(u"id can't be specified when post")
self.validate_keys(self.name, self.model.get_column_names(),
data.keys())
item = self.model(**data)
return item.save().to_dict()
def process_nonempty(self, data):
no_empty = self.validator['nonempty']
for k in no_empty:
if not data.get(k, None):
raise ValidationError(
u'param {0} required not empty'.format(k))
return True
def process_types(self, data):
types = self.validator['types']
for key, tp in types.items():
if key in data and not isinstance(data[key], tp):
raise ValidationError(u'param {0} need to be type {1}, your type is {2}'
.format(key, tp, type(data[key])))
return True
def process_required(self, data):
required = self.validator['required']
not_supply = frozenset(required) - frozenset(data.keys())
if not_supply:
raise ValidationError(
u'param %s is required' %
u','.join(not_supply))
return True
def query(self, params):
rel_name = params.pop('__relation', None)
pk = params.pop('__pk', None)
if rel_name and pk is not None:
if rel_name not in self.relations:
raise ValidationError(u'{0} is not a relation of {1}'.format(
rel_name, self.name))
return self.do_relation_query(params, rel_name, pk)
else:
return self.do_self_query(params)
def process_oneof(self, data):
oneof = self.validator['oneof']
for key, option_values in oneof.items():
if key in data and data[key] not in option_values:
raise ValidationError(u'param {0} must in {1}, your value is {2}'.format(
key, u','.join(option_values), data[key]
))
return True
def http_put(self, data):
_id = data.pop('id')
self.validate_keys(self.name, self.model.get_column_names(),
data.keys())
if not self.model.get(_id):
raise ValidationError(u'id {0} of {1} not exists'.format(
_id, self.name))
self.model.query_update(query={'id': _id}, data=data)
return self.model.get(_id).to_dict()
def process_length(self, data):
length = self.validator['length']
for key, ll in length.items():
if key not in data:
continue
val_len = len(data[key])
if val_len < ll[0] or val_len > ll[-1]:
raise ValidationError(u'param {0} length required to between {1} and {2}, '
u'your length is {3}'.format(key, ll[0], ll[-1], val_len))
return True
def parse_filter(self, key, value):
if key in self.columns:
return _Filter(key=key, op='eq', val=value)
elif key.endswith(self.OPERATORS):
key_oper = key.split(self.operator_separator)
if len(key_oper) != 2:
raise ValidationError(u'invalid filter {0} for {1}'.format(
key, self.name))
fkey, oper = key_oper
if fkey not in self.columns:
raise ValidationError(
u'filter key {0} is not an attribute of {1}'.format(
fkey, self.name))
elif oper not in self.OPERATORS:
raise ValidationError(
u'filter operation {0} is not support'.format(oper))
if oper == 'like' and not self.suffix_like and value.startswith(
'%'):
raise ValidationError(
u'suffix like is not support, you used at {0}={1}'.format(
key, value))
elif oper in ['in', 'between']:
value = value.split(self.value_separator)
if oper == 'between' and len(value) != 2:
raise ValidationError(
u'between value must be a range,'
u' your query: {0}={1}'.format(
key, self.value_separator.join(value)))
return _Filter(key=fkey, op=oper, val=value)
raise ValidationError(u'invalid filter {0} for {1}'.format(
key, self.name))