Python web_response.Response方法代码示例

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
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 aoihttp Request
        :param code: The HTTP result code to return
        :param text: The text to return
        :param encoding: The text encoding.  Defaults to utf-8
        :return: The aoihttp 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 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
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') 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def message_data(request):
    """
    As an example of aiohttp providing a non-html response, we load the actual messages for the "messages" view above
    via ajax using this endpoint to get data. see static/message_display.js for details of rendering.
    """
    json_str = await request.app['pg'].fetchval(
        """
        select coalesce(array_to_json(array_agg(row_to_json(t))), '[]')
        from (
          select username, timestamp, message
          from messages
          order by timestamp desc
        ) t
        """
    )
    return Response(text=json_str, content_type='application/json') 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def _write_upnp_headers(self, result: typing.Union[Response, StreamResponse]) -> typing.NoReturn:
        result.headers.setdefault("Content-Type", "video/mp4")
        result.headers.setdefault("Access-Control-Allow-Origin", "*")
        result.headers.setdefault("Access-Control-Allow-Methods", "GET, OPTIONS")
        result.headers.setdefault("Access-Control-Allow-Headers", "Content-Type")
        result.headers.setdefault("transferMode.dlna.org", "Streaming")
        result.headers.setdefault("TimeSeekRange.dlna.org", "npt=0.00-")
        result.headers.setdefault("contentFeatures.dlna.org", "DLNA.ORG_OP=01;DLNA.ORG_CI=0;")

    # noinspection PyUnusedLocal 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def _upnp_discovery_handler(self, request: Request) -> typing.Optional[Response]:
        result = Response(status=200)
        self._write_upnp_headers(result)
        return result 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def get(self) -> Response:
        data = []

        domains = session.query(Domain).all()
        for instance in self.resource.collection.values():
            data.append(self.resource.render(instance))

        return Response(status=200, body=self.resource.encode({
            'domains': [
                {
                    'id': domain.id, 'title': domain.domain,
                    'groups': [{'id': group.id, 'name': group.name} for group in domain.groups]
                } for domain in session.query(Domain).all()
            ]}), content_type='application/json') 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def setUp(self):
        self.app = App()
        self.client = ClientSession()

        self.callback = callback = CoroutineMock()
        self.route_path = "/mock_handler"
        self.route_method = "GET"
        self.metrics = metrics = patch(
            "asyncworker.metrics.aiohttp_resources.metrics"
        ).start()

        @self.app.route(
            routes=[self.route_path],
            type=RouteTypes.HTTP,
            methods=[self.route_method],
        )
        async def handler(request):
            metrics.requests_in_progress.labels.assert_called_once_with(
                method=request.method, path=request.path
            )
            metrics.requests_in_progress.labels.return_value.inc.assert_called_once()
            metrics.requests_in_progress.labels.return_value.dec.assert_not_called()
            await callback(request)
            return Response(text="ok")

        await self.app.startup() 

# 需要导入模块: from aiohttp import web_response [as 别名]
# 或者: from aiohttp.web_response import Response [as 别名]
def process(self, req: Request, logic: Callable) -> Response:
        """
        Accept an incoming webhook request and convert it into a TurnContext which can be processed by the bot's logic.

        :param req: The aoihttp Request object
        :param logic: The method to call for the resulting bot turn.
        :return: The aoihttp Response
        """
        if not req:
            raise Exception("Request is required")

        if not self.slack_logged_in:
            await self.slack_client.login_with_slack()
            self.slack_logged_in = True

        body = await req.text()
        slack_body = SlackHelper.deserialize_body(req.content_type, body)

        if slack_body.type == "url_verification":
            return SlackHelper.response(req, 200, slack_body.challenge)

        if not self.slack_client.verify_signature(req, body):
            text = "Rejected due to mismatched header signature"
            return SlackHelper.response(req, 401, text)

        if (
            not self.slack_client.options.slack_verification_token
            and slack_body.token != self.slack_client.options.slack_verification_token
        ):
            text = f"Rejected due to mismatched verificationToken:{body}"
            return SlackHelper.response(req, 403, text)

        if slack_body.payload:
            # handle interactive_message callbacks and block_actions
            activity = SlackHelper.payload_to_activity(slack_body.payload)
        elif slack_body.type == "event_callback":
            activity = await SlackHelper.event_to_activity(
                slack_body.event, self.slack_client
            )
        elif slack_body.command:
            activity = await SlackHelper.command_to_activity(
                slack_body, self.slack_client
            )
        else:
            raise Exception(f"Unknown Slack event type {slack_body.type}")

        context = TurnContext(self, activity)
        await self.run_pipeline(context, logic)

        return SlackHelper.response(req, 200)