Python HttpRequest.is_ajax方法代码示例

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
def integration_doc(request: HttpRequest, integration_name: str=REQ(default=None)) -> HttpResponse:
    if not request.is_ajax():
        return HttpResponseNotFound()
    try:
        integration = INTEGRATIONS[integration_name]
    except KeyError:
        return HttpResponseNotFound()

    context = {}  # type: Dict[str, Any]
    add_api_uri_context(context, request)

    context['integration_name'] = integration.name
    context['integration_display_name'] = integration.display_name
    if hasattr(integration, 'stream_name'):
        context['recommended_stream_name'] = integration.stream_name
    if isinstance(integration, WebhookIntegration):
        context['integration_url'] = integration.url[3:]
    if isinstance(integration, HubotIntegration):
        context['hubot_docs_url'] = integration.hubot_docs_url
    if isinstance(integration, EmailIntegration):
        context['email_gateway_example'] = settings.EMAIL_GATEWAY_EXAMPLE
    if integration.name == 'freshdesk':
        # In our Freshdesk docs, some nested code blocks have characters such
        # as '{' encoded as '{' to prevent clashes with Jinja2 syntax,
        # but the encoded form never gets rendered because the text ends up
        # inside a <pre> tag. So here, we explicitly set a directive that
        # a particular template should be "unescaped" before being displayed.
        # Note that this value is used by render_markdown_path.
        context['unescape_rendered_html'] = True

    doc_html_str = render_markdown_path(integration.doc, context)

    return HttpResponse(doc_html_str)

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
def integration_doc(request: HttpRequest, integration_name: str=REQ(default=None)) -> HttpResponse:
    if not request.is_ajax():
        return HttpResponseNotFound()
    try:
        integration = INTEGRATIONS[integration_name]
    except KeyError:
        return HttpResponseNotFound()

    context = {}  # type: Dict[str, Any]
    add_api_uri_context(context, request)

    context['integration_name'] = integration.name
    context['integration_display_name'] = integration.display_name
    if hasattr(integration, 'stream_name'):
        context['recommended_stream_name'] = integration.stream_name
    if isinstance(integration, WebhookIntegration):
        context['integration_url'] = integration.url[3:]
    if isinstance(integration, HubotIntegration):
        context['hubot_docs_url'] = integration.hubot_docs_url
    if isinstance(integration, EmailIntegration):
        context['email_gateway_example'] = settings.EMAIL_GATEWAY_EXAMPLE

    doc_html_str = render_markdown_path(integration.doc, context)

    return HttpResponse(doc_html_str)

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
def get_lockout_response(request: HttpRequest) -> HttpResponse:
    context = {
        'failure_limit': settings.AXES_FAILURE_LIMIT,
        'username': get_client_username(request) or ''
    }

    cool_off = settings.AXES_COOLOFF_TIME
    if cool_off:
        if isinstance(cool_off, (int, float)):
            cool_off = timedelta(hours=cool_off)

        context.update({
            'cooloff_time': iso8601(cool_off)
        })

    status = 403

    if request.is_ajax():
        return JsonResponse(
            context,
            status=status,
        )

    if settings.AXES_LOCKOUT_TEMPLATE:
        return render(
            request,
            settings.AXES_LOCKOUT_TEMPLATE,
            context,
            status=status,
        )

    if settings.AXES_LOCKOUT_URL:
        return HttpResponseRedirect(settings.AXES_LOCKOUT_URL)

    return HttpResponse(get_lockout_message(), status=status)

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
    def test_request_middleware(self):

        # Middleware related test
        request = HttpRequest()
        request.method = random.sample([u'POST', u'GET'], 1)[0]
        request.path = random.sample([u'/requests/',
                                      u'/edit/',
                                      u'/admin/'], 1)[0]
        request.user = AnonymousUser()
        request.POST = QueryDict(u'k_post=v_post')
        request.COOKIES = QueryDict(u'k_coo=v_coo')
        request.META['HTTP_ACCEPT_LANGUAGE'] = u'en'
        request.META['HTTP_HOST'] = get_random_ip()
        request.META['HTTP_REFERER'] = u''
        request.META['HTTP_USER_AGENT'] = u''
        request.META['QUERY_STRING'] = u'&t=1'
        request.META['REMOTE_ADDR'] = get_random_ip()
        request.META['REMOTE_USER'] = u''
        request.META['REQUEST_METHOD'] = request.method
        request.META['SERVER_NAME'] = u'localhost'
        request.META['SERVER_PORT'] = u'80'

        response = HttpResponse()
        response.status_code = random.sample(
            [200, 302, 404, 500], 1)[0]
        middleware = RequestMiddleware()
        resp = middleware.process_response(request, response)
        self.assertEquals(response, resp)

        r = Request.objects.all().order_by('-time')[:1][0]
        self.assertEquals(r.status_code, response.status_code)
        self.assertEquals(r.host, request.get_host())
        self.assertEquals(r.path, request.path)
        self.assertEquals(r.user, None)
        self.assertEquals(r.method, request.method)
        self.assertEquals(r.user_agent,
                          request.META.get('HTTP_USER_AGENT', ''))
        self.assertEquals(r.language,
                          request.META.get('HTTP_ACCEPT_LANGUAGE', ''))
        self.assertEquals(r.timezone, request.META.get('TZ', ''))
        self.assertEquals(r.remote_address,
                          request.META.get('REMOTE_ADDR', ''))
        self.assertEquals(r.referer,
                          request.META.get('HTTP_REFERER', ''))
        self.assertEquals(r.is_secure, request.is_secure())
        self.assertEquals(r.is_ajax, request.is_ajax())
        self.assertEquals(r.GET, json.dumps(request.GET))
        self.assertEquals(r.POST, json.dumps(request.POST))
        self.assertEquals(r.cookies, json.dumps(request.COOKIES))

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
    def process_request(self, request: HttpRequest):
        request.window_key = get_random_string(32, VALID_KEY_CHARS)
        if request.is_ajax() and self.ajax_header in request.META:
            session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
            signer = signing.Signer(session_key)
            signed_token = request.META[self.ajax_header]
            request.window_key = signer.unsign(signed_token)
        request.has_websocket_topics = False
        request.remote_username = None

        if settings.USE_X_FORWARDED_FOR and "HTTP_X_FORWARDED_FOR" in request.META:
            request.META["REMOTE_ADDR"] = (
                request.META["HTTP_X_FORWARDED_FOR"].split(",")[0].strip()
            )

        if settings.USE_HTTP_BASIC_AUTH and "HTTP_AUTHORIZATION" in request.META:
            authentication = request.META["HTTP_AUTHORIZATION"]
            authmeth, sep, auth_data = authentication.partition(" ")
            if sep == " " and authmeth.lower() == "basic":
                auth_data = base64.b64decode(auth_data.strip()).decode("utf-8")
                username, password = auth_data.split(":", 1)
                user = auth.authenticate(username=username, password=password)
                if user:
                    request.user = user
                    auth.login(request, user)
        # noinspection PyTypeChecker
        username = getattr(settings, "DF_FAKE_AUTHENTICATION_USERNAME", None)
        if username and settings.DEBUG:
            remote_addr = request.META.get("REMOTE_ADDR")
            if remote_addr in settings.INTERNAL_IPS:
                request.META[self.header] = username
            elif remote_addr:
                logger.warning(
                    "Unable to use `settings.DF_FAKE_AUTHENTICATION_USERNAME`. "
                    "You should add %s to the list `settings.INTERNAL_IPS`."
                    % remote_addr
                )

        if self.header and self.header in request.META:
            remote_username = request.META.get(self.header)
            if (
                not remote_username or remote_username == "(null)"
            ):  # special case due to apache2+auth_mod_kerb :-(
                return
            remote_username = self.format_remote_username(remote_username)
            # noinspection PyTypeChecker
            self.remote_user_authentication(request, remote_username)

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import is_ajax [as 别名]
class JavaScriptFeaturesTest(TestCase):
    def setUp(self):
        self.middleware = JavaScriptFeaturesMiddleware()
        self.request = HttpRequest()
        self.response = HttpResponse()

    def test_normal_request_with_no_features(self):
        self.middleware.process_request(self.request)
        self.middleware.process_response(self.request, self.response)

        self.assertTrue('X-JavaScript' not in self.response)

        script = init_javascript_features(
            {"request": self.request},
        )
        self.assertEqual("", script)

    def test_normal_request_with_features(self):
        self.middleware.process_request(self.request)
        use_javascript_feature(
            self.request,
            "Foo",
        )
        use_javascript_feature(
            self.request,
            "Bar",
        )
        use_javascript_feature(
            self.request,
            "Bar",
        )
        self.middleware.process_response(self.request, self.response)

        self.assertTrue('X-JavaScript' not in self.response)

        script = init_javascript_features(
            {"request": self.request},
        )
        self.assertTrue("%s.Foo.init" % settings.JAVASCRIPT_FEATURES_NAMESPACE in script)
        self.assertTrue("%s.Bar.init" % settings.JAVASCRIPT_FEATURES_NAMESPACE in script)

    def test_ajax_request_with_no_features(self):
        self.request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.assertTrue(
            self.request.is_ajax(),
            "Test setup is wrong, this should be an AJAX request",
        )

        self.middleware.process_request(self.request)
        self.middleware.process_response(self.request, self.response)

        self.assertTrue('X-JavaScript' not in self.response)

    def test_ajax_request_with_features(self):
        self.request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.assertTrue(
            self.request.is_ajax(),
            "Test setup is wrong, this should be an AJAX request",
        )

        self.middleware.process_request(self.request)
        use_javascript_feature(
            self.request,
            "Foo",
        )
        use_javascript_feature(
            self.request,
            "Bar",
        )
        use_javascript_feature(
            self.request,
            "Bar",
        )
        self.middleware.process_response(self.request, self.response)

        self.assertTrue('X-JavaScript' in self.response)
        header = self.response['X-JavaScript']
        features = simplejson.loads(header)
        self.assertEqual(2, len(features))
        self.assertTrue('Foo' in features and 'Bar' in features)