class ItemsValid(object):
def __init__(self, field):
fieldtype = field['type']
nodetype = registry.validation(fieldtype, **field)
self.schema = SchemaNode(Sequence(), nodetype)
def __call__(self, node, value):
self.schema.deserialize(value)
def test_invalid(self):
from colander import Invalid, SchemaNode
n = SchemaNode(JobQuery.File(), name='filefield')
with self.assertRaises(Invalid) as e:
n.deserialize(12345)
self.assertDictEqual(e.exception.asdict(),
{'filefield': '12345 is not a cgi.FieldStorage'})
class Filter(object):
"""
Base class for search field filter fields.
"""
interface.implements(IDescribable)
def __init__(self, name, field_type, ops=None, validator=None):
self.name = name
self.valid_ops = ops or FILTER_OPERATIONS.keys()
self.node = SchemaNode(
field_type,
name=name,
missing=None,
validator=validator,
)
@property
def field_type(self):
return self.node.typ
@property
def is_sequence(self):
"""
Check that current field support values as list.
List operations like "in" or "nin" require `colander.List`
as field type to be able to process multiple values.
Field type for each value can be validated individually
using colander validators.
Returns a Boolean.
"""
return isinstance(self.field_type, colander.List)
def valid_operation(self, operation):
return operation in self.valid_ops
def deserialize(self, raw_value):
return self.node.deserialize(raw_value)
def describe(self):
type_cls = self.field_type.__class__
operation_list = []
for operation in self.valid_ops:
info = {
'name': operation,
'doc': FILTER_OPERATIONS[operation].__doc__,
}
operation_list.append(info)
return {
'type': type_cls.__name__,
'operations': operation_list,
}
def users(request):
db = request.db
# Schema
schema = SchemaNode(Mapping(),
SchemaNode(Integer(), name='id'))
payload = schema.deserialize(request.json)
users = User.by_params(db, **payload)
return users
def user_by_key(request):
db = request.db
# Schema
schema = SchemaNode(Mapping(),
SchemaNode(String(), name='key_key'))
payload = schema.deserialize(request.json)
key = Key.by_key_key(db, payload['key_key'])
if key:
return key.user
def apps_create(request):
db = request.db
schema = SchemaNode(Mapping(),
SchemaNode(String(), name='name'))
payload = schema.deserialize(request.json)
app = App(created=datetime.datetime.now(),
name=payload['name'],
user=request.user)
db.add(app)
db.flush()
return app
def get_input_data(context, request: PyramidRequest, schema: colander.SchemaNode) -> Union[dict, list]:
if not schema:
return {}
content_type = request.content_type
if request.method in METHODS_WITH_BODY and content_type.startswith('application/json'):
try:
data_dict = request.json_body
except ValueError as e:
raise InvalidBodyFormat(detail=str(e))
else:
data_dict = request.params
try:
schema = schema().bind(request=request, context=context)
return schema.deserialize(data_dict)
except colander.Invalid as e:
raise colander_invalid_to_response(e)
def keys_add(request):
db = request.db
schema = SchemaNode(Mapping(),
SchemaNode(String(), name='key_type'),
SchemaNode(String(), name='key_key'),
SchemaNode(String(), name='key_comment'))
payload = schema.deserialize(request.json)
key = Key.by_key_key(db, payload['key_key'])
if not key:
key = Key(created=datetime.datetime.now(),
key_type=payload['key_type'],
key_key=payload['key_key'],
key_comment=payload['key_comment'],
user=request.user)
db.add(key)
return key
