python类HttpResponse()的实例源码

def get(self, request):
        return HttpResponse('Main Page')

def get(self, request, *args, **kwargs):
        if self.request.GET.get('hub.verify_token') == settings.GOLEM_CONFIG.get('WEBHOOK_VERIFY_TOKEN'):
            return HttpResponse(self.request.GET['hub.challenge'])
        else:
            return HttpResponse('Error, invalid token')

def post(self, request, *args, **kwargs):
        # Converts the text payload into a python dictionary
        request_body = json.loads(self.request.body.decode('utf-8'))
        FacebookInterface.accept_request(request_body)
        return HttpResponse()

def get(self, request, *args, **kwargs):
        request_body = json.loads(self.request.body.decode('utf-8'))
        from pprint import pprint
        pprint(request_body)
        return HttpResponse()

def post(self, request, *args, **kwargs):
        # Converts the text payload into a python dictionary
        request_body = json.loads(self.request.body.decode('utf-8'))
        TelegramInterface.accept_request(request_body)
        return HttpResponse()

def test(request):

    with open('test/results.json') as infile:
        tests = json.load(infile)

    status = 'passed'
    avg = {'duration':0, 'total':0, 'init':0, 'parsing':0, 'processing':0}
    passed = 0
    for test in tests:
        result = test['result']
        if result['status'] == 'passed':
            passed += 1
            avg['duration'] += result['duration']
            avg['total'] += result['report']['avg']['total']
            avg['init'] += result['report']['avg']['init']
            avg['parsing'] += result['report']['avg']['parsing']
            avg['processing'] += result['report']['avg']['processing']
        elif status != 'exception':
            status = result['status']

    if passed > 0:
        for key in avg:
            avg[key] = avg[key] / passed

    context = {'tests':tests, 'avg':avg, 'status':status}
    template = loader.get_template('golem/test.html')
    return HttpResponse(template.render(context, request))

def debug(request):
    FacebookInterface.accept_request({'entry':[{'messaging':[{'message': {'seq': 356950, 'mid': 'mid.$cAAPhQrFuNkFibcXMZ1cPICEB8YUn', 'text': 'hi'}, 'recipient': {'id': '1092102107505462'}, 'timestamp': 1595663674471, 'sender': {'id': '1046728978756975'}}]}]})

    return HttpResponse('done')

def user_info_api_handler(request):
    user_id = request.GET.get("user_id")
    user_info = UserInfo.query_format_info_by_user_id(user_id)
    return HttpResponse(json.dumps({"user_info": user_info}))

def user_info_api_by_ease_mob_handler(request):
    ease_mob = request.GET.get("ease_mob")
    user_info = UserInfo.query_format_info_by_ease_mob(ease_mob)
    return HttpResponse(json.dumps({"user_info": user_info}))

def test_view(request):
    PizzaOrder.objects.create(status='ORDERED')
    return HttpResponse()

def preview_campaign(request, campaign_id):
    from premailer import Premailer
    campaign = get_object_or_404(Campaign, pk=campaign_id)
    content = campaign.render_html(request, test=True)
    content = Premailer(content, strip_important=False).transform()
    return HttpResponse(content)

def preview_campaign_plain(request, campaign_id):
    campaign = get_object_or_404(Campaign, pk=campaign_id)
    content = campaign.render_plain(request, test=True)
    return HttpResponse('<pre>%s</pre>' % content.strip())

def get(self, request, *args, **kwargs):
        from requests_oauthlib import OAuth1Session

        config = SocialConfig.get_solo()
        oauth_token = request.GET.get('oauth_token')
        oauth_verifier = request.GET.get('oauth_verifier')

        oauth_client = OAuth1Session(
            client_key=config.twitter_client_id,
            client_secret=config.twitter_client_secret,
            resource_owner_key=oauth_token,
            resource_owner_secret=config.twitter_access_token_secret,
            verifier=oauth_verifier
        )

        try:
            answer = oauth_client.fetch_access_token('https://api.twitter.com/oauth/access_token')
        except ValueError:
            raise Http404

        if answer and 'oauth_token' in answer:
            SocialConfig.objects.update(twitter_access_token=answer['oauth_token'])
            add_message(request, SUCCESS, _('Twitter access_token updated successfully!'))
            return redirect('admin:social_networks_socialconfig_change')
        else:
            return HttpResponse(answer)

def render(self, indent=0):
        """
        Renders a HttpResponse for the ongoing request
        :param indent int
        :rtype: HttpResponse
        """
        self.__indent = indent
        return HttpResponse(
            self.__str__(), content_type=self.__content_type, charset=self.__charset, **self.__kwargs
        )

def get_invalid_result():
    """Return an object instance that cannot be serialized in json or xml"""
    from django.http.response import HttpResponse
    return HttpResponse(content='dummy')

def xml_http_response(data, http_response_cls=HttpResponse):
        response = http_response_cls(data)
        response['Content-Type'] = 'text/xml'
        return response

def result_error(self, exception, http_response_cls=HttpResponse):

        raw_response = '<?xml version="1.0"?>'
        raw_response += '<methodResponse>'
        raw_response += self.dumps(xmlrpc_client.Fault(exception.code, exception.message))
        raw_response += '</methodResponse>'

        return self.xml_http_response(raw_response, http_response_cls=http_response_cls)

def json_http_response(data, http_response_cls=HttpResponse):
        response = http_response_cls(data)
        response['Content-Type'] = 'application/json'
        return response

def result_error(self, exception, http_response_cls=HttpResponse):
        result = self.json_error_response(exception)
        return self.json_http_response(self.dumps(result), http_response_cls=http_response_cls)

def lichess_api_call(request, path):
    params = request.GET.dict()
    priority = int(params.pop('priority', 0))
    max_retries = int(params.pop('max_retries', 3))
    redis_key = get_random_string(length=16)
    worker.queue_work(priority, _do_lichess_api_call, redis_key, path, request.method, request.body, params, priority, max_retries)
    return HttpResponse(redis_key)