django.http.HttpResponseNotAllowed

Here are the examples of the python api django.http.HttpResponseNotAllowed taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

146 Examples 7

Example 1

Project: courtlistener Source File: views.py
@ensure_csrf_cookie
@login_required
def delete_visualization(request):
    if request.is_ajax():
        v = SCOTUSMap.objects.get(pk=request.POST.get('pk'), user=request.user)
        v.deleted = True
        v.save()
        return HttpResponse("It worked.")
    else:
        return HttpResponseNotAllowed(
            permitted_methods=['POST'],
            content="Not an ajax request",
        )

Example 2

Project: synnefo Source File: urls.py
def volume_demux(request):
    if request.method == 'GET':
        return views.list_volumes(request)
    elif request.method == 'POST':
        return views.create_volume(request)
    else:
        return HttpResponseNotAllowed(['GET', 'POST'])

Example 3

Project: wateronmars Source File: views.py
@login_required(login_url=settings.LOGIN_URL)
@csrf_protect
def user_creation(request):
  if not request.user.is_staff:
    return HttpResponseForbidden("Sorry, you're not allowed to create new users.")
  if request.method == 'POST':
    form = UserProfileCreationForm(request.POST, error_class=CustomErrorList)
    if form.is_valid():
      form.save()
      return HttpResponseRedirect(reverse('wom_user.views.user_profile',
                                          args=(request.user.username,)))
  elif request.method == 'GET':
    form = UserProfileCreationForm(error_class=CustomErrorList)
  else:
    return HttpResponseNotAllowed(['GET','POST'])
  return render_to_response('user_creation.html',
                            {'form': form},
                            context_instance=RequestContext(request))

Example 4

Project: pets Source File: views.py
Function: home
def home(request):
    if (request.method) != 'GET':
        return HttpResponseNotAllowed(['GET'])

    pets = Pet.objects.filter()
    serializer = PetSerializer(pets, many=True, context={'request': request})
    return JsonSerializedResponse(serializer.data)

Example 5

Project: ion Source File: signup.py
@login_required
def toggle_favorite_view(request):
    if request.method != "POST":
        return http.HttpResponseNotAllowed(["POST"], "HTTP 405: METHOD NOT ALLOWED")
    if not ("aid" in request.POST and request.POST["aid"].isdigit()):
        http.HttpResponseBadRequest("Must specify an integer aid")

    aid = request.POST["aid"]
    with transaction.atomic():
        activity = get_object_or_404(EighthActivity, id=aid)
        if activity.favorites.filter(id=request.user.id).exists():
            activity.favorites.remove(request.user)
            return http.HttpResponse("Unfavorited activity.")
        else:
            activity.favorites.add(request.user)
            return http.HttpResponse("Favorited activity.")

Example 6

Project: seriesly Source File: __init__.py
def is_get(func):
    def need_get_func(*args, **kwargs):
        request = args[0]
        if request.method == 'GET':
            return func(*args, **kwargs)
        else:
            return HttpResponseNotAllowed(["GET"])
    return need_get_func

Example 7

Project: lettuce Source File: http.py
def require_http_methods(request_method_list):
    """
    Decorator to make a view only accept particular request methods.  Usage::

        @require_http_methods(["GET", "POST"])
        def my_view(request):
            # I can assume now that only GET or POST requests make it this far
            # ...

    Note that request methods should be in uppercase.
    """
    def decorator(func):
        def inner(request, *args, **kwargs):
            if request.method not in request_method_list:
                return HttpResponseNotAllowed(request_method_list)
            return func(request, *args, **kwargs)
        return wraps(func, assigned=available_attrs(func))(inner)
    return decorator

Example 8

