Skip to main content
AJAX requests for Ponies™

How many times you found yourself writing some views in Django to handle an AJAX request? And how many times you just copy-pasted a view written for synchronous requests and edited them to return a JSON object? And so, how many times you forgot that that @login_required will actually redirect the request to the login page in case of anonymous users? If this happened to you as many times as it happened to us, you may be start considering using django-ajaxutils.

Django-ajaxutils allows you to define a view as an AJAX view that will return a JSON object and that will handle correctly errors such as user not authenticated and invalid requests. Everything through a simple decorator!

https://secure.travis-ci.org/ahref/django-ajaxutils.png?branch=master

Installation

Just go for:

pip install django-ajaxutils

to do the magic.

Usage

If you want to define a view for handling an AJAX request, you have just to decorate it with @ajax and return a dictionary representing the object to be returned as JSON. If you lack of imagination, check this out:

from ajaxutils.decorators import ajax


@ajax()
def check_for_some_task(request):
    exit_status = get_status_of_some_task()
    if exit_status is None:
        return {
            'status': 'pending'
        }

    return {
        'status': 'completed',
        'exit_status': exit_status
    }

Requiring authentication

If your view requires the user to be authenticated, just write it:

@ajax(login_required=True)
def some_very_private_view(request):
    data = perform_something_private()
    return {
        'data': data
    }

In case of an unauthenticated request, a 401: Unauthorized response containing the following JSON object will be returned:

{
    'status': 'error',
    'error': 'Unauthorized',
}

Requiring GET / POST

@ajax also allows you a quick way to require a particular method for requesting the view. For example, if your view will edit some server-side data, you may accept only POST requests. With @ajax this is as easy as remembering the first two decimal digits of PI (which are 1 and 4, btw):

@ajax(login_required=True, require_POST=True)
def submit_my_data(request):
    new_obj = save_my_data()
    return {
        'id': new_obj.pk
    }

This will return a 405: Method not allowed response with the following JSON object in case of illegal requests:

{
    'status': 'error',
    'error': 'Method not allowed',
}

You can of course set require_GET=True for GET requests.

You can also use this alternative syntax:

@ajax(require="GET")
def my_cool_view(request):
    return {
        'hello': 'world!'
    }

Custom Status Codes

What if you don’t want to return an HTTP 200? Do you want to return a 404? Write:

from django.http import Http404

@ajax()
def my_cool_view(request):
    raise Http404

This returns:

{
    'status': 'error',
    'error': 'Not found',
}

Or maybe a 400 - Bad Request:

from django.http import HttpResponseBadRequest

@ajax()
def my_cool_view(request):
    return HttpResponseBadRequest('My error message')

This returns:

{
    'status': 'error',
    'error': 'My error message',
}

and the HTTP response has status code 400.

Another syntax, more Flask-ish:

@ajax()
def my_cool_view(request):
    return {
        "i'm a": 'teapot'
    }, 418

From infinity import json

Tired of writing infinite import statements to choose the best json module? Let ajaxutils do it for you:

from ajaxutils import json

At the moment, ajaxutils prefers simplejson over the stdlib json. No other json module is used. In the future we will probably provide support to ujson using a Django setting.

Changelog

v0.2

  • Moved JsonResponse to ajaxutils.http

  • Added Custom Status Codes handling

  • Added documentation for @ajax(require=METHOD)

  • Added “from ajaxutils import json”

Metadata

Release files for django-ajaxutils 0.2

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for django-ajaxutils 0.2
File Size Uploaded Provenance
django-ajaxutils-0.2.tar.gz 4.5 kB Without provenance Details

Release files / django-ajaxutils-0.2.tar.gz

Download URL django-ajaxutils-0.2.tar.gz
Size 4.5 kB
Tags Source
SHA-256 checksum
How to use checksums
0a9a7ced6342c09eb4a339af6734e172fa0ba994b60a8ce53ef99e16e1b52df5
BLAKE2b-256 checksum
How to use checksums
8b57afc9f562dff5ee0c5aa6120d79575c624adb3daf606b2337c7090223a834
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No

Security for django-ajaxutils 0.2

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page