python类HttpResponseBadRequest()的实例源码

def update_notify_numbers(request):
    if request.method == 'POST':
        if 'notify_numbers' in request.POST:
            notify_numbers = request.POST['notify_numbers'].strip()
            if not notify_numbers == "":
                for current_number in notify_numbers.split(','):
                    try:
                        validate_phone(current_number.strip())
                    except ValidationError:
                        messages.error(request, "Invalid phone number: '" + current_number +
                                       "'. Example of valid input is '+62000000, +52000000, +63000000'",
                                       extra_tags="alert alert-danger notify-numbers")
                        return redirect("/dashboard/profile")
            network = UserProfile.objects.get(user=request.user).network
            network.notify_numbers = notify_numbers
            network.save()
            messages.success(request, "Notify numbers updated.",
                         extra_tags="alert alert-success notify-numbers")
            return redirect("/dashboard/profile")
    return HttpResponseBadRequest()

def export_data(request, atype):
    if atype == "sheet":
        return excel.make_response_from_a_table(
            Customer, 'xls', file_name="sheet")
    elif atype == "custom":
        query_sets = Customer.objects.all()
        column_names = ['first_name', 'last_name', 'email', 'birthday']
        return excel.make_response_from_query_sets(
            query_sets,
            column_names,
            'xls',
            file_name="custom"
        )
    else:
        return HttpResponseBadRequest(
            "Bad request. please put one of these " +
            "in your url suffix: sheet, book or custom")

def parameterval_png(request, pk):
    try:
        param = ParameterVal.objects.get(pk=pk)
    except ParameterVal.DoesNotExist:
        return HttpResponseNotFound()

    if not param.wf_module.public_authorized():
        return HttpResponseForbidden()

    # is this actually in image? totes hardcoded for now
    if param.parameter_spec.id_name != 'chart':
        return HttpResponseBadRequest()

    # decode the base64 payload of the data URI into a png
    image_data = param.value.partition('base64,')[2]
    binary = base64.b64decode(image_data)
    return HttpResponse(binary, content_type='image/png')

def get(self, request, *args, **kwargs):
        try:
            answer = BalanceAnswer.objects.get(id=kwargs['pk'])
        except BalanceAnswer.DoesNotExist:
            return HttpResponseBadRequest(request)

        if hasattr(answer, 'match'):
            # we already created a match from this BalanceAnswer
            return super(MatchCreate, self).get(request, *args, **kwargs)

        # check that players from balance exist
        # (we don't allow CustomBalance results here)
        players = [p[0] for t in answer.teams for p in t['players']]
        players = Player.objects.filter(name__in=players)

        if len(players) < 10:
            return HttpResponseBadRequest(request)

        MatchManager.record_balance(answer, int(kwargs['winner']))

        return super(MatchCreate, self).get(request, *args, **kwargs)

def dispatch(self,request,*args,**kwargs):
        '''
        Check that a valid Invoice ID has been passed in session data,
        and that said invoice is marked as paid.
        '''
        paymentSession = request.session.get(INVOICE_VALIDATION_STR, {})
        self.invoiceID = paymentSession.get('invoiceID')
        self.amount = paymentSession.get('amount',0)
        self.success_url = paymentSession.get('success_url',reverse('registration'))

        # Check that Invoice matching passed ID exists
        try:
            i = Invoice.objects.get(id=self.invoiceID)
        except ObjectDoesNotExist:
            return HttpResponseBadRequest(_('Invalid invoice information passed.'))

        if i.unpaid or i.amountPaid != self.amount:
            return HttpResponseBadRequest(_('Passed invoice is not paid.'))

        return super(GiftCertificateCustomizeView,self).dispatch(request,*args,**kwargs)

def dispatch(self, request, *args, **kwargs):
        ids = request.GET.get('ids')
        ct = getIntFromGet(request,'ct')

        try:
            contentType = ContentType.objects.get(id=ct)
            self.objectClass = contentType.model_class()
        except (ValueError, ObjectDoesNotExist):
            return HttpResponseBadRequest(_('Invalid content type passed.'))

        # This view only deals with subclasses of Events (Public Events, Series, etc.)
        if not isinstance(self.objectClass(),Event):
            return HttpResponseBadRequest(_('Invalid content type passed.'))

        try:
            self.queryset = self.objectClass.objects.filter(id__in=[int(x) for x in ids.split(',')])
        except ValueError:
            return HttpResponseBadRequest(_('Invalid ids passed'))

        return super(RepeatEventsView,self).dispatch(request,*args,**kwargs)