Project: pycon Source File: views.py
@login_required
def team_reject(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "applied":
            membership.state = "rejected"
            membership.save()
            messages.success(request, "Rejected application.")
    return redirect("team_detail", slug=membership.team.slug)

Example 9

Project: hackerunion.org Source File: views.py
@jsonify
@chapter_view(members_only=True)
def resign(request):
    if request.method == 'POST':
        form = LeadResignForm(request, data=request.POST)

        if form.is_valid():
            form.save()
            return json.success({})

        return json.error(form.errors)
    return HttpResponseNotAllowed(['POST'])

Example 10

Project: readthedocs.org Source File: private.py
@login_required
def project_notifications_delete(request, project_slug):
    """Project notifications delete confirmation view"""
    if request.method != 'POST':
        return HttpResponseNotAllowed('Only POST is allowed')
    project = get_object_or_404(Project.objects.for_admin_user(request.user),
                                slug=project_slug)
    try:
        project.emailhook_notifications.get(email=request.POST.get('email')).delete()
    except EmailHook.DoesNotExist:
        try:
            project.webhook_notifications.get(url=request.POST.get('email')).delete()
        except WebHook.DoesNotExist:
            raise Http404
    project_dashboard = reverse('projects_notifications', args=[project.slug])
    return HttpResponseRedirect(project_dashboard)

Example 11

Project: django-calendartools Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        allowed_methods = [m for m in self.http_method_names if hasattr(self, m)]
        logger.warning('Method Not Allowed (%s): %s' % (request.method, request.path),
            extra={
                'status_code': 405,
                'request': self.request
            }
        )
        return http.HttpResponseNotAllowed(allowed_methods)

Example 12

Project: zulip Source File: decorator.py
Function: require_post
def require_post(func):
    # type: (ViewFuncT) -> ViewFuncT
    @wraps(func)
    def wrapper(request, *args, **kwargs):
        # type: (HttpRequest, *Any, **Any) -> HttpResponse
        if (request.method != "POST"
            and not (request.method == "SOCKET"
                     and request.META['zulip.emulated_method'] == "POST")):
            if request.method == "SOCKET":
                err_method = "SOCKET/%s" % (request.META['zulip.emulated_method'],)
            else:
                err_method = request.method
            logging.warning('Method Not Allowed (%s): %s', err_method, request.path,
                            extra={'status_code': 405, 'request': request})
            return HttpResponseNotAllowed(["POST"])
        return func(request, *args, **kwargs)
    return wrapper # type: ignore # https://github.com/python/mypy/issues/1927

Example 13

Project: django-annotatetext Source File: views.py
Function: delete_annotation
def delete_annotation(request):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    if not request.user.is_staff:
        return HttpResponseForbidden()
    if not "annotation_id" in request.POST:
        return HttpResponseBadRequest()
    try:
        annoid = int(request.POST["annotation_id"])
    except (TypeError, ValueError):
        return HttpResponseBadRequest()
    annotation = get_object_or_404(Annotation, id=annoid)
    annotation.delete()
    return HttpResponseRedirect(request.POST.get("next","/"))

Example 14

Project: onlineweb4 Source File: views.py
Function: get
    def get(self, request, *args, **kwargs):
        """
        GET request are forbidden on delete views
        :param request: Django Request instance
        :param args: Positional arguments
        :param kwargs: Keyword arguments
        :return: 405 Method Not Allowed
        """

        return HttpResponseNotAllowed(permitted_methods=['POST'])

Example 15

Project: pycon Source File: views.py
Function: team_demote
@login_required
def team_demote(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "manager":
            membership.state = "member"
            membership.save()
            messages.success(request, "Demoted from manager.")
    return redirect("team_detail", slug=membership.team.slug)

Example 16

Project: courtlistener Source File: views.py
@ensure_csrf_cookie
@login_required
def share_visualization(request):
    if request.is_ajax():
        v = SCOTUSMap.objects.get(pk=request.POST.get('pk'), user=request.user)
        v.published = True
        v.save()
        return HttpResponse("It worked")
    else:
        return HttpResponseNotAllowed(
            permitted_methods=['POST'],
            content="Not an ajax request",
        )

Example 17

Project: django-cropduster Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        allowed_methods = [m for m in self.http_method_names if hasattr(self, m)]
        logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
            extra={
                'status_code': 405,
                'request': self.request
            }
        )
        return http.HttpResponseNotAllowed(allowed_methods)

Example 18

Project: mygpo Source File: decorators.py
Function: allowed_methods
def allowed_methods(methods):
    def decorator(fn):
        @wraps(fn)
        def tmp(request, *args, **kwargs):
            if request.method in methods:
                return fn(request, *args, **kwargs)
            else:
                return HttpResponseNotAllowed(methods)

        return tmp

    return decorator

Example 19

Project: GAE-Bulk-Mailer Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
            extra={
                'status_code': 405,
                'request': self.request
            }
        )
        return http.HttpResponseNotAllowed(self._allowed_methods())

Example 20

Project: synnefo Source File: urls.py
def volume_metadata_demux(request, volume_id):
    if request.method == 'GET':
        return views.list_volume_metadata(request, volume_id)
    elif request.method == 'POST':
        return views.update_volume_metadata(request, volume_id, reset=False)
    elif request.method == 'PUT':
        return views.update_volume_metadata(request, volume_id, reset=True)
    else:
        return HttpResponseNotAllowed(['GET', 'POST', 'PUT'])

