django/core/serializers/xml_serializer.py

   1 """
   2 XML serializer.
   3 """
   4
   5 from django.conf import settings
   6 from django.core.serializers import base
   7 from django.db import models
   8 from django.utils.xmlutils import SimplerXMLGenerator
   9 from django.utils.encoding import smart_unicode
  10 from xml.dom import pulldom
  11
  12 class Serializer(base.Serializer):
  13     """
  14     Serializes a QuerySet to XML.
  15     """
  16
  17     def indent(self, level):
  18         if self.options.get('indent', None) is not None:
  19             self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
  20
  21     def start_serialization(self):
  22         """
  23         Start serialization -- open the XML document and the root element.
  24         """
  25         self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
  26         self.xml.startDocument()
  27         self.xml.startElement("django-objects", {"version" : "1.0"})
  28
  29     def end_serialization(self):
  30         """
  31         End serialization -- end the document.
  32         """
  33         self.indent(0)
  34         self.xml.endElement("django-objects")
  35         self.xml.endDocument()
  36
  37     def start_object(self, obj):
  38         """
  39         Called as each object is handled.
  40         """
  41         if not hasattr(obj, "_meta"):
  42             raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
  43
  44         self.indent(1)
  45         self.xml.startElement("object", {
  46             "pk"    : smart_unicode(obj._get_pk_val()),
  47             "model" : smart_unicode(obj._meta),
  48         })
  49
  50     def end_object(self, obj):
  51         """
  52         Called after handling all fields for an object.
  53         """
  54         self.indent(1)
  55         self.xml.endElement("object")
  56
  57     def handle_field(self, obj, field):
  58         """
  59         Called to handle each field on an object (except for ForeignKeys and
  60         ManyToManyFields)
  61         """
  62         self.indent(2)
  63         self.xml.startElement("field", {
  64             "name" : field.name,
  65             "type" : field.get_internal_type()
  66         })
  67
  68         # Get a "string version" of the object's data (this is handled by the
  69         # serializer base class).
  70         if getattr(obj, field.name) is not None:
  71             value = self.get_string_value(obj, field)
  72             self.xml.characters(smart_unicode(value))
  73         else:
  74             self.xml.addQuickElement("None")
  75
  76         self.xml.endElement("field")
  77
  78     def handle_fk_field(self, obj, field):
  79         """
  80         Called to handle a ForeignKey (we need to treat them slightly
  81         differently from regular fields).
  82         """
  83         self._start_relational_field(field)
  84         related = getattr(obj, field.name)
  85         if related is not None:
  86             if field.rel.field_name == related._meta.pk.name:
  87                 # Related to remote object via primary key
  88                 related = related._get_pk_val()
  89             else:
  90                 # Related to remote object via other field
  91                 related = getattr(related, field.rel.field_name)
  92             self.xml.characters(smart_unicode(related))
  93         else:
  94             self.xml.addQuickElement("None")
  95         self.xml.endElement("field")
  96
  97     def handle_m2m_field(self, obj, field):
  98         """
  99         Called to handle a ManyToManyField. Related objects are only
 100         serialized as references to the object's PK (i.e. the related *data*
 101         is not dumped, just the relation).
 102         """
 103         self._start_relational_field(field)
 104         for relobj in getattr(obj, field.name).iterator():
 105             self.xml.addQuickElement("object", attrs={"pk" : smart_unicode(relobj._get_pk_val())})
 106         self.xml.endElement("field")
 107
 108     def _start_relational_field(self, field):
 109         """
 110         Helper to output the <field> element for relational fields
 111         """
 112         self.indent(2)
 113         self.xml.startElement("field", {
 114             "name" : field.name,
 115             "rel"  : field.rel.__class__.__name__,
 116             "to"   : smart_unicode(field.rel.to._meta),
 117         })
 118
 119 class Deserializer(base.Deserializer):
 120     """
 121     Deserialize XML.
 122     """
 123
 124     def __init__(self, stream_or_string, **options):
 125         super(Deserializer, self).__init__(stream_or_string, **options)
 126         self.event_stream = pulldom.parse(self.stream)
 127
 128     def next(self):
 129         for event, node in self.event_stream:
 130             if event == "START_ELEMENT" and node.nodeName == "object":
 131                 self.event_stream.expandNode(node)
 132                 return self._handle_object(node)
 133         raise StopIteration
 134
 135     def _handle_object(self, node):
 136         """
 137         Convert an <object> node to a DeserializedObject.
 138         """
 139         # Look up the model using the model loading mechanism. If this fails,
 140         # bail.
 141         Model = self._get_model_from_node(node, "model")
 142
 143         # Start building a data dictionary from the object.  If the node is
 144         # missing the pk attribute, bail.
 145         pk = node.getAttribute("pk")
 146         if not pk:
 147             raise base.DeserializationError("<object> node is missing the 'pk' attribute")
 148
 149         data = {Model._meta.pk.attname : Model._meta.pk.to_python(pk)}
 150
 151         # Also start building a dict of m2m data (this is saved as
 152         # {m2m_accessor_attribute : [list_of_related_objects]})
 153         m2m_data = {}
 154
 155         # Deseralize each field.
 156         for field_node in node.getElementsByTagName("field"):
 157             # If the field is missing the name attribute, bail (are you
 158             # sensing a pattern here?)
 159             field_name = field_node.getAttribute("name")
 160             if not field_name:
 161                 raise base.DeserializationError("<field> node is missing the 'name' attribute")
 162
 163             # Get the field from the Model. This will raise a
 164             # FieldDoesNotExist if, well, the field doesn't exist, which will
 165             # be propagated correctly.
 166             field = Model._meta.get_field(field_name)
 167
 168             # As is usually the case, relation fields get the special treatment.
 169             if field.rel and isinstance(field.rel, models.ManyToManyRel):
 170                 m2m_data[field.name] = self._handle_m2m_field_node(field_node, field)
 171             elif field.rel and isinstance(field.rel, models.ManyToOneRel):
 172                 data[field.attname] = self._handle_fk_field_node(field_node, field)
 173             else:
 174                 if field_node.getElementsByTagName('None'):
 175                     value = None
 176                 else:
 177                     value = field.to_python(getInnerText(field_node).strip())
 178                 data[field.name] = value
 179
 180         # Return a DeserializedObject so that the m2m data has a place to live.
 181         return base.DeserializedObject(Model(**data), m2m_data)
 182
 183     def _handle_fk_field_node(self, node, field):
 184         """
 185         Handle a <field> node for a ForeignKey
 186         """
 187         # Check if there is a child node named 'None', returning None if so.
 188         if node.getElementsByTagName('None'):
 189             return None
 190         else:
 191             return field.rel.to._meta.get_field(field.rel.field_name).to_python(
 192                        getInnerText(node).strip())
 193
 194     def _handle_m2m_field_node(self, node, field):
 195         """
 196         Handle a <field> node for a ManyToManyField.
 197         """
 198         return [field.rel.to._meta.pk.to_python(
 199                     c.getAttribute("pk"))
 200                     for c in node.getElementsByTagName("object")]
 201
 202     def _get_model_from_node(self, node, attr):
 203         """
 204         Helper to look up a model from a <object model=...> or a <field
 205         rel=... to=...> node.
 206         """
 207         model_identifier = node.getAttribute(attr)
 208         if not model_identifier:
 209             raise base.DeserializationError(
 210                 "<%s> node is missing the required '%s' attribute" \
 211                     % (node.nodeName, attr))
 212         try:
 213             Model = models.get_model(*model_identifier.split("."))
 214         except TypeError:
 215             Model = None
 216         if Model is None:
 217             raise base.DeserializationError(
 218                 "<%s> node has invalid model identifier: '%s'" % \
 219                     (node.nodeName, model_identifier))
 220         return Model
 221
 222
 223 def getInnerText(node):
 224     """
 225     Get all the inner text of a DOM node (recursively).
 226     """
 227     # inspired by http://mail.python.org/pipermail/xml-sig/2005-March/011022.html
 228     inner_text = []
 229     for child in node.childNodes:
 230         if child.nodeType == child.TEXT_NODE or child.nodeType == child.CDATA_SECTION_NODE:
 231             inner_text.append(child.data)
 232         elif child.nodeType == child.ELEMENT_NODE:
 233             inner_text.extend(getInnerText(child))
 234         else:
 235            pass
 236     return u"".join(inner_text)
 237