Come includere dati extra nella risposta del serializzatore Django?

Question

Sto cercando di cercare una vita con Django e jQuery. Quello che ho fatto è fare in modo che javascript richieda alcuni dati con la funzione getJSON, quindi ho impostato una vista in Django che restituisce una risposta JSON automatizzata dal serializzatore Django.

E questo funziona bene, restituisce una risposta json con il tipo di contenuto text / javascript. Per evitare di inviare tutti i dati, (molto che non ho bisogno) ho fatto questo:

response.write (serializers.serialize (" json " ;, soknad_list, fields = ('name', 'image', 'genre')))

Ma per esempio, il campo 'genere' è un campo manyToMany, quindi è possibile ottenere i valori da genre.all.0 per esempio e non solo l'ID del genere?

E il modello ha una funzione get_absolute _url , è possibile includerlo nella risposta JSON, se sì come?

Quindi suppongo che la mia domanda sia: è possibile includere elementi diversi dai dati di campo non elaborati nella risposta JSON, in caso contrario, come risolveresti il ??mio problema?

Answer 1

Ho scoperto che la cosa più semplice era non usare affatto il serializzatore. Non so perché non ci abbia pensato prima, ma ho appena usato una visualizzazione dell'elenco di oggetti generici e ho cambiato il mimetype in text / javascript e ho creato un modello JSON installato su un modello html.

Molto semplice, e in questo modo sono riuscito a ottenere tutti i dati desiderati nella risposta JSON. In questo modo puoi aggiungere tutto ciò che puoi aggiungere a un modello html in una risposta JSON, anche impaginando.

Esempio di estrazione della vista che ho creato:

    return object_list (request, queryset = object_list, template_name = 'search / results.js', template_object_name = 'risultato', paginate_by = 12, mimetype = 'text / javascript')

Answer 2

La serializzazione JSON di Django si basa su simplejson, che puoi usare direttamente ed estendere a piacimento per gestire qualsiasi tipo di oggetto. Quindi hai principalmente due opzioni qui: o costruisci manualmente un elenco di dicts con dati rilevanti e passalo a simplejson.dumps () (che per impostazione predefinita supporta stringhe, elenchi, dicts e numeri), o scrivi il tuo codificatore json che sa come per serializzare il set di dati specifico. FWIW, ecco un (non ben collaudato ma finora funzionato) codificatore json consapevole del modello Django:

from django.utils import simplejson
from django.utils import datetime_safe
from django.utils.functional import Promise
from django.utils.translation import force_unicode
from django.utils.encoding import smart_unicode
from django.core.serializers.json import DjangoJSONEncoder

class ModelJSONEncoder(DjangoJSONEncoder):
    """
    (simplejson) DjangoJSONEncoder subclass that knows how to encode fields.

    (adated from django.serializers, which, strangely, didn't
     factor out this part of the algorithm)
    """
    def handle_field(self, obj, field):
        return smart_unicode(getattr(obj, field.name), strings_only=True)

    def handle_fk_field(self, obj, field):
        related = getattr(obj, field.name)
        if related is not None:
            if field.rel.field_name == related._meta.pk.name:
                # Related to remote object via primary key
                related = related._get_pk_val()
            else:
                # Related to remote object via other field
                related = getattr(related, field.rel.field_name)
        return smart_unicode(related, strings_only=True)

    def handle_m2m_field(self, obj, field):
        if field.creates_table:
            return [
                smart_unicode(related._get_pk_val(), strings_only=True)
                for related
                in getattr(obj, field.name).iterator()
                ]

    def handle_model(self, obj):
        dic = {}
        for field in obj._meta.local_fields:
            if field.serialize:
                if field.rel is None:
                    dic[field.name] = self.handle_field(obj, field)
                else:
                    dic[field.name] = self.handle_fk_field(obj, field)
        for field in obj._meta.many_to_many:
            if field.serialize:
                dic[field.name] = self.handle_m2m_field(obj, field)
        return dic

    def default(self, obj):
        if isinstance(o, Promise):
            return force_unicode(o)

        if isinstance(obj, Model):
            return self.handle_model(obj)

        return super(ModelJSONEncoder, self).default(obj)

HTH

Answer 3

Esiste una pratica app / serializzatore di terze parti di django che ti permetterà di includere dati extra. Consente inoltre di includere relazioni modello ed escludere un elenco di campi.

È disponibile all'indirizzo http://code.google.com/p/wadofstuff/wiki/DjangoFullSerializers