Example 21

Project: wateronmars Source File: views.py
@loggedin_and_owner_required
def user_river_sieve(request,owner_name):
  if request.owner_user != request.user:
    return HttpResponseForbidden()
  if request.method == 'GET':
    return generate_user_sieve(request,owner_name)
  elif request.method == 'POST':
    return apply_to_user_sieve(request, owner_name)
  else:
    return HttpResponseNotAllowed(['GET','POST'])

Example 22

Project: ion Source File: groups.py
@eighth_admin_required
def add_group_view(request):
    if request.method == "POST":
        form = QuickGroupForm(request.POST)
        if form.is_valid():
            group = form.save()
            messages.success(request, "Successfully added group.")
            return redirect("eighth_admin_edit_group", group_id=group.id)
        else:
            messages.error(request, "Error adding group.")
            try:
                request.session["add_group_form"] = pickle.dumps(form)
            except (pickle.PicklingError, TypeError):
                """Prevent pickle errors."""
                pass
            return redirect("eighth_admin_dashboard")
    else:
        return http.HttpResponseNotAllowed(["POST"], "405: METHOD NOT ALLOWED")

Example 23

Project: pretix Source File: orders.py
    def get(self, *args, **kwargs):
        to = self.request.GET.get('status', '')
        if self.order.status == Order.STATUS_PENDING and to == 'c':
            return render(self.request, 'pretixcontrol/order/cancel.html', {
                'order': self.order,
            })
        elif self.order.status == Order.STATUS_PAID and to == 'r':
            return render(self.request, 'pretixcontrol/order/refund.html', {
                'order': self.order,
                'payment': self.payment_provider.order_control_refund_render(self.order),
            })
        else:
            return HttpResponseNotAllowed(['POST'])

Example 24

Project: timebank Source File: utils.py
Function: call
    def __call__(self, request, *args, **kwargs):
        self.request = request
        self.methods = [method.replace('_', '') for method in dir(self)\
            if callable(getattr(self, method)) and\
               method.replace('_', '') in self.available_methods]

        if request.method in self.methods:
            try:
                view = getattr(self, '__' + request.method + '__')
            except AttributeError:
                view = getattr(self, request.method)
            return view(*args, **kwargs)
        else:
            return HttpResponseNotAllowed(self.methods)

Example 25

Project: readthedocs.org Source File: private.py
@login_required
def project_redirects_delete(request, project_slug):
    """Project redirect delete view"""
    if request.method != 'POST':
        return HttpResponseNotAllowed('Only POST is allowed')
    project = get_object_or_404(Project.objects.for_admin_user(request.user),
                                slug=project_slug)
    redirect = get_object_or_404(project.redirects,
                                 pk=request.POST.get('id_pk'))
    if redirect.project == project:
        redirect.delete()
    else:
        raise Http404
    return HttpResponseRedirect(reverse('projects_redirects',
                                        args=[project.slug]))

Example 26

Project: regulations-core Source File: urls_utils.py
def by_verb_url(regex, name, by_verb):
    """Relatively clean way to segment url end points by HTTP Verb.
        @regex is the url regex as would be found in urls.py
        @name is also as would be found in urls.py
        @by_verb is a dictionary from verb (uppercase) to handler"""
    def wrapper(request, *args, **kwargs):
        verb = request.method.upper()
        if not by_verb:
            raise Http404
        elif verb in by_verb:
            return by_verb[verb](request, *args, **kwargs)
        else:
            return HttpResponseNotAllowed(by_verb.keys())
    if any(getattr(fn, 'csrf_exempt', False) for fn in by_verb.values()):
        wrapper = csrf_exempt(wrapper)

    return url(regex, wrapper, name=name)

Example 27

Project: zulip Source File: response.py
def json_method_not_allowed(methods):
    # type: (List[text_type]) -> text_type
    resp = HttpResponseNotAllowed(methods)
    resp.content = force_bytes(ujson.dumps({"result": "error",
        "msg": "Method Not Allowed",
        "allowed_methods": methods}))
    return resp

Example 28

Project: django-annotatetext Source File: views.py
Function: post_annotation
def post_annotation(request):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    form = NewAnnotationForm(request.POST)
    if form.is_valid():
        new_annotation = Annotation(content_type=form.cleaned_data["content_type"],
                    object_id=form.cleaned_data["object_id"],
                    user=request.user,
                    selection_start=form.cleaned_data["selection_start"],
                    selection_end=form.cleaned_data["selection_end"],
                    comment=form.cleaned_data["comment"],
                    flags=form.cleaned_data["flags"],
                    color=form.cleaned_data["color"])
        new_annotation.save()
        fragment = "#annotation-%d" % new_annotation.id
        return HttpResponseRedirect(request.POST.get("next","/") + fragment)
    else:
        return HttpResponseBadRequest()

Example 29

Project: decode-Django Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning('Method Not Allowed (%s): %s', request.method, request.path, 产生警告
            extra={
                'status_code': 405,
                'request': self.request
            }
        )
        return http.HttpResponseNotAllowed(self._allowed_methods())

Example 30

Project: PyClassLessons Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
            extra={
                'status_code': 405,
                'request': request
            }
        )
        return http.HttpResponseNotAllowed(self._allowed_methods())

Example 31

Project: django Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning(
            'Method Not Allowed (%s): %s', request.method, request.path,
            extra={'status_code': 405, 'request': request}
        )
        return http.HttpResponseNotAllowed(self._allowed_methods())

Example 32

Project: seriesly Source File: __init__.py
def is_post(func):
    def need_post_func(*args, **kwargs):
        request = args[0]
        if request.method == 'POST':
            return func(*args, **kwargs)
        else:
            return HttpResponseNotAllowed(["POST"])
    return need_post_func

Example 33

Project: edx-platform Source File: views.py
@csrf_exempt
@social.apps.django_app.utils.psa('{0}:complete'.format(URL_NAMESPACE))
def lti_login_and_complete_view(request, backend, *args, **kwargs):
    """This is a combination login/complete due to LTI being a one step login"""

    if request.method != 'POST':
        return HttpResponseNotAllowed('POST')

    request.backend.start()
    return complete(request, backend, *args, **kwargs)

Example 34

Project: symposion Source File: views.py
Function: team_accept
@login_required
def team_accept(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "applied":
            membership.state = "member"
            membership.save()
            messages.success(request, _("Accepted application."))
    return redirect("team_detail", slug=membership.team.slug)

Example 35

Project: courtlistener Source File: views.py
@ensure_csrf_cookie
@login_required
def restore_visualization(request):
    if request.is_ajax():
        v = SCOTUSMap.objects.get(pk=request.POST.get('pk'), user=request.user)
        v.deleted = False
        v.date_deleted = None
        v.save()
        return HttpResponse("It worked")
    else:
        return HttpResponseNotAllowed(
            permitted_methods=['POST'],
            content="Not an ajax request",
        )

Example 36

Project: django-ios-notifications Source File: api.py
    @method_decorator(api_authentication_required)
    @csrf_exempt
    def route(self, request, **kwargs):
        method = request.method
        if method in self.allowed_methods:
            if hasattr(self, method.lower()):
                if method == 'PUT':
                    request.PUT = QueryDict(request.body if django.VERSION >= (1, 4) else request.raw_post_data).copy()
                return getattr(self, method.lower())(request, **kwargs)

            return HttpResponseNotImplemented()

        return HttpResponseNotAllowed(self.allowed_methods)

Example 37

Project: courtlistener Source File: views.py
@ensure_csrf_cookie
@login_required
def privatize_visualization(request):
    if request.is_ajax():
        v = SCOTUSMap.objects.get(pk=request.POST.get('pk'), user=request.user)
        v.published = False
        v.save()
        return HttpResponse("It worked")
    else:
        return HttpResponseNotAllowed(
                permitted_methods=['POST'],
                content="Not an ajax request",
        )

Example 38

Project: pycon Source File: views.py
Function: team_accept
@login_required
def team_accept(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "applied":
            membership.state = "member"
            membership.save()
            messages.success(request, "Accepted application.")
    return redirect("team_detail", slug=membership.team.slug)

Example 39

Project: geonode Source File: views.py
Function: group_remove
@login_required
def group_remove(request, slug):
    group = get_object_or_404(GroupProfile, slug=slug)
    if request.method == 'GET':
        return render_to_response(
            "groups/group_remove.html", RequestContext(request, {"group": group}))
    if request.method == 'POST':

        if not group.user_is_role(request.user, role="manager"):
            return HttpResponseForbidden()

        group.delete()
        return HttpResponseRedirect(reverse("group_list"))
    else:
        return HttpResponseNotAllowed()

Example 40

Project: wateronmars Source File: views.py
Function: home
def home(request):

  """
  Return the home page of the site.
  """
  if request.method != 'GET':
    return HttpResponseNotAllowed(['GET'])
  d = add_base_template_context_data({},
                                     request.user.username,
                                     request.user.username)
  return render_to_response('home.html',d,
                            context_instance=RequestContext(request))

Example 41

Project: synnefo Source File: views.py
def create_new_keypair(request):
    """
    Response to generate private/public RSA key pair
    """

    get_user(request, settings.ASTAKOS_AUTH_URL)

    if request.method != "POST":
        return http.HttpResponseNotAllowed(["POST"])

    if not SUPPORT_GENERATE_KEYS:
        raise Exception("Application does not support ssh keys generation")

    if PublicKeyPair.user_limit_exceeded(request.user_uniq):
        return http.HttpResponseServerError("SSH keys limit exceeded")

    data = generate_keypair()
    return http.HttpResponse(json.dumps(data), content_type="application/json")

Example 42

Project: symposion Source File: views.py
@login_required
def team_promote(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "member":
            membership.state = "manager"
            membership.save()
            messages.success(request, _("Promoted to manager."))
    return redirect("team_detail", slug=membership.team.slug)

Example 43

Project: synnefo Source File: urls.py
def volume_item_demux(request, volume_id):
    if request.method == "GET":
        return views.get_volume(request, volume_id)
    elif request.method == "PUT":
        return views.update_volume(request, volume_id)
    elif request.method == "DELETE":
        return views.delete_volume(request, volume_id)
    else:
        return HttpResponseNotAllowed(["GET", "PUT", "DELETE"])

Example 44

Project: wateronmars Source File: views.py
def user_collection(request,owner_name):
  if request.method == 'GET':
    return get_user_collection(request,owner_name)
  elif request.method == 'POST':
    if request.user.username != owner_name:
      return HttpResponseForbidden()
    return post_to_user_collection(request,owner_name)
  else:
    return HttpResponseNotAllowed(['GET','POST'])

Example 45

Project: readthedocs.org Source File: private.py
@login_required
def project_users_delete(request, project_slug):
    if request.method != 'POST':
        return HttpResponseNotAllowed('Only POST is allowed')
    project = get_object_or_404(Project.objects.for_admin_user(request.user), slug=project_slug)
    user = get_object_or_404(User.objects.all(), username=request.POST.get('username'))
    if user == request.user:
        raise Http404
    project.users.remove(user)
    project_dashboard = reverse('projects_users', args=[project.slug])
    return HttpResponseRedirect(project_dashboard)

Example 46

Project: talk.org Source File: http.py
Function: require_http_methods
def require_http_methods(request_method_list):
    """
    Decorator to make a view only accept particular request methods.  Usage::

        @require_http_methods(["GET", "POST"])
        def my_view(request):
            # I can assume now that only GET or POST requests make it this far
            # ...

    Note that request methods should be in uppercase.
    """
    def decorator(func):
        def inner(request, *args, **kwargs):
            if request.method not in request_method_list:
                return HttpResponseNotAllowed(request_method_list)
            return func(request, *args, **kwargs)
        return wraps(func)(inner)
    return decorator

Example 47

Project: symposion Source File: views.py
Function: team_demote
@login_required
def team_demote(request, pk):
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
    membership = get_object_or_404(Membership, pk=pk)
    state = membership.team.get_state_for_user(request.user)
    if request.user.is_staff or state == "manager":
        if membership.state == "manager":
            membership.state = "member"
            membership.save()
            messages.success(request, _("Demoted from manager."))
    return redirect("team_detail", slug=membership.team.slug)

Example 48

Project: autotest Source File: resource_lib.py
Function: handle_request
    def handle_request(self):
        if self._request.method.upper() not in self._permitted_methods:
            return http.HttpResponseNotAllowed(self._permitted_methods)

        handler = getattr(self, self._request.method.lower())
        return handler()

Example 49

Project: Bundestagger Source File: utils.py
Function: is_method
def is_method(method, func):
    def need_method_func(*args, **kwargs):
        request = args[0]
        if request.method == method:
            return func(*args, **kwargs)
        else:
            return HttpResponseNotAllowed([method])
    return need_method_func

Example 50

Project: django-cbv Source File: base.py
Function: http_method_not_allowed
    def http_method_not_allowed(self, request, *args, **kwargs):
        allowed_methods = [m for m in self.http_method_names
                           if hasattr(self, m)]
        logger.warning(
            'Method Not Allowed (%s): %s' % (request.method, request.path),
            extra={
                'status_code': 405,
                'request': self.request
            }
        )
        return http.HttpResponseNotAllowed(allowed_methods)
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3