django view + AJAX：如何按照POST形式检索数据

Question

I have a query form that can generate a large json object from data on the server. Ideally, on submit the user should be redirected to the results page (+progress bar) that gets updated from the AJAX request until the results have been generated and are ready to display.

Currently, when the user submits the form, they're left hanging on the queryForm page whilst the results are generated. What's the correct django-way to implement a callback for dataFromQuery once it's completed?

Here is a stripped down version of my class-based view:

class QueryForm(generic.View):
form_class = ReturnQuery
template_name = 'myapp/form/queryForm.html'

    def get(self, request, *args, **kwargs):
    #render form
    return render(request, self.template_name, {'form': form})

    def post(self, request, *args, **kwargs):
    form = self.form_class(request.POST)

        if form.is_valid():
            # <process form cleaned data>
            print(request.POST)
            print(form.cleaned_data)
            # continues to build results object (json) which can take 
            # any length of time

        return render(request, 'myapp/form/queryResults.html', {
                    'dataFromQuery': dataFromQuery,
                })

I tried is_ajax() within the POST method:

 if request.is_ajax():
            results = { "progress" : {'progress':1} }
            try:
              dataFromQuery
            except NameError:
              dataFromQuery_exists = False
            else:
              dataFromQuery_exists = True
              results['data']=dataFromQuery

            return JsonResponse(results)

but dataFromQuery isn't being passed to the results object once it's complete.

JS:

var refreshIntervalId = setInterval(function(){
    $.ajax({type: "POST",url: '/website/queryForm/', data: {csrfmiddlewaretoken : csrftoken}, dataType:'json', success: function(results){ //do something with results }})
});

I've looked at template responses but I'm not sure how they can help here as it looks like the callback is executed once the page render is complete. Any help would be appreciated.

EDIT: I may have been a little unclear. The results.progress is retrieved on successful AJAX, but this line: results['data']=dataFromQuery isn't updating once the results have been generated.

Answer 1

Consider using some task queue/manager, like celery . Just create task that will produce your result, monitor it somehow and display to user current progress of creating response.

Answer 2

HTTP works with request -> response. Django can't 'push' messages (like progress) to the browser without it asking. What you could do is use polling, which is sending an ajax request every X seconds to get the status. This solution is not that simple to create, as you'll need a seperate function that returns the progress, and do the actualling progressing in a seperate thread (asynchronous).

depending on the situation, a much easier solution is let your user know that data is being processed, by using a spinner for example.

Answer 3

I am currently developing a very similar case. What you are trying to do is not so trivial. Unfortunately Django is totally synchronous by nature, therefor your AJAX calls will be blocking on the Python side.

As already suggested use some kind of task management tool. I use celery which is easy to use and fully integrated on Django.

Your code will look like this

class QueryForm(generic.View):
    ...
    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST)
        token = generate_request_token()

        if form.is_valid():
           celery_task.apply_async(<token>, <parameters>) <-- this returns immediately

           return render(request, 'myapp/form/queryResults.html', {
                    'token': <token>,
                })

Your celery_task is now calculating the results in the background and will store the results once it has finished. Where you want to store the results is your choice.

You still need to create another Django endpoint to get the result. Map it to something like www.yoursite.com/queryForm/data'. Something like this

def get(self, request, *args, **kwargs):
    #return data in JSON format
    return JsonResponse(get_data_from_storage(request.<token>))

get_data_from_storage will look into the result storage and check if the results are ready or partially ready. (Another approach is to check the status of the celery_task. When it is done, the results must be ready)

Then on the JS side, as soon as the user submit the QueryForm, he is redirected to www.yoursite.com/queryResults.html/TOKEN (result page), or find a way to pass the token to the result page.

What you can do now is to use TOKEN to query the backend for data belonging to that token. Once inside the result page you do something like.

var refreshIntervalId = setInterval(function(){
    $.ajax({type: "GET", url: '/website/queryForm/data', data: {token: <token>}, dataType:'json', success: function(results){ if (results) {// do something} }})
});

The JS approach above is called continuous polling and it is not optimal. (See Socket.io for alternative, but you will need an additional component like Node.js, I went this way). The rendering is finally done on the frontend side. Each time you get new results, you update the page with fresh data.

There are other approaches, but currently this seemed the most straightforward to me.

Alternatives to Celery are:

• Threads (if u know what you are doing)
• RabbitMQ/ZeroMQ
• Tornado (but might not be easy to integrate with Django)
• Gevent