La sérialisation JSON de Google App Engine modèles

C'est la solution la plus simple que j'ai trouvé. Il nécessite seulement 3 lignes de codes.

Simplement ajouter une méthode à votre modèle de retourner un dictionnaire:

class DictModel(db.Model):
    def to_dict(self):
       return dict([(p, unicode(getattr(self, p))) for p in self.properties()])

SimpleJSON fonctionne désormais correctement:

class Photo(DictModel):
   filename = db.StringProperty()
   title = db.StringProperty()
   description = db.StringProperty(multiline=True)
   date_taken = db.DateTimeProperty()
   date_uploaded = db.DateTimeProperty(auto_now_add=True)
   album = db.ReferenceProperty(Album, collection_name='photo')

from django.utils import simplejson
from google.appengine.ext import webapp

class PhotoHandler(webapp.RequestHandler):
   def get(self):
      photos = Photo.all()
      self.response.out.write(simplejson.dumps([p.to_dict() for p in photos]))

Pour sérialiser des modèles, ajouter des json encodeur comme dans le python suivant:

import datetime
from google.appengine.api import users
from google.appengine.ext import db
from django.utils import simplejson

class jsonEncoder(simplejson.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return obj.isoformat()

        elif isinstance(obj, db.Model):
            return dict((p, getattr(obj, p)) 
                        for p in obj.properties())

        elif isinstance(obj, users.User):
            return obj.email()

        else:
            return simplejson.JSONEncoder.default(self, obj)


# use the encoder as: 
simplejson.dumps(model, cls=jsonEncoder)

Ce code:

• une date comme isoformat chaîne (par cette suggestion),
• un modèle comme dict de ses propriétés,
• un utilisateur que son e-mail.

Pour décoder la date, vous pouvez utiliser ce code javascript:

function decodeJsonDate(s){
  return new Date( s.slice(0,19).replace('T',' ') + ' GMT' );
} // Note that this function truncates milliseconds.

Note: Merci à l'utilisateur pydave qui a modifié ce code pour le rendre plus lisible. J'avais eu à l'origine utilisé python si/d'autre des expressions pour exprimer jsonEncoder en moins de lignes comme suit: (j'ai ajouté quelques commentaires et utilisé google.appengine.ext.db.to_dict, pour la rendre plus claire que l'original.)

class jsonEncoder(simplejson.JSONEncoder):
  def default(self, obj):
    isa=lambda x: isinstance(obj, x) # isa(<type>)==True if obj is of type <type>
    return obj.isoformat() if isa(datetime.datetime) else \
           db.to_dict(obj) if isa(db.Model) else \
           obj.email()     if isa(users.User) else \
           simplejson.JSONEncoder.default(self, obj)

Pour les cas simples, j'aime l'approche préconisée ici à la fin de l'article:

  # after obtaining a list of entities in some way, e.g.:
  user = users.get_current_user().email().lower();
  col = models.Entity.gql('WHERE user=:1',user).fetch(300, 0)

  # ...you can make a json serialization of name/key pairs as follows:
  json = simplejson.dumps(col, default=lambda o: {o.name :str(o.key())})

L'article contient également, à l'autre extrémité du spectre, un complexe sérialiseur classe qui enrichit django (et ne nécessitent _meta -- ne savez pas pourquoi vous obtenez une erreur à propos _meta manquant, peut-être le bug décrit ici) avec la capacité de sérialiser calculé les propriétés /méthodes. La plupart du temps, vous sérialisation des besoins se situe quelque part entre les deux, et pour ceux d'une approche introspective comme @David Wilson est peut-être préférable.

Si vous utilisez app-engine-patch il déclare automatiquement la _meta attribut pour vous, et puis vous pouvez utiliser django.core.serializers comme vous le feriez normalement sur django modèles (comme dans le traîneau du code).

App-engine-patch a quelques autres fonctionnalités intéressantes telles dispose d'une authentification hybride (django + comptes google), et la partie admin de django fonctionne.

J'ai étendu le JSON classe de Codeur écrit par dpatru à l'appui:

• Les résultats de la requête propriétés (par exemple de la voiture.owner_set)
• ReferenceProperty récursivement le transformer en JSON

• Propriétés de filtrage - seules les propriétés avec un verbose_name sera encodé en JSON

  class DBModelJSONEncoder(json.JSONEncoder):
      """Encodes a db.Model into JSON"""
  
      def default(self, obj):
          if (isinstance(obj, db.Query)):
              # It's a reference query (holding several model instances)
              return [self.default(item) for item in obj]
  
          elif (isinstance(obj, db.Model)):
              # Only properties with a verbose name will be displayed in the JSON output
              properties = obj.properties()
              filtered_properties = filter(lambda p: properties[p].verbose_name != None, properties)
  
              # Turn each property of the DB model into a JSON-serializeable entity
              json_dict = dict([(
                      p,
                      getattr(obj, p)
                          if (not isinstance(getattr(obj, p), db.Model))
                          else
                      self.default(getattr(obj, p)) # A referenced model property
                  ) for p in filtered_properties])
  
              json_dict['id'] = obj.key().id() # Add the model instance's ID (optional - delete this if you do not use it)
  
              return json_dict
  
          else:
              # Use original JSON encoding
              return json.JSONEncoder.default(self, obj)

Il y a une méthode, "Modèle.propriétés()", définie pour toutes les classes du Modèle. Il retourne le dict que vous cherchez.

from django.utils import simplejson
class Photo(db.Model):
  # ...

my_photo = Photo(...)
simplejson.dumps(my_photo.properties())

Voir Les propriétés du modèle dans les docs.