def get(self, request):
        """
            Instagram will send a GET request to confirm our subscription
            url. They send a GET-parameter 'hub.challenge' and we have to
            reply with that value and only the value.
        """
        log.debug("Instagram handling GET subscription")

        q_hub_mode = request.GET.get('hub.mode', False)
        q_hub_challenge = request.GET.get('hub.challenge', False)

        # TODO add a check when making a new subscription
        q_hub_verify_token = request.GET.get('hub.verify_token', False)

        log.debug("hub.mode: {}".format(q_hub_mode))
        log.debug("hub.challenge: {}".format(q_hub_challenge))
        log.debug("hub.verify_token: {}".format(q_hub_verify_token))

        if q_hub_mode == 'subscribe' and q_hub_challenge is not False:
            log.debug("instagram hub verification successful")

            return HttpResponse(q_hub_challenge, content_type="text/plain")

        log.error("instagram hub verification failed")
        return HttpResponseBadRequest()

def bad_request(request, exception, template_name=ERROR_400_TEMPLATE_NAME):
    """
    400 error handler.

    Templates: :template:`400.html`
    Context: None
    """
    try:
        template = loader.get_template(template_name)
    except TemplateDoesNotExist:
        if template_name != ERROR_400_TEMPLATE_NAME:
            # Reraise if it's a missing custom template.
            raise
        return http.HttpResponseBadRequest('<h1>Bad Request (400)</h1>', content_type='text/html')
    # No exception content is passed to the template, to not disclose any sensitive information.
    return http.HttpResponseBadRequest(template.render())


# This can be called when CsrfViewMiddleware.process_view has not run,
# therefore need @requires_csrf_token in case the template needs
# {% csrf_token %}.

def get(self, request):
        if len(request.GET) > 1:
            formset = PageBlockQueryFormSet(request.GET)
            if not formset.is_valid():
                return HttpResponseBadRequest('invalid query')

            pages = formset.get_query()
        else:
            formset = PageBlockQueryFormSet()
            pages = Page.objects.all()

        paginator, pages = paginate(request, pages.order_by('title'))

        for page in pages:
            page.can_choose = True

        return render(request, self.template_name, {
            'base_url': replace_page_in_query(request.GET.urlencode(), None),
            'formset': formset,
            'pages': pages,
        })

def post(self, request):
        """
        Handling GET method
        :param request: Request to View
        :return: HttpResponse with code 201 if user is created or
        HttpResponseBadRequest if request contain incorrect data
        """
        verification_code = request.GET.get("code", "")

        invitation = AdviserInvitations.get_invitation(verification_code)

        user_registration_form = UserRegistrationForm(json.loads(request.body))

        if not user_registration_form.is_valid():
            return HttpResponseBadRequest("Invalid input data. Please edit and try again.")

        AdviserUser.create_user(user_registration_form, invitation)

        invitation.close_invitation()

        return HttpResponse(status=201)

def post(self, request):
        """Handling GET method
            :param request: Request to View
            :return: HttpResponse with code 201 if user is invited or
                     HttpResponseBadRequest if request contain incorrect data
        """
        invite_form = UserInvitationForm(json.loads(request.body))

        if not invite_form.is_valid():
            return HttpResponseBadRequest("Invalid input data. Please edit and try again.")

        if AdviserUser.objects.filter(user__email=invite_form.data[u'email']).exists():
            return HttpResponseBadRequest("User with this e-mail is registered")

        if AdviserInvitations.objects.filter(email=invite_form.data[u'email']).exists():
            return HttpResponseBadRequest("User with this e-mail is already invited")

        sender = EmailSender(invite_form.data[u'email'])
        sender.send_invite(invite_form.data[u'id_company'])
        return HttpResponse(status=201)

