¿Cómo incluir datos adicionales en la respuesta del serializador Django?

Question

Estoy tratando de hacer una búsqueda de vidas con Django y jQuery. Lo que he hecho es hacer que el javascript solicite algunos datos con la función getJSON, luego he configurado una vista en Django que devuelve una respuesta JSON automatizada por el serializador Django.

Y esto funciona bien, devuelve una respuesta json con el tipo de contenido text / javascript. Para evitar enviar todos los datos, (mucho que no necesito) hice esto:

response.write (serializers.serialize (" json " ;, soknad_list, fields = ('nombre', 'imagen', 'género')))

Pero, por ejemplo, el campo 'género' es un campo manyToMany, por lo tanto, ¿es posible obtener los valores de genre.all.0 por ejemplo y no solo el ID del género?

Y el modelo tiene una función get_absolute _url , ¿es posible incluir esto en la respuesta JSON? Si es así, ¿cómo?

Supongo que mi pregunta es, ¿es posible incluir cosas que no sean los datos de campo sin procesar en la respuesta JSON? Si no, ¿cómo resolvería mi problema?

Answer 1

Descubrí que lo más simple era no usar el serializador. No sé por qué no pensé en esto antes, pero simplemente usé una vista genérica de la lista de objetos y cambié el tipo MIME a texto / javascript e hice una plantilla JSON con una plantilla html.

Muy simple, y de esa manera logré obtener todos los datos que quería en la respuesta JSON. De esta manera puede agregar todo lo que puede agregar a una plantilla html en una respuesta JSON, incluso paginando.

Ejemplo de extracción de la vista que he creado:

    devolver object_list (solicitud, queryset = object_list, template_name = 'search / results.js', template_object_name = 'result', paginate_by = 12, mimetype = 'text / javascript')

Answer 2

La serialización JSON de Django se basa en simplejson, que puede usar directamente y extender a voluntad para manejar cualquier tipo de objetos. Por lo tanto, aquí tiene la mayoría de las dos opciones: crear manualmente una lista de dictados con datos relevantes y pasarla a simplejson.dumps () (que por defecto admite cadenas, listas, dictados y números), o escribir su propio codificador json que sepa cómo para serializar su conjunto de datos específico. FWIW, aquí hay un codificador json compatible con el modelo Django (no está bien probado, pero hasta el momento funcionó):

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

Existe una aplicación / serializador de terceros de Django que te permitirá incluir datos adicionales. También le permite incluir relaciones de modelo y excluir una lista de campos.

Está disponible en http://code.google.com/p/wadofstuff/wiki/DjangoFullSerializers