def pop(self, data):
if self.name in data or self.default is not NoKeyDefault:
yield self.get_name(), catch_error(self.trafaret,
data.pop(self.name, self.default))
raise StopIteration
if not self.optional:
yield self.name, DataError(error='is required')
def check_(value):
first, second = None, None
if name in value:
first = value[name]
else:
yield name, t.DataError('is required'), (name,)
if confirm_name in value:
second = value[confirm_name]
else:
yield confirm_name, t.DataError('is required'), (confirm_name,)
if not (first and second):
return
yield name, t.catch_error(trafaret, first), (name,)
yield confirm_name, t.catch_error(trafaret, second), (confirm_name,)
if first != second:
yield confirm_name, t.DataError(f'must be equal to {name}'), (confirm_name,)
async def register_user(request: web.Request) -> web.Response:
""" Register user handler. Check if user already exist or create new user in database
:param request: web request
:return: web response in json format
"""
json_data = await request.json()
result = T.catch_error(REGISTER_TRAFARET, json_data)
if isinstance(result, DataError):
errors = result.as_dict()
return json_response({'errors': errors}, status=400)
async with request.app['db'].acquire() as connection:
cursor = await connection.execute(
users.select().where(users.c.email == json_data['email']))
user_credentials = await cursor.fetchone()
if user_credentials:
return json_response({
'message':
'User with email {email} already exist'.format(
email=json_data['email'])
})
else:
await connection.execute(users.insert().values(
name=json_data['name'],
last_name=json_data['last_name'],
email=json_data['email'],
password=generate_password_hash(json_data['password']),
))
return json_response({
'message':
'User with email {email} register successfully'.format(
email=json_data['email'])
})
def check_(value):
first, second = None, None
if name in value:
first = value[name]
else:
yield name, t.DataError('is required'), (name,)
if confirm_name in value:
second = value[confirm_name]
else:
yield confirm_name, t.DataError('is required'), (confirm_name,)
if not (first and second):
return
yield name, t.catch_error(trafaret, first), (name,)
yield confirm_name, t.catch_error(trafaret, second), (confirm_name,)
if first != second:
yield confirm_name, t.DataError('must be equal to {}'.format(name)), (confirm_name,)
def test_regexp_raw_error(self):
trafaret = t.RegexpRaw('cat')
res = catch_error(trafaret, 'dog')
assert res.as_dict(value=True) == 'does not match pattern cat, got \'dog\''
res = extract_error(trafaret, None)
assert res == 'value is not a string'
def test_xor_key(self):
trafaret = t.Dict(xor_key('name', 'nick', t.String()))
res = trafaret({'name': u'Nickolay'})
assert res == {'name': u'Nickolay'}
res = catch_error(trafaret, {'name': u'Nickolay', 'nick': u'Sveta'})
assert res.as_dict() == {
'name': 'correct only if nick is not defined',
'nick': 'correct only if name is not defined',
}
res = catch_error(trafaret, {})
assert res.as_dict() == {
'name': 'is required if nick is not defined',
'nick': 'is required if name is not defined',
}
def transform(self, value, context=None):
errors = []
for trafaret in self.trafarets:
res = t.catch_error(trafaret, value, context=context)
if isinstance(res, t.DataError):
errors.append(res)
else:
return value
raise t.DataError(errors)
def check_(value):
if (first in value) ^ (second in value):
key = first if first in value else second
yield first, t.catch_error(trafaret, value[key]), (key,)
elif first in value and second in value:
yield first, t.DataError(error='correct only if {} is not defined'.format(second)), (first,)
yield second, t.DataError(error='correct only if {} is not defined'.format(first)), (second,)
else:
yield first, t.DataError(error='is required if {} is not defined'.format('second')), (first,)
yield second, t.DataError(error='is required if {} is not defined'.format('first')), (second,)
def check_(value):
if (first in value) ^ (second in value):
key = first if first in value else second
yield first, t.catch_error(trafaret, value[key]), (key,)
elif first in value and second in value:
yield first, t.DataError(error=f'correct only if {second} is not defined'), (first,)
yield second, t.DataError(error=f'correct only if {first} is not defined'), (second,)
else:
yield first, t.DataError(error=f'is required if {second} is not defined'), (first,)
yield second, t.DataError(error=f'is required if {first} is not defined'), (second,)
def test_confirm_key(self):
trafaret = t.Dict(
confirm_key('password', 'password_confirm', t.String()))
res = trafaret({'password': u'qwerty', 'password_confirm': u'qwerty'})
assert res == {'password': u'qwerty', 'password_confirm': u'qwerty'}
res = catch_error(trafaret, {'password_confirm': u'qwerty'})
assert res.as_dict() == {'password': '******'}
res = catch_error(trafaret, {'password': u'qwerty'})
assert res.as_dict() == {'password_confirm': 'is required'}
res = catch_error(trafaret, {
'password': u'qwerty',
'password_confirm': u'not qwerty'
})
assert res.as_dict() == {
'password_confirm': 'must be equal to password'
}
def __call__(self, data):
subdict = dict((k, data.get(k)) for k in self.keys if k in data)
keys_names = self.keys
res = t.catch_error(self.trafaret, subdict)
if isinstance(res, t.DataError):
for k, e in res.error.items():
if not isinstance(e, t.DataError):
raise RuntimeError('Please use DataError instance')
yield k, e, keys_names
else:
for k, v in res.items():
yield k, v, keys_names
def check_(value):
first, second = None, None
if name in value:
first = value[name]
yield name, t.catch_error(trafaret, first), (name, )
else:
yield name, t.DataError('is required',
code=codes.REQUIRED), (name, )
if confirm_name in value:
second = value[confirm_name]
yield confirm_name, t.catch_error(trafaret,
second), (confirm_name, )
else:
yield confirm_name, t.DataError(
'is required', code=codes.REQUIRED), (confirm_name, )
if not (first and second):
return
if first != second:
yield (confirm_name,
t.DataError('must be equal to {}'.format(name),
code=codes.MUST_BE_EQUAL), (confirm_name, ))
def test_subdict_sample(self):
def check_passwords_equal(data):
if data['password'] != data['password_confirm']:
return t.DataError('Passwords are not equal',
code='are_no_equal')
return data['password']
check_password = t.String()
passwords_key = subdict(
'password',
t.Key('password', trafaret=check_password),
t.Key('password_confirm', trafaret=check_password),
trafaret=check_passwords_equal,
)
signup_trafaret = t.Dict(
t.Key('email', trafaret=t.Email),
passwords_key,
)
res = signup_trafaret({
'email': u'*****@*****.**',
'password': u'qwerty',
'password_confirm': u'qwerty'
})
assert res == {'email': u'*****@*****.**', 'password': u'qwerty'}
res = catch_error(
signup_trafaret, {
'email': u'*****@*****.**',
'password': u'qwerty',
'password_confirm': u'not qwerty'
})
assert res.as_dict() == {'password': '******'}
res = catch_error(signup_trafaret, {
'email': u'*****@*****.**',
'password': u'qwerty'
})
assert res.as_dict() == {'password_confirm': 'is required'}
async def login_user(request: web.Request) -> web.Response:
""" Login user handler. Check if user exist in database and generate JWT token
:param request: web request
:return: web response in json format
"""
jwt_config = request.app['config']['jwt_auth']
json_data = await request.json()
result = T.catch_error(LOGIN_TRAFARET, json_data)
if isinstance(result, DataError):
errors = result.as_dict()
return json_response({'errors': errors}, status=400)
async with request.app['db'].acquire() as connection:
cursor = await connection.execute(
users.select().where(users.c.email == json_data['email']))
user_credentials = await cursor.fetchone()
if not user_credentials:
return json_response(
{
'message':
'User with email {email} does not exist'.format(
email=json_data['email'])
},
status=403)
else:
id, email, password = user_credentials['id'], user_credentials[
'email'], user_credentials['password']
if check_password_hash(password, json_data['password']):
payload = {
'user_id':
id,
'user_email':
email,
'exp':
datetime.datetime.utcnow() +
timedelta(seconds=jwt_config['jset_exp_delta_seconds'])
}
jwt_token = jwt.encode(payload, jwt_config['jwt_secret'],
jwt_config['jwt_algorithm'])
return json_response({'token': jwt_token.decode('utf-8')})
else:
return json_response({'message': 'Password is not correct'},
status=401)
def check_(value):
if (first in value) ^ (second in value):
key = first if first in value else second
yield first, t.catch_error(trafaret, value[key]), (key, )
elif first in value and second in value:
yield first, t.DataError(
error='correct only if {} is not defined'.format(second)), (
first, )
yield second, t.DataError(
error='correct only if {} is not defined'.format(first)), (
second, )
else:
yield first, t.DataError(
error='is required if {} is not defined'.format('second')), (
first, )
yield second, t.DataError(
error='is required if {} is not defined'.format('first')), (
second, )
def check_(value):
if (first in value) ^ (second in value):
key = first if first in value else second
yield first, t.catch_error(trafaret, value[key]), (key, )
elif first in value and second in value:
yield (
first,
t.DataError(
error='correct only if {} is not defined'.format(second),
code=codes.ONLY_ONE_MUST_BE_DEFINED), (first, ))
yield (second,
t.DataError(
error='correct only if {} is not defined'.format(first),
code=codes.ONLY_ONE_MUST_BE_DEFINED), (second, ))
else:
yield (first,
t.DataError(
error='is required if {} is not defined'.format(second),
code=codes.ONE_IS_REQUIRED), (first, ))
yield (second,
t.DataError(
error='is required if {} is not defined'.format(first),
code=codes.ONE_IS_REQUIRED), (second, ))
def test_regexp_raw_error(self):
trafaret = t.RegexpRaw('cat')
res = catch_error(trafaret, 'dog')
self.assertEqual(res.as_dict(value=True),
'does not match pattern cat, got \'dog\'')
def transform(self, value, context=None):
res = t.catch_error(self.trafaret, value, context=context)
if not isinstance(res, t.DataError):
raise t.DataError('Value must not be validated')
return value
def test_regexp_raw_error(self):
trafaret = t.RegexpRaw('cat')
res = catch_error(trafaret, 'dog')
self.assertEqual(res.as_dict(value=True), 'does not match pattern cat, got \'dog\'')
def test_on_error_data_error(self):
trafaret = t.OnError(t.Bool, message='Changed message')
res = catch_error(trafaret, 'Trololo')
self.assertEqual(res.as_dict(), 'Changed message')
def test_on_error_data_error(self):
trafaret = t.OnError(t.Bool, message='Changed message')
res = catch_error(trafaret, 'Trololo')
self.assertEqual(res.as_dict(), 'Changed message')