def post(self, request):
        """
        Handling POST method
        :param json file with username and password
        :return: HttpResponse with superuser status and code 200 if user is invited or
                 HttpResponseBadRequest if request contain incorrect data
        """
        data = json.loads(request.body)
        login_form = LoginForm(data)
        if not login_form.is_valid():
            return HttpResponseBadRequest('Invalid input data', status=401)
        username = data.get('username', None)
        password = data.get('password', None)
        user = auth.authenticate(username=username, password=password)
        if user:
            role = model_to_dict(User.objects.get(username=username))
            response = HttpResponse('is_supeuser', status=200)
            response.set_cookie('role', value=role['is_superuser'])
            auth.login(request, user)
            return response
        else:
            return HttpResponseBadRequest("Incorrect email or password", status=401)

def put(self, request):
        """
        Handling PUT method. Send project to chosen players.
        :param request: Request to View.
        :return: Http response with status code 400 if players weren`t added. Http response with status code 201 if project is sended.
        """
        data = json.loads(request.body)
        if not data.get("players"):
            return HttpResponseBadRequest("Players are not added. Please, add some players.")
        project = AdviserProject.objects.get(id=data.get("project")["id"])
        if (not request.user.is_superuser) and (project.id_company.id != 
                                                request.user.adviseruser.id_company.id):
            return HttpResponseBadRequest("Permission denied")
        for player in data.get("players"):
            player = Player.get_by_id(player["id"])
            player.project = project
            player.save()
        return HttpResponse(status=201)

def put(self, request):
        """

        :param request: Request to View
        :return: change user info
        """
        data = json.loads(request.body)
        user_form = UserForm(data['User'])
        if not user_form.is_valid():
            return HttpResponseBadRequest('Invalid input data', status=400)
        adviser_user = AdviserUser.objects.get(id=data['AdviserUser']['id'])
        adviser_user.set_adviser_user(data['AdviserUser'])
        user = User.objects.get(id=data['User']['id'])
        user.last_name = data['User']['last_name']
        user.first_name = data['User']['first_name']
        user.save()
        return HttpResponse(status=201)

def check_superadmin(func):
    """
    Decorator that check if authenticated user is a superadmin.
    :param func: function, that be wrapped
    :return: function
    """
    def wrapper(self, request, *args, **kwargs):
        """
        Wrapper, that checks authenticated user
        :param request: Django request
        :return: BadRequest when authenticated user is not a superadmin or function in other case
        """
        if not request.user.is_superuser:
            return HttpResponseBadRequest("Permission denied")
        return func(self, request, *args, **kwargs)
    return wrapper

def put(self, request, company_id):
        """
        Handling put method.
        :args
            request: Request to View.
            company_id: id of company to be updated.
        :return: HttpResponse with code 201 if company is updated or
        HttpResponseBadRequest if request contain incorrect data also if user is not superuser .
        """
        if (not request.user.is_superuser) and (Company.get_company(company_id).administrator != 
                                                request.user.adviseruser):
            return HttpResponseBadRequest("Permission denied")
        data = json.loads(request.body)
        if data.get("administrator"):
            data["administrator"] = AdviserUser.objects.get(id=data.get("administrator").get("id"))
        company = Company.get_company(data["id"])
        company_form = CompanyForm(data, company)
        if not company_form.is_valid():
            return HttpResponseBadRequest(str(company_form.errors))
        company.set_company(data)
        return HttpResponse(status=201)

def sources(request):
    """
    Content Source backend endpoint.

    Uses OpenEdx Course API v.1.0
    :param request:
    :param course_id:
    :return: (JSON) blocks
    """
    course_id = request.POST.get('course_id')
    if not course_id:
        return HttpResponseBadRequest(reason={"error": "`course_id` is a mandatory parameter."})

    log.debug('course_ID{}'.format(course_id))

    try:
        sources_list = get_available_blocks(course_id)
    except ObjectDoesNotExist as exc:
        return HttpResponseBadRequest(reason={"error": exc.message})
    except HttpClientError as exc:
        return HttpResponseNotFound(reason={"error": exc.message})

    return JsonResponse(data=sources_list, safe=False)

def display_certs(request):

    try:
        ct = int(request.GET["ct"])
        ids = request.GET["ids"]
    except KeyError:
        return HttpResponseBadRequest()

    id_list = map(int, ids.split(","))
    model = ContentType.objects.get(pk=ct).model_class()
    qs = model.objects.filter(pk__in=id_list)

    for client in qs:
        if not client.cert:
            client.create_cert()
    return render(request, "display_certs.html", {"objs": qs})