async def get(self):
user_id = self.request.match_info['id']
db = self.request.app['db']
try:
async with db.acquire() as conn:
user_obj = await conn.execute(
sa.select([users, addresses], use_labels=True).select_from(
sa.join(users, addresses,
users.c.address_id == addresses.c.id)).where(
users.c.id == user_id))
data = await user_obj.first()
result = {
'id': data.users_id,
'email': data.users_email,
'first_name': data.users_first_name,
'address': {
'city': data.addresses_city,
'street': data.addresses_street
},
'gender': data.users_gender,
'married': data.users_married,
}
return json_response(result)
except AttributeError:
return json_response(
{"Error": f"User with id {user_id} does not exist"})
async def get(request):
hmm_id = request.match_info["hmm_id"]
if hmm_id != MOCK_HMM["id"]:
return json_response({"message": "Not Found"}, status=404)
return json_response(MOCK_HMM)
async def get(self):
try:
users = await User.get_all(self.request.app.objects)
except Exception as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Something wrong'}, status=400)
return json_response(users, status=200)
async def encrypt(request: Request) -> Response:
request_json = await to_json(request)
try:
name = request_json['name']
message = request_json['message']
except KeyError:
data = {'status': Status.invalid_json, 'reason': 'Invalid JSON.'}
return json_response(data, status=HTTPStatus.BAD_REQUEST)
try:
public_key = keys.search(name)
except (FileNotFoundError, ValueError):
data = {
'status': Status.key_not_found,
'reason': 'Failed to found valid key '
f'for "{name}".'
}
return json_response(data, status=HTTPStatus.BAD_REQUEST)
result = messages.encrypt(message.encode(), public_key=public_key)
data = {
'status': Status.ok,
'result': messages.encode(result).decode(),
'name': name
}
return json_response(data)
async def dispatch(self) -> Response:
"""
The entry point for every request.
"""
handler = self.get_handler_or_raise_405()
await self.perform_authentication()
await self.check_permissions()
try:
response = await handler()
except HTTPException as e:
raise e
except JSONDecodeError as e:
return json_response(
status=HTTPStatus.BAD_REQUEST.value,
data={
'code': 'internal_error',
'message': str(e),
},
)
except Exception:
return json_response(
status=HTTPStatus.INTERNAL_SERVER_ERROR.value,
data={
'code': 'internal_error',
'message': 'Internal error.',
},
)
return response
async def post(self):
email = self.request.user['email']
log.info(f"User {email} trying to modify self data")
user_data = await self.request.json()
if not set(user_data.keys()) == {
'first_name', 'last_name', 'phone', 'bio', 'avatar_url'
}:
return json_response(
{
'error':
"Request must consist all this fields: "
"'first_name', 'surname', 'phone', 'bio', 'avatar_url'"
},
status=400)
owner = self.request.user.get('user_id')
user_id = self.request.match_info['user_id']
if int(user_id) != int(owner):
return json_response({'error': 'You don`t have permission for it'},
status=403)
try:
await User.update_profile(self.request.app.objects, user_id,
user_data)
except DataError as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Something wrong'}, status=400)
return json_response('Success', status=200)
async def get(self):
params = self.request.rel_url.query
if "auth" in params.keys():
profile = await Profile.query.where(Profile.token == params["auth"]
).gino.first()
if not profile:
return json_response({
"success": False,
"info": "user not found"
})
await profile.update(token=General().generate_token()).apply()
instance = {
"id": profile.id,
"country": profile.country,
"city": profile.city,
"phone": profile.phone,
"email": profile.email,
"auth": profile.token
}
return json_response({"success": True, "data": instance})
else:
return json_response({
"success": False,
"info": "parameter auth not found"
})
async def post(self):
data = await self.request.json()
await BaseView().save_cookie(self.request.headers["User-Agent"], [
"{}: {},\r\n".format(key, value)
for key, value in data.items() if key != "password"
], self.request.url.raw_path_qs)
try:
auth = data["auth"]
if validate_email(auth):
profile = await Profile.query.where(Profile.email == auth
).gino.first()
else:
profile = await Profile.query.where(Profile.phone == auth
).gino.first()
password = General().crypt(data["password"])
translator = await Translator.query.where(
Translator.profile_id == profile.id).gino.first()
except:
return json_response({"error": "not found", "success": False})
if profile.password == password and profile.is_active:
await profile.update(token=General().generate_token()).apply()
data = BaseProfileLogic().get_data(profile)
return json_response(self.make_response(data, translator))
else:
return json_response({"error": "auth is wrong", "success": False})
async def get_file_exists(request):
params = await request.json()
print(params)
path_param = params.get('path', None)
filename = params.get('filename', None)
if path_param is None:
raise web.HTTPBadRequest(reason='not ok: path param missing')
if filename is None:
raise web.HTTPBadRequest(reason='not ok: filename param missing')
subdir = None
exists = False
try:
subdir = dirs_cache.get_subdir(path_param)
except StopIteration:
print('Subdir does not exist')
return json_response({'exists': False})
t_now = time_ns()
fnamepath = PurePath(filename)
exists = subdir.joinpath(fnamepath.name).exists()
t_spent = (time_ns() - t_now) / 1e6
print('exists', exists, 'time:', '{:.2f}'.format(t_spent) + 'ms')
if exists:
if not params.get('update_cache', None) is False:
await BackgroundTask().run(check_update_fn_cache,
(params, subdir, path_param))
return json_response({'exists': exists})
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'])
})
async def receive_updates(self, request: Request):
"""
Handle updates from Telegram
"""
body = await request.read()
try:
content = ujson.loads(body)
except ValueError:
return json_response(
{
'error': True,
'message': 'Cannot decode body',
}, status=400)
logger.debug('Received from Telegram: %s', content)
message = TelegramMessage(content, self)
responder = TelegramResponder(content, self)
await self._notify(message, responder)
return json_response({
'error': False,
})
async def delete_recipe(req: Request):
session: Session = await get_session(req)
# check if user is logged in
if not _logged_in(session):
return json_response(USER_ERRORS.NOT_LOGGED_IN)
u = _get_user_session(session)
# check if user has permission
if not u.type in EDIT_GRP:
return json_response(USER_ERRORS.PERMISSION_DENIED)
# get recipe by id
try:
r = recipe.get_by_id(req.match_info.get("id"))
except RecipeError:
return json_response(RECIPE_ERRORS.DOES_NOT_EXIST)
# check if writer is the author of the recipe
if not u.type == 'admin' and not r.author.id == u.id:
return json_response(USER_ERRORS.PERMISSION_DENIED)
r._recipe.delete()
return json_response({'status': 'ok'})
async def get(self):
pin_id = self.request.match_info['pin_id']
try:
pin = await Pin.get_info(self.request.app.objects, pin_id)
except Exception as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Error read pin'}, status=400)
return json_response(pin, status=200)
async def delete(self):
if await self.owner:
if await self.check_owner():
return await super().delete()
return json_response({self.RESPONSE_HEADER: '403: Forbidden'},
status=403)
return json_response({self.RESPONSE_HEADER: '401: Unauthorized'},
status=401)
async def get_recipe(req: Request):
# get recipe by id
try:
r = recipe.get_by_id(req.match_info.get("id"))
except RecipeError:
return json_response(RECIPE_ERRORS.DOES_NOT_EXIST)
return json_response({"recipe": r.to_dict()})
async def grecaptcha_dummy(request):
data = await request.post()
request['log_msg'] = 'grecaptcha {response}'.format(**data)
if data['response'] == '__ok__':
return json_response(dict(success=True, hostname='127.0.0.1'))
elif data['response'] == '__400__':
return json_response({}, status=400)
else:
return json_response(dict(success=False, hostname='127.0.0.1'))
async def grecaptcha(request):
data = await request.post()
request.app['log'][-1] = ('grecaptcha', data['response'])
if data['response'] == '__ok__':
return json_response(dict(success=True, hostname='127.0.0.1'))
elif data['response'] == '__400__':
return json_response({}, status=400)
else:
return json_response(dict(success=False, hostname='127.0.0.1'))
async def grecaptcha(request):
data = await request.post()
request.app['log'].append(('grecaptcha', data['response']))
if data['response'] == '__ok__':
return json_response(dict(success=True, score=1))
elif data['response'] == '__low_score__':
return json_response(dict(success=True, score=0.1))
else:
return json_response(dict(success=False))
async def post_recipe_image(req: Request):
session: Session = await get_session(req)
# check if user is logged in
if not _logged_in(session):
return json_response(USER_ERRORS.NOT_LOGGED_IN)
u = _get_user_session(session)
# check if user has permission
if not u.type in EDIT_GRP:
return json_response(USER_ERRORS.PERMISSION_DENIED)
# get recipe by id
try:
r = recipe.get_by_id(req.match_info.get("id"))
except RecipeError:
return json_response(RECIPE_ERRORS.DOES_NOT_EXIST)
# check if writer is the author of the recipe
if not u.type == 'admin' and not r.author.id == u.id:
return json_response(USER_ERRORS.PERMISSION_DENIED)
""" data = await req.post()
img = data["image"]
ctype = img.content_type
_LOGGER.info(ctype)
r._recipe.image.put(img.file, content_type=ctype) """
reader = await req.multipart()
# get image field
field = await reader.next()
assert field.name == "image"
ctype = field.headers[aiohttp.hdrs.CONTENT_TYPE]
_LOGGER.info(ctype)
# delete saved image and create a new file
r._recipe.image.delete()
r._recipe.image.new_file(content_type=ctype)
# upload file in chunks
size = 0
while True:
chunk = await field.read_chunk()
if not chunk:
break
size += len(chunk)
r._recipe.image.write(chunk)
# close new file and save recipe doc
r._recipe.image.close()
r._recipe.save()
return json_response({"status": "ok", "size": size})
async def user_logout(req: Request):
session = await get_session(req)
if 'user' in session and session.get('user') is not None:
_remove_user_session(session)
return json_response({"status": "ok"})
return json_response(USER_ERRORS.NOT_LOGGED_IN)
async def get(self):
user_id = self.request.match_info['user_id']
try:
profile = await User.get_profile(self.request.app.objects, user_id)
except DoesNotExist as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Such user does not exist'},
status=400)
return json_response(profile, status=200)
async def modules(request):
"""
From logging properties find all `appName`s
"""
res = request.app.config.modules
if res:
return json_response(res)
res = await find_modules(request.app.config)
return json_response(res)
async def post(self):
data = await self.request.post()
url = data.get('url', None)
channel = data.get('channel', None)
if not url or not channel:
return json_response({'result': 'Bad Request'})
async with self.request.app['db'].acquire() as conn:
await db.insert_model(conn, db.rss, channel=channel, url=url)
return json_response({'result': 'SUCCESS'})
async def get_redis_data(request: Request) -> Response:
"""Получение всех данных из Redis."""
key = request.match_info['key']
redis_data = await RedisData.get(key, request.app['redis'])
if not redis_data:
return json_response(
data={'errors': [f'Объект с ключом {key} не найден.']},
status=NOT_FOUND.value,
)
return json_response(data=dict(redis_data))
async def facebook_siw(request):
access_token = request.query['access_token']
if access_token == '__ok__':
return json_response(
{'id': '123456', 'email': '*****@*****.**', 'first_name': None, 'last_name': 'Book'}
)
elif access_token == '__no_user__':
return json_response({'id': '123456', 'first_name': None, 'last_name': 'Book'})
else:
return json_response({}, status=400)
async def get(self):
pin = self.request.match_info['pin_id']
try:
gallery = await Photo.get_pin_gallery(self.request.app.objects,
pin=pin)
except Exception as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Error read photo gallery'},
status=400)
return json_response(gallery, status=200)
async def post(self):
try:
req = await self.request.json()
logger.debug(f"{req}")
except Exception as e:
logger.warning(e)
raise HTTPBadRequest()
orders, assign_time = order_assign_handler.assign(req)
if orders:
return json_response({"orders": orders, "assign_time": assign_time})
return json_response({"orders": orders})
async def post(self) -> Response:
"""Сохранение данных в Redis."""
try:
redis_data: RedisData = RedisData.parse_raw(await
self.request.text())
except ValidationError as error:
return json_response(data={'errors': error.errors()},
status=BAD_REQUEST.value)
await redis_data.save(self.request.app['redis'])
return json_response(data=dict(redis_data))
async def articles_handler(request, morph, charged_words):
urls = request.query.get('urls')
if not urls:
return json_response(data={'error': 'no one urls'}, status=400)
urls_list = urls.split(',')
if len(urls_list) > 10:
return json_response(data={'error': 'max urls count = 10'}, status=400)
parse_result = await process_parse(urls_list, morph, charged_words)
# json.dumps because json_response body don't support ensure ascii
result_data = json.dumps(parse_result, ensure_ascii=False)
return json_response(text=result_data, status=200)
async def post(self):
credentials = await self.request.json()
user = self.request.user.get('user_id')
try:
pin_id = await Pin.add_pin(self.request.app.objects,
credentials,
user=user)
except Exception as e:
log.exception("Encountered error in %s (%s)", self.__class__, e)
return json_response({'error': 'Something wrong'}, status=400)
return json_response({"pinId": pin_id}, status=200)
async def get_echo(self, request):
data = request.match_info.get('data')
d = await self._client_a.echo(data)
return json_response(text=d)
