def _get_response(exc, content, status_code, headers={}): from aiohttp.web_response import Response resp = Response(status=status_code, text=content) for header_name, header_value in convert_to_str(headers.items()): resp.headers[header_name] = header_value return resp
def response( # pylint: disable=unused-argument req: Request, code: int, text: str = None, encoding: str = None) -> Response: """ Formats an aiohttp Response. :param req: The original aiohttp Request. :type req: :class:`aiohttp.web_request.Request` :param code: The HTTP result code to return. :type code: int :param text: The text to return. :type text: str :param encoding: The text encoding. Defaults to UTF-8. :type encoding: str :return: The aoihttp Response :rtype: :class:`aiohttp.web_response.Response` """ response = Response(status=code) if text: response.content_type = "text/plain" response.body = text.encode( encoding=encoding if encoding else "utf-8") return response
async def _health_check_handler(self, _: Request) -> typing.Optional[Response]: try: await self._mtproto.health_check() return Response(status=200, text="ok") except ConnectionError: return Response(status=500, text="gone")
def handle_error(self, request, status=500, exc=None, message=None): """Handle errors. Returns HTTP response with specific status code. Logs additional information. It always closes current connection.""" self.log_exception("Error handling request", exc_info=exc) if status == 500: msg = "<h1>500 Internal Server Error</h1>" if self.debug: try: tb = traceback.format_exc() tb = html_escape(tb) msg += '<br><h2>Traceback:</h2>\n<pre>' msg += tb msg += '</pre>' except: # pragma: no cover pass else: msg += "Server got itself in trouble" msg = ("<html><head><title>500 Internal Server Error</title>" "</head><body>" + msg + "</body></html>") else: msg = message resp = Response(status=status, text=msg, content_type='text/html') resp.force_close() # some data already got sent, connection is broken if request.writer.output_size > 0 or self.transport is None: self.force_close() return resp
async def handle(self, request: Request) -> Response: local_token_raw: str = request.match_info["local_token"] if not local_token_raw.isdigit(): return Response(status=400) local_token: int = int(local_token_raw) if local_token not in self._devices: return Response(status=403) device = self._devices[local_token] data = await request.read() status = _player_status(data) if status == UpnpPlayerStatus.PLAYING: device.playing = True if status == UpnpPlayerStatus.ERROR and device.playing: device.errored = True if device.errored and status == UpnpPlayerStatus.NOTHING: device.errored = False device.playing = False await device.reconnect.handle() return Response(status=200)
async def get(self): # TODO должна быть какая нибудь аутентификация (причем быстрая) try: user_uid = uuid.uuid4().hex query = all_tokens.insert().values((user_uid,)) await self.pg.fetch(query) return Response(body={ "MESSAGE_NAME": "GET_TOKEN", "STATUS": True, "PAYLOAD": { "TOKEN": user_uid, "description": "OK" } }) except Exception as e: logging.debug("handler name - %r, message_name - %r, error decoding - %r", "CreateToken", "GET_TOKEN", e) return Response(body={ "MESSAGE_NAME": "GET_TOKEN", "STATUS": False, "PAYLOAD": { "TOKEN": None, "description": "unknown runtime error" } })
async def get(self): try: query = GET_MODEL.where(all_tokens.c.token == self.token) result = await self.pg.fetch(query) return Response( body={ "MESSAGE_NAME": "CHECK_TOKEN", "STATUS": True, "PAYLOAD": { "TOKEN_STATUS": True, "NAME_MODELS": result, "description": None } }) except Exception as e: logging.debug( "handler name - %r, message_name - %r, error decoding - %r", "CheckToken", "CHECK_TOKEN", e) return Response( body={ "MESSAGE_NAME": "CHECK_TOKEN", "STATUS": False, "PAYLOAD": { "TOKEN_STATUS": None, "NAME_MODELS": [], "description": "Неизвестная runtime ошибка" } })
async def authorize(request, response: Response, vk_access_token: VkOAuthAccessTokenDTO): """Авторизация пользователя""" store: VKAccessTokenObjectManager = request.app.stores.access_tokens auth_token = await store.set_access_token(vk_access_token) response.set_cookie(name=AUTH_COOKIE_NAME, value=auth_token, expires=vk_access_token.expires_in) return response
def __init__(self, data=None): if data is None: data = self.default_msg data = json.dumps(data) Response.__init__(self, text=data, status=self.status, content_type='application/json') Exception.__init__(self)
async def aws_endpoint(request): # very VERY simple mock of s3 if request.method == 'GET': return Response(text=s3_response) elif request.method == 'PUT': image_data = await request.read() img = Image.open(BytesIO(image_data)) request.app['images'].append((request.path, img.width, img.height)) return Response(text='')
async def handle(self, request: Request) -> Response: password = request.match_info["password"] if password != self._config.web_ui_password: return Response(status=403) remote_token = secret_token() self._devices[remote_token] = WebDevice(f"web @({request.remote})", remote_token, self._devices) return Response(status=200, body=str(remote_token))
async def get(self, project_name) -> Response: project_doc = self.dbcon.database[project_name].find_one( {"type": "project"}) if project_doc: return Response(status=200, body=self.resource.encode(project_doc), content_type="application/json") return Response( status=404, reason="Project name {} not found".format(project_name))
async def slack_command(request): action = request.match_info.get('slack_command', None) if not action: log.warning('Got no action.') return Response(body='Bad action') payload = await request.text() result = Dispatcher.dispatch_action(action=action, payload=payload) if not result: return Response(body='Error!!') return json_response(result)
def __init__(self, body=irc['INTERNAL_SERVER_ERROR'], status=500): Response.__init__( self, status=status, headers=None, reason=None, text=None, content_type='application/json', body=json.dumps({"errors": body}), )
async def handle_file(self, request: 'web.Request', filename: str, from_index=None) -> 'web.Response': """Handle file requests.""" try: filepath = self._directory.joinpath(filename).resolve() if not self._follow_symlinks: filepath.relative_to(self._directory) except (ValueError, FileNotFoundError) as error: # relatively safe raise HTTPNotFound() from error except Exception as error: # perm error or other kind! request.app.logger.exception(error) raise HTTPNotFound() from error # on opening a dir, load it's contents if allowed if filepath.is_dir(): if filename.endswith('/') or not filename: ret = await self.handle_file(request, filename + 'index.html', from_index=filename) else: # Redirect and add trailing slash so relative links work (Issue #3140) new_url = request.rel_url.path + '/' if request.rel_url.query_string: new_url += '?' + request.rel_url.query_string raise HTTPMovedPermanently(new_url) elif filepath.is_file(): ct, encoding = mimetypes.guess_type(str(filepath)) encoding = encoding or 'utf-8' if ct == 'text/html' and self.modify_html: if sys.version_info[0] == 3 and sys.version_info[1] <= 5: # Python 3.4 and 3.5 do not accept pathlib.Path objects in calls to open() filepath = str(filepath) with open(filepath, 'r', encoding=encoding) as fh: text = fh.read() text = self.transform_html(text) ret = Response(text=text, content_type=ct, charset=encoding) else: ret = FileResponse(filepath, chunk_size=self._chunk_size) elif from_index: filepath = self._directory.joinpath(from_index).resolve() try: return Response(text=self._directory_as_html(filepath), content_type="text/html") except PermissionError: raise HTTPForbidden else: raise HTTPNotFound return ret
async def incoming_request(request): airtable = request.app.plugins['airtable'] payload = await request.json() logger.debug('Incoming Airtable event payload: %s', payload) if payload['token'] != airtable.verify: return Response(status=401) futures = list(_dispatch(airtable.routers['request'], payload, request.app)) if futures: return await _wait_and_check_result(futures) return Response(status=200)
def logout( request, response: Response, ): """Деавторизация пользователя.""" auth_cookie: Optional[str] = request.cookies.get(AUTH_COOKIE_NAME, None) if auth_cookie: store: VKAccessTokenObjectManager = request.app.stores.access_tokens asyncio.get_event_loop().create_task( store.delete_access_token(auth_cookie)) response.del_cookie(name=AUTH_COOKIE_NAME) return response
async def get(self, instance_id): instance = session.query(Article).filter( Article.id == instance_id ).first() if not instance: return Response( status=404, body=json.dumps({'not found': 404}), content_type='application/json' ) data = self.resource.render_and_encode(instance) return Response(status=200, body=data, content_type='application/json')
async def handle(self, request: Request) -> Response: password = request.match_info["password"] if password != self._config.web_ui_password: return Response(status=403) token = secret_token() device = WebDevice(f"web @({request.remote})", token) remove = functools.partial(self._remove_device, device) self._devices[device] = debounce = AsyncDebounce(remove, self._config.request_gone_timeout) debounce.update_args() return Response(status=200, body=str(token))
async def return_value(currency: Currency, pool): query = sa.select([ RateOrm.rate.label('current_rate'), func.avg(RateOrm.volume).label('avg_volume') ]).group_by(RateOrm.id).where(RateOrm.currency_id == currency.id).order_by( RateOrm.date.desc()).limit(1) async with pool.transaction() as conn: result = await conn.fetchrow(query) if result is None: return Response(text='not found transaction', status=404) result = Rate(**dict(result)) return Response(body=result.json().encode('utf-8'), content_type='application/json', status=200)
async def get(self, project_name, asset_name) -> Response: asset_doc = self.dbcon.database[project_name].find_one({ "type": "asset", "name": asset_name }) if asset_doc: return Response(status=200, body=self.resource.encode(asset_doc), content_type="application/json") return Response(status=404, reason="Asset name {} not found in project {}".format( asset_name, project_name))
async def start_timer(self, request): data = await request.json() try: project_name = data['project_name'] asset_name = data['asset_name'] task_name = data['task_name'] hierarchy = data['hierarchy'] except KeyError: log.error("Payload must contain fields 'project_name, " + "'asset_name', 'task_name', 'hierarchy'") return Response(status=400) self.module.stop_timers() self.module.start_timer(project_name, asset_name, task_name, hierarchy) return Response(status=200)
async def slack_api(request): api_plugin = request.app.plugins["api"] try: slack_request = SlackApiRequest.from_request(request) except FailedVerification: logger.info(f"Failed verification to API route {request.url}.") return Response(status=401) futures = list( _dispatch(api_plugin.routers["slack"], slack_request, request.app)) if futures: return await _wait_and_check_result(futures) return Response(status=200)
async def _wait_and_check_result(futures): dones, _ = await asyncio.wait(futures, return_when=asyncio.ALL_COMPLETED) try: results = [done.result() for done in dones] except Exception as e: logger.exception(e) return Response(status=500) results = [result for result in results if isinstance(result, Response)] if len(results) > 1: logger.warning('Multiple web.Response for handler, returning none') elif results: return results[0] return Response(status=200)
async def get(self, request: Request) -> Response: auth = False for x in self.allowed_hosts: if request.remote.startswith(x): auth = True break if not auth: _LOGGER.warning( f'unauthorised attempt to connect from {request.remote}') return Response(status=401) hass: HomeAssistant = request.app['hass'] hub: 'h.MegaD' = hass.data.get(DOMAIN).get( request.remote) # TODO: проверить какой remote if hub is None and request.remote == '::1': hub = hass.data.get(DOMAIN).get('__def') if hub is None: return Response(status=400) data = dict(request.query) hass.bus.async_fire( EVENT_BINARY_SENSOR, data, ) _LOGGER.debug(f"Request: %s from '%s'", data, request.remote) make_ints(data) port = data.get('pt') data = data.copy() data['mega_id'] = hub.id ret = 'd' if port is not None: hub.values[port] = data for cb in self.callbacks[hub.id][port]: cb(data) template: Template = self.templates.get(hub.id, {}).get(port) if hub.update_all: asyncio.create_task(self.later_update(hub)) if template is not None: template.hass = hass ret = template.async_render(data) _LOGGER.debug('response %s', ret) ret = Response(body=ret or 'd', content_type='text/plain', headers={ 'Server': 's', 'Date': 'n' }) return ret
async def post(self): status: bool = True try: res: dict = await self.request.json() payload: dict = res["PAYLOAD"] logging.info("handler name - %r, message_name - %r, info - %r", "AddCommentHandler", "ADD_COMMENT", "OK") # запрос к db на добавление комментария в бд(id, url фото, комментарий, дата) query = comments.insert().values( file=payload["url"], comment=payload["comment"], date=datetime.now() ) await self.pg.fetch(query) except Exception as e: status = False logging.info("handler name - %r, message_name - %r, info - %r, error - %r", "AddCommentHandler", "ADD_COMMENT", "FAIL", e) return Response(body={ "MESSAGE_NAME": "ADD_COMMENT", "STATUS": status })
async def render_page(self, reason=''): """ Получет список изображений из БД и формирует html код страницы :param reason: Текстовое описание причины ошибки :return: Response """ rows_per_page, page = self.fetch_query_data() page = page - 1 order = 'desc', by = 'upload_date' orderby = getattr(Images.c, by, None) if orderby is None: orderby = Images.c.upload_date sort = orderby.desc() if order != 'desc': sort = orderby.asc() query = Images.select()\ .order_by(sort)\ .limit(rows_per_page)\ .offset(rows_per_page*page) query_string, params = asyncpgsa.compile_query(query) res = [] async with self.request.app.db.acquire() as conn: for row in await conn.fetch(query_string, *params): tmp = ImageManager.init_from_db_row(row) res.append(tmp.serialize()) template = self.request.app.jinja.get_template('index.html') data = await template.render_async(res=res, reason=reason) return Response(body=data, status=200, headers={'Content-Type': 'text/html'})
async def get(self): await self.check_import_exists() # В задании требуется, чтобы ключами были номера месяцев # (без ведущих нулей, "01" -> 1). month = func.date_part('month', citizens_t.c.birth_date) month = cast(month, Integer).label('month') query = select([ month, relations_t.c.citizen_id, func.count(relations_t.c.relative_id).label('presents') ]).select_from( relations_t.join( citizens_t, and_( citizens_t.c.import_id == relations_t.c.import_id, citizens_t.c.citizen_id == relations_t.c.relative_id ) ) ).group_by( month, relations_t.c.import_id, relations_t.c.citizen_id ).where( relations_t.c.import_id == self.import_id ) rows = await self.pg.fetch(query) result = {i: [] for i in range(1, 13)} for month, rows in groupby(rows, key=lambda row: row['month']): for row in rows: result[month].append({'citizen_id': row['citizen_id'], 'presents': row['presents']}) return Response(body={'data': result})
async def post(self) -> Response: """Uploads a file to storage Request ------ should be contain multipart data ------ Response ------ <file_hash> str: new file name generated by hash function """ if not self.request.can_read_body: raise ValidationError if 'multipart' not in self.request.content_type: raise ValidationError( message='Only multipart content is supported') reader = await self.request.multipart() file_manager = self._create_file_manager() try: async for file_stream in reader: if file_stream.filename: file_hash = await file_manager.save_file(file_stream) break response = Response(body={'file_hash': file_hash}, headers={'Location': f'/files/{file_hash}'}, status=HTTPStatus.CREATED) return response except EmptyFileError as e: logger.exception(e) raise ValidationError(message='File is empty') from e
async def post(self, request): data = await request.json() group, _created = get_or_create(session, DomainGroup, name=data['name']) domains = [] if data.get('domains'): for domain_el in data.get('domains'): domain, _domain_created = get_or_create(session, Domain, domain=domain_el) domains.append({ 'id': domain.id, 'domain': domain_el, 'created': _domain_created }) return Response(status=200, body=self.resource.encode({ 'id': group.id, 'name': group.name, 'domains': domains, 'created': _created }), content_type='application/json')