Probably this is so that you can store the raw value in the db under field.attname, while transparently accessing a converted value via field.name

Probably to make that mechanism work you are needing a descriptor class, much like a ForeignKey field has a ReverseSingleRelatedObjectDescriptor which handles the get/set functionality for the field – allowing you to get or set model instances, while a plain id is saved in the db under field.attname.

Since there’s no specific docs on how to do this you probably started by copying Django’s example, like the ForeignKey mechanism above.

Long story short, there’s some untidy magic in Model.__init__ and a gotcha or two that can trip you up: https://code.djangoproject.com/ticket/17080

TLDR?

Ok, just be sure your custom descriptor subclasses property, instead of object even though all the existing ones built into Django subclass object.

jQuery.extend({
    arrayCompare: function (arrayA, arrayB) {
        if (arrayA.length != arrayB.length) { return false; }
        // sort modifies original array
        // (which are passed by reference to our method!)
        // so clone the arrays before sorting
        var a = jQuery.extend(true, [], arrayA);
        var b = jQuery.extend(true, [], arrayB);
        a.sort();
        b.sort();
        for (var i = 0, l = a.length; i < l; i++) {
            if (a[i] !== b[i]) {
                return false;
            }
        }
        return true;
    }
});

var a = [1, 2, 3];
var b = [2, 3, 4];
var c = [3, 4, 2];

jQuery.arrayCompare(a, b);
// false

jQuery.arrayCompare(b, c);
// true

// c is still unsorted [3, 4, 2]

Currently only handles the ‘dict of vars’ style substitution and probably doesn’t handle escaping and other edge-cases properly. Fine for a bit of quick and dirty string action though.

Anyone actually sending back XML in their Ajax app these days?

I find, if I have the choice, I’m using JSON for sending the data back. Then, for those times where you don’t want to duplicate all of the templating logic from the server in your Javascript code just to ‘Ajax’ a form or something, I find I will often render a bit of HTML and send that back, even if it feels a bit dirty. It’s easy and there’s a certain DRYness that’s undeniable.

So it’s only a matter of time before you start thinking, as a did, “Sure, I could make half a dozen separate XHR requests, but what I really need to do here is send back a package of identifiable HTML and JSON chunks.”

Some kind of multi-part response basically. Hang on, I’ve heard of that before… something to do with email, or file uploads?

A quick search reveals some talk about how to do a multi-part form post via Ajax: basically it’s not possible, the XHR object doesn’t support it. That’s not what we want though… we want to parse multi-part data in the response.

It turns out all the browsers, except (of course) IE6, will give you access to the response body while the response is still loading. The multi-part format is pretty simple, each part is just separated by a delimiter string (see the IETF RFC here). So, we can write some js to parse the multi-part response and make it happen!

Well, actually I figured someone must have done it already.

I found this one first: mpAjax

It does the job, but doesn’t exactly follow the RFC. The script requires the boundary delimiter to have a random id appended to the end, where as the RFC seems to specify that the delimiters should all be identical. The RFC also provides a mechanism for specifying a different mime type for each part, with mpAjax your script will need to know in advance which mime type to expect for each part.

Bingo! DUI Stream

The other thing with mpAjax is that it doesn’t try and process each part as they arrive, it waits for the whole response before parsing. Well for the team at Digg it seems the ‘streaming’ aspect was the main point. They have an interesting demo where even stream down dozens of small (Base64-encoded…) GIF images via ajax, all in one request.

All good, they do streaming and they stick close to the RFC, allowing you to specify the mime type for each part. They put it up on GitHub in April ’09 promising a few enhancements and some more documentation would be forthcoming, but nothing has happened publicly since then.

After using the code a bit I took it on myself to fork and implement a few changes, such as: make the request via either GET or POST, make the request more than once (!), let it work – albeit without streaming – in IE6, and the ability to parse your own custom headers for each part.

Code is here on GitHub.

Django…

So, how do you output a multi-part http response from Django?

Glad you asked. Here’s four solutions (hacked out of a recent project I worked on)… all of which sub-class the django HttpResponse.

First up is a kind of base MultipartHttpResponse. Next is a sub-class of that which works with mpAjax.

Third is a sub-class that does true streaming, via a generator in the _make_body method. This is built-in django goodness, though be careful as I’ve read that some middleware modules can negate the streaming behaviour (they will consume the whole generator before passing on any output). This one will work with DUI Stream.

To use it, pass a list of (mime-type str, body) tuples as parts when initialising the response, eg:

parts = [
    (MIME_HTML,
     """<div>response</div>"""),
    (MIME_JSON,
    json.dumps(data)),
]

return StreamingMultipartHttpResponse(parts)

Easy.

Finally, there’s a sub-class of the above designed to take advantage of my tweaked version of the DUI Stream js. Code is as above, except that it takes a dict of headers in place of the mime-type string above, eg:

parts = [
    ({
        'Content-Type': MIME_HTML,
        'Content-ID': '%s|%s' % (i, x),
    },
     """<div>response</div>"""),
    ({
        'Content-Type': MIME_JSON,
        'Content-ID': '%s|%s' % (i, x+1),
    },
    json.dumps(data)),
]

return DUI_MXHR_Response(parts)

Cool?

You can check the DUI examples for the js side, but the code is nice and simple. You can register a handler function for each mime-type, which will fire whenever a part with that type has finished streaming down, eg:

    dui_stream_obj = new DUI.Stream();

    dui_stream_obj.listen('application/json', handleJson);
    dui_stream_obj.listen('text/html', handleHtml);
    dui_stream_obj.listen('complete', streamCheckComplete);

Nice.

If you’re using my version then your handler function will receive an array of headers for that part, eg:

function handleHtml(data, headers) {
    var path = headers['Content-ID'];
    ...

Done.

If you’ve ever needed this:

Then here’s some handy code to do that.

You can customise and use this action (actually a sort of action factory function) with any of your models which need it.

With a ModelChoiceField you don’t specify the choices directly, you give a queryset of results from the db, which just has a flat structure.

I’ve made a ‘GroupedModelChoiceField’ that allows to output optiongroups based on a field from the model in your queryset. Code is here on djangosnippets… simple as that!

“Django supports adding custom methods for accessing the ORM through the ability to implement a custom Manager… The downside of this approach is that methods added to a manager can only be used at the beginning of the chain.”

My modest contribution is in this comment on DjangoSnippets…

I think the snippet is fairly self explanatory:

http://www.djangosnippets.org/snippets/1830/

In this post I’ll be extending FilteredSelectMultiple to show the tree structure in the list:

The code is pretty clean – no patches to hack! – and you can get it here on Django snippets.

You’ll also need to put this javascript file on your media path: mptt_m2m_selectbox.js

Once you’ve got those, you just need to use it in your admin form:

class ProductForm(forms.ModelForm):
    categories = MPTTModelMultipleChoiceField(
                    ProductCategory.objects.all(),
                    widget = MPTTFilteredSelectMultiple("Categories",False,attrs={'rows':'10'})
                )
    class Meta:
        model= ProductCategory

class ProductAdmin(admin.ModelAdmin):
    form = ProductForm

And that’s about it. You could go further of course, for example by rendering the select list in a fixed-width font you could draw the tree branches in ascii. Probably it would also be useful to show a different representation in the right-hand list (eg to represent the parents of selected categories somehow).

If you make any enhancements or find any bugs then please comment back!