def validate_code(key, value, length, reverse=False, startswith=None):
value = maybe_unicode(value)
if not value:
raise Error(key, _('Required'))
number = value.strip().lower()
if not number.isnumeric():
raise Error(key, _('Need to be a number'))
elif len(number) != length:
raise Error(key, _('Need to have ${length} digits', mapping={'length': length}))
if startswith and str(number[0]) not in startswith:
startswith_str = '"%s"' % '", "'.join(startswith)
raise Error(key, _('Need to start with ${chars}', mapping={'chars': startswith_str}))
last_number = int(number[-1])
number = number[:-1]
if reverse:
number_list = reversed(number)
else:
number_list = list(number)
prime = find_next_prime(length)
check_digit = prime - (sum(i * int(d) for i, d in enumerate(number_list, 2)) % prime)
if last_number != check_digit:
raise Error(key, _('Invalid number'))
else:
return value
def validate_pt_post_address(postal_address):
if u('-') not in postal_address:
raise Error('postal_address', _('Invalid postal address'))
cp4, cp3 = postal_address.split(u('-'), 1)
if not cp4.isnumeric() or not cp3.isnumeric():
raise Error('postal_address', _('Invalid postal address'))
cp4 = int(cp4)
if cp4 < 1000 or cp4 > 9999:
raise Error('postal_address', _('First number must be between 1000 and 9999'))
elif len(cp3) != 3:
raise Error('postal_address', _('Second number must have 3 digits'))
def datetimeinput_deserialize(self, field, pstruct):
if pstruct is null:
return null
else:
# seriously pickadate? oh. right. i forgot. you're javascript.
date = (pstruct.get('date_submit') or pstruct.get('date', '')).strip()
time = (pstruct.get('time_submit') or pstruct.get('time', '')).strip()
if (not time and not date):
return null
result = 'T'.join([date, time])
if not date:
raise Invalid(field.schema, _('Incomplete date'), result)
if not time:
raise Invalid(field.schema, _('Incomplete time'), result)
return result
def wrapper(cls, *args, **kwargs):
cache_key = '%s user limit %s' % (wrapped.__name__, cls.request.ip_address)
counter = int(cls.cache.get(cache_key, expire=expire) or 0)
if counter >= length:
raise Error('tries', _('Too many tries. Try again later'))
cls.cache.put(cache_key, counter + 1, expire=expire)
result = wrapped(cls, *args, **kwargs)
return result
def __call__(self, node, value):
number = to_unicode(value).lower()
if len(number) != self.length:
raise Invalid(node, _('Need to have ${length} chars', mapping={'length': self.length}))
digit_sum = 0
second_digit = False
for letter in reversed(number):
digit = PORTUGUESE_CC_LETTER_MAPPING.get(letter)
if second_digit:
digit *= 2
if digit > 9:
digit -= 9
digit_sum += digit
second_digit = not second_digit
if digit_sum % 10:
raise Invalid(node, _('Invalid code'))
def deserialize(self, node, value):
if is_file_type(value):
return {
'file': value,
'filename': basename(value.name),
'type': None}
elif isinstance(value, FieldStorage):
return {
'file': value.file,
'filename': value.filename,
'type': 'image/png'}
else:
raise Invalid(node, _('Invalid file.'))
def format_error_to_json_values(error, kwargs=None, request=None):
if request:
translate = translate_factory(request)
else:
translate = lambda tstring, **kw: tstring
if isinstance(error, HTTPError):
status = error.code
key = camelcase(error.title)
title = error.title
message = error.explanation
elif isinstance(error, Invalid):
status = 400
key = camelcase(error._keyname())
title = _('Form error')
message = error.msg
errors = defaultdict(list)
for path in error.paths():
for exc in path:
key = str(exc.node.name)
if exc.positional and exc.pos: # Ignore 0 position
key += '.' + str(exc.pos)
if key and exc.msg:
key = camelcase(key)
for message in exc.messages():
errors[key].append(translate(message))
if not kwargs:
kwargs = {}
kwargs['errors'] = errors
else:
status = getattr(error, 'code', 400)
key = camelcase(getattr(error, 'key', 'undefined'))
title = getattr(error, 'title', None)
message = getattr(error, 'msg', getattr(error, 'message', 'Undefined'))
values = {
'status': status,
'property': key,
'title': title and translate(title) or None,
'message': translate(message)}
if kwargs:
values.update(kwargs)
return values
add_sequence_node(schema, *sequence_node, **kwargs)
else:
add_sequence_node(schema, sequence_node, sequence_node.name, **kwargs)
def set_sequence_nodes(**kwargs):
def decorator(class_):
with_filter_by = kwargs.pop('with_filter_by', False)
for key, value in kwargs.items():
add_sequence_node(class_, value, key, with_filter_by=with_filter_by)
return class_
return decorator
@set_sequence_nodes(
field=SchemaNode(String(), title=_('Show fields')),
exclude_field=SchemaNode(String(), title=_('Exclude fields')))
class SearchFields(MappingSchema):
pass
def PaginationOrderFinisher(node, appstruct):
if appstruct and appstruct.get('order_by'):
order_by = appstruct['order_by']
if not is_nonstr_iter(order_by):
order_by = [order_by]
appstruct['order_by'] = []
output_node = getattr(node, '__output_node__')
for ob in order_by:
ob = ob.split(' ', 1)
def _render(value, system):
request = system.get('request')
output_schema = None
if isinstance(value, dict):
output_schema = value['schema']
value = value['value']
delimiter = ';'
quote_char = '"'
line_terminator = '\r\n'
quoting = QUOTE_ALL
encoder = None
if request is not None:
response = request.response
ct = response.content_type
if ct == response.default_content_type:
response.content_type = 'text/csv'
output = request.registry.config.lookup_output_schema(
request.matched_route.name,
request_method=request.method)
if output:
output_schema = output[0].schema
if output_schema:
value = self.lookup_rows(request, output_schema.children[0], value)
output_filename = getattr(output_schema, 'filename', None)
if output_filename:
if callable(output_filename):
output_filename = output_filename()
response.content_disposition = 'attachment; filename="%s"' % output_filename
_get_param = request.params.get
get_param = lambda k: _get_param(k) or _get_param(camelcase(k))
csv_delimiter = get_param('csv_delimiter')
if csv_delimiter:
delimiter = to_string(csv_delimiter)
if delimiter == '\\t':
delimiter = '\t'
else:
delimiter = delimiter[0]
csv_quote_char = get_param('csv_quote_char')
if csv_quote_char:
quote_char = to_string(csv_quote_char)
csv_line_terminator = get_param('csv_line_terminator')
if csv_line_terminator:
if csv_line_terminator == '\\n\\r':
line_terminator = '\n\r'
elif csv_line_terminator == '\\n':
line_terminator = '\n'
elif csv_line_terminator == '\\r':
line_terminator = '\r'
csv_encoding = get_param('csv_encoding')
if csv_encoding:
try:
encoder = codecs.lookup(csv_encoding)
except LookupError:
raise Error('csv_encoding', _('Invalid CSV encoding'))
else:
if encoder.name != 'utf-8':
request.response.charset = encoder.name
yes_text = request.translate(_('Yes'))
no_text = request.translate(_('No'))
csv_quoting = get_param('csv_quoting')
if csv_quoting:
csv_quoting = to_string(csv_quoting).lower()
if csv_quoting == 'minimal':
quoting = QUOTE_MINIMAL
elif csv_quoting == 'non_numeric':
quoting = QUOTE_NONNUMERIC
elif csv_quoting == 'none':
quoting = QUOTE_NONE
else:
yes_text = 'Yes'
no_text = 'No'
if not value:
return ''
f = StringIO()
csvfile = csv_writer(
f,
delimiter=delimiter,
quotechar=quote_char,
lineterminator=line_terminator,
quoting=quoting)
for value_items in value:
row = []
for item in value_items:
if item is None:
item = ''
elif not isinstance(item, str):
if isinstance(item, bool):
item = item and yes_text or no_text
elif isinstance(item, (float, int)):
item = str(item)
elif isinstance(item, (DATE, DATETIME)):
item = item.isoformat()
elif not isinstance(item, str):
item = to_string(item)
row.append(item)
csvfile.writerow(row)
f.seek(0)
response = f.read()
f.close()
if encoder:
response = encoder.decode(encoder.encode(response)[0])[0]
else:
response = to_string(response)
return response
def __call__(self, node, value):
number = maybe_phone_number(value)
if not number:
raise Invalid(node, _('Invalid number'))
else:
return number
def __call__(self, node, value):
if not validate_skype_username(value, validate_with_api=self.validate_with_api):
raise Invalid(node, _('Invalid "skype" username'))
def __call__(self, node, value):
if not to_unicode(value).isnumeric():
raise Invalid(node, _('Invalid number'))
