def get_model_class(self, model_path):
if not model_path:
raise base.DeserializationError(
"Model path must exist, but given '{}'".format(model_path))
try:
return apps.get_model(model_path)
except (LookupError, TypeError):
raise base.DeserializationError(
"Model path can not be found: path: {}".format(model_path))
def _handle_object(self, node):
"""
Convert an <object> node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object. If the node is
# missing the pk attribute, bail.
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
data = {Model._meta.pk.attname: Model._meta.pk.to_python(pk)}
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
# Deseralize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail (are you
# sensing a pattern here?)
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError(
"<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly.
field = Model._meta.get_field(field_name)
# As is usually the case, relation fields get the special treatment.
if field.rel and isinstance(field.rel, models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
if field_node.getElementsByTagName('None'):
value = None
elif isinstance(field, TransField):
value = field.to_python(
xml_serializer.getInnerText(
field_node).strip()).raw_data
else:
value = field.to_python(
xml_serializer.getInnerText(field_node).strip())
data[field.name] = value
# Return a DeserializedObject so that the m2m data has a place to live.
return base.DeserializedObject(Model(**data), m2m_data)
def _get_model(self, model_identifier):
"""
Look up model
"""
if not model_identifier:
raise base.DeserializationError(
"Worksheet is missing the required model name")
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError(
"Worksheet has invalid model identifier: '%s'" %
(model_identifier))
def field_is_nonrelational(self, ignore, model_class, field):
if (not field.remote_field):
return True
else:
if (ignore):
return False
elif isinstance(field.remote_field, models.ManyToManyRel):
raise base.DeserializationError(
"Model contains a (not parsable) Many to Many field: model:{}: field:{}"
.format(model_class._meta, field_name))
elif isinstance(field.remote_field, models.ManyToOneRel):
raise base.DeserializationError(
"Model contains a (not parsable) Many to One field: model:{}: field:{}"
.format(model_class._meta, field_name))
def _handle_object(self, node):
"""Convert an <object> node to a DeserializedObject."""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object.
data = {}
field_names = {f.name for f in Model._meta.get_fields()}
# Do the pk
#obj_pk = obj.pk
# if obj_pk is not None:
# data['pk'] = str(obj_pk)
for field_node in node.getElementsByTagName("field"):
field_name = field_node.getAttribute("name")
# If the field is missing the name attribute, bail
if not field_name:
raise base.DeserializationError("<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly unless ignorenonexistent or map is used.
if self.ignore and field_name not in field_names:
continue
field = Model._meta.get_field(field_name)
# Relation fields error or ignore
if (field.remote_field and
(isinstance(field.remote_field, models.ManyToManyRel)
or isinstance(field.remote_field, models.ManyToOneRel))
):
if self.ignore:
continue
else:
if field.remote_field and isinstance(field.remote_field, models.ManyToManyRel):
raise base.DeserializationError("<field> node is a (not parsable) Many to Many field")
else:
raise base.DeserializationError("<field> node is a (not parsable) Many to One foreign key field")
else:
#print('node:' + str(field_node.childNodes))
c = field_node.firstChild
if (c):
value = field.to_python(c.data.strip())
else:
value = None
data[field.name] = value
obj = Model(**data)
return base.DeserializedObject(obj)
def _get_model(self, sheet):
"""
Each sheet on the workbook represents a model.
Returns the model class from a specific sheet,
or raises when the model has been not found.
"""
if not sheet.title:
raise base.DeserializationError(
"Worksheet is missing the required model name")
try:
return apps.get_model(sheet.title)
except (LookupError, TypeError):
raise base.DeserializationError(
'Worksheet has invalid model identifier: {}'.format(
sheet.title))
def _get_model(model_identifier):
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
msg = ('Invalid model identifier: \'{}\' '
''.format(model_identifier))
raise base.DeserializationError(msg)
def _get_model_from_node(self, node):
"""
Helper to look up a model from a <type=model>.
"""
name = ""
#print "node.prefix", node.prefix
#print "node.tagName", node.tagName
#print "node.namespaceURI", node.namespaceURI
if node.namespaceURI and node.namespaceURI.startswith(
"urn:x-ns:hotjazz:"):
name = node.namespaceURI[len("urn:x-ns:hotjazz:"):] + ":" + \
node.tagName.split(":")[-1]
else:
name = node.tagName
#print "name", name
model_identifier = name.replace("_", ".").replace(":", ".")
#print "model_identifier", model_identifier
try:
Model = models.get_model(*model_identifier.split("."))
except TypeError:
raise
#Model = None
if Model is None:
raise base.DeserializationError(
"<%s> node has invalid model identifier: '%s'" % \
(node.nodeName, model_identifier))
return Model
def _get_model_from_node(self, node, attr):
"""
Look up a model from a <object model=...> or a <field rel=... to=...>
node.
"""
model_identifier = node.getAttribute(attr)
if not model_identifier:
raise base.DeserializationError(
"<%s> node is missing the required '%s' attribute"
% (node.nodeName, attr))
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError(
"<%s> node has invalid model identifier: '%s'"
% (node.nodeName, model_identifier))
def __init__(self, *args, **kwargs):
r"""
Initialize XLIFF 2.0 deserializer
:param \*args: The supplied arguments
:type \*args: list
:param \**kwargs: The supplied keyword arguments
:type \**kwargs: dict
:raises ~django.core.serializers.base.DeserializationError: If the deserialization fails
"""
# Initialize base deserializer
super().__init__(*args, **kwargs)
# Get language objects from <xliff>-node
for event, node in self.event_stream:
if event == "START_ELEMENT" and node.nodeName == "xliff":
# Get source language stored in the xliff node
self.source_language = Language.objects.get(
slug=self.require_attribute(node, "srcLang"))
# Get target language stored in the xliff node
self.target_language = Language.objects.get(
slug=self.require_attribute(node, "trgLang"))
logger.debug(
"Starting XLIFF 2.0 deserialization for translation from %r to %r",
self.source_language,
self.target_language,
)
return
raise base.DeserializationError(
"The XLIFF file does not contain an <xliff>-block,")
def _handle_object(self, node):
"""
Convert a model node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node)
# Start building a data dictionary from the object.
# If the node is missing the pk set it to None
if node.hasAttribute("hotjazz:pk"):
pk = node.getAttribute("hotjazz:pk")
else:
pk = None
data = {Model._meta.pk.attname: Model._meta.pk.to_python(pk)}
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
# Deseralize each field.
for child_node in node.childNodes:
# ignore anything but elements
if child_node.nodeType != Node.ELEMENT_NODE:
continue
# if the object has non-field contents, bail
if not child_node.hasAttribute("hotjazz:type") \
or not child_node.getAttribute("hotjazz:type").endswith("Field"):
raise base.DeserializationError("Unrecognized node (%s)" %
smart_unicode(child_node))
field_node = child_node
field_name = field_node.tagName.split(":")[-1]
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly.
field = Model._meta.get_field(field_name)
# As is usually the case, relation fields get the special treatment.
if field.rel and isinstance(field.rel, models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
value = None
try:
value = field.to_python(getInnerText(field_node).strip())
except ValidationError:
# assuming this is a NULL value for a non-char column
pass
data[field.name] = value
# Return a DeserializedObject so that the m2m data has a place to live.
result = base.DeserializedObject(Model(**data), m2m_data)
return result
def _get_model(model_identifier):
"""Look up a model from an "app_label.model_name" string."""
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError("Invalid model identifier: '%s'" %
model_identifier)
def _handle_fk_field_node(self, node, field):
"""
Handle a field node for a ForeignKey
"""
if hasattr(field.rel.to._default_manager, 'get_by_natural_key'):
keys = node.getElementsByTagName('hotjazz:natural_ref')
# If there are 'natural_ref' subelements, it must be a natural key
if keys:
obj_pk = self._resolve_natural_key_fk(node, field)
return obj_pk
# Otherwise, treat like a normal PK
key = node.getElementsByTagName("hotjazz:pk_ref")
if not key:
return None
# assuming for a moment this is actually a nullable field...
# raise base.DeserializationError(
# "Expecting hotjazz:pk_ref to deserialize process field %s" % (
# smart_unicode(field.name),))
if key.length != 1:
raise base.DeserializationError(
"Expecting one hotjazz:pk_ref to deserialize process field %s, got %d"
% (smart_unicode(field.name), key.length))
field_value = getInnerText(key.item(0)).strip()
obj_pk = field.rel.to._meta.get_field(
field.rel.field_name).to_python(field_value)
return obj_pk
def _get_value(self, cell, field):
"""
Returns the value of the cell casted to the proper field type
:param cell:
:param field:
:return:
"""
# Empty cell:
if cell.value is None:
return None
# Cell with excel formula:
if str(cell.value).startswith('='):
raise base.DeserializationError(
"Formulas are not supported at this time. Cell %s%s" %
(cell.row, cell.column))
# Process each field type:
elif isinstance(field, models.ForeignKey):
return field.related_model.objects.get(pk=cell.value)
elif isinstance(field, models.AutoField):
return cell.value
elif isinstance(field, models.BooleanField):
return cell.value if type(cell.value) is bool else bool(cell.value)
elif isinstance(field, models.DateTimeField):
# Order matters, DateTime needs to come before Date because datetime subclasses date
# isinstance(aDateTimeInstance, DateField) is True, isinstance(aDateInstance, DateTimeField) is False
if type(cell.value) is datetime:
if settings.USE_TZ and timezone.is_naive(cell.value):
return timezone.make_aware(cell.value, pytz.UTC)
else:
return cell.value
else:
# Handle a couple different timestamp formats -- first one is how *we* save 'em
for pattern, format in DATETIME_FORMATS.items():
if re.match(pattern, str(cell.value)):
return datetime.strptime(str(cell.value), format)
return str(cell.value) # hope for the best
elif isinstance(field, models.DateField):
if type(cell.value) is datetime:
return cell.value.date()
else:
return cell.value if type(
cell.value) is date else datetime.strptime(
cell.value, Y_M_D_FORMAT).date()
elif isinstance(field, models.DecimalField):
try:
return decimal.Decimal(cell.value)
except Exception as ex:
print(cell.value)
else:
return str(cell.value)
def get_object(self, node):
"""
Retrieve an object from the serialized unit node.
:param node: The current xml node of the object
:type node: xml.dom.minidom.Element
:raises ~django.core.serializers.base.DeserializationError: If the deserialization fails
:return: The original page translation
:rtype: ~integreat_cms.cms.models.pages.page_translation.PageTranslation
"""
# Get original page
page_id = self.require_attribute(node, "original")
try:
page = Page.objects.get(id=page_id)
except (ValueError, Page.DoesNotExist) as e:
# If the id isn't a number or if no page with this id is found, check if the external file reference is given
external_file = node.getElementsByTagName("external-file")
if not external_file:
# If no such reference is given, just raise the initial error
raise e
# Get href of external file and parse url
page_link = (urlparse(
self.require_attribute(external_file[0],
"href")).path.strip("/").split("/"))
logger.debug(
"<external-file>-node found, parsed page link: %r",
page_link,
)
# Expect the link to be in the format /<region_slug>/<language_slug>/[<parent_page_slug>]/<page_slug>/
if len(page_link) < 3:
raise base.DeserializationError(
"The page link of the <external-file> reference needs at least 3 segments"
) from e
page_translation_slug = page_link.pop()
region_slug, language_slug = page_link[:2]
page = Page.objects.get(
region__slug=region_slug,
translations__slug=page_translation_slug,
translations__language__slug=language_slug,
)
logger.debug(
"Referenced original page: %r",
page,
)
# Get target language of this file
target_language_slug = self.require_attribute(node, "target-language")
# Get existing target translation or create a new one
page_translation = page.get_translation(
target_language_slug) or PageTranslation(
page=page,
language=Language.objects.get(slug=target_language_slug),
)
return page_translation
def _get_model(model_identifier):
"""
Helper to look up a model from an "app_label.module_name" string.
"""
registry = Base._decl_class_registry
Model = registry.get(model_identifier, None)
if Model is None:
raise base.DeserializationError(u"Invalid model identifier: '%s'" \
% model_identifier)
return Model
def _get_model_from_node(self, node, attr):
"""
Helper to look up a model from a <object model=...> or a <field
rel=... to=...> node.
"""
model_identifier = node.getAttribute(attr)
if not model_identifier:
raise base.DeserializationError(
"<%s> node is missing the required '%s' attribute" \
% (node.nodeName, attr))
try:
Model = models.get_model(*model_identifier.split("."))
except TypeError:
Model = None
if Model is None:
raise base.DeserializationError(
"<%s> node has invalid model identifier: '%s'" % \
(node.nodeName, model_identifier))
return Model
def _get_model(model_identifier):
"""
Helper to look up a model from an "app_label.model_name" string.
"""
try:
Model = apps.get_model(*model_identifier.split("."))
except (LookupError, TypeError):
raise base.DeserializationError("Invalid model identifier: '%s'" %
model_identifier)
return Model
def _handle_object(self, node):
"""
Convert an <object> node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object.
data = {}
if node.hasAttribute('pk'):
data[Model._meta.pk.attname] = Model._meta.pk.to_python(
node.getAttribute('pk'))
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
field_names = {f.name for f in Model._meta.get_fields()}
# Deserialize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail (are you
# sensing a pattern here?)
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError(
"<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly unless ignorenonexistent=True is used.
if self.ignore and field_name not in field_names:
continue
field = Model._meta.get_field(field_name)
# As is usually the case, relation fields get the special treatment.
if field.remote_field and isinstance(field.remote_field,
models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.remote_field and isinstance(field.remote_field,
models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
if field_node.getElementsByTagName('None'):
value = None
else:
value = field.to_python(getInnerText(field_node).strip())
data[field.name] = value
obj = base.build_instance(Model, data, self.db)
# Return a DeserializedObject so that the m2m data has a place to live.
return base.DeserializedObject(obj, m2m_data)
def _get_model(model_identifier):
"""
Helper to look up a model from an "app_label.module_name" string.
"""
try:
Model = models.get_model(*model_identifier.split("."))
except TypeError:
Model = None
if Model is None:
raise base.DeserializationError(u"Invalid model identifier: '%s'" % model_identifier)
return Model
def _get_model(model_identifier, state):
"""
Helper to look up a model from an "app_label.model_name" string.
"""
try:
if is_django_1_7:
apps = state.render()
else:
apps = state.apps
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError("Invalid model identifier: '%s'" %
model_identifier)
def Deserializer(object_list, **options):
"""Deserialize simple Python objects back into Model instances.
It's expected that you pass the Python objects themselves (instead of a
stream or a string) to the constructor
"""
models.get_apps()
for d in object_list:
# Look up the model and starting build a dict of data for it.
Model = python._get_model(d["model"])
data = {}
key = resolve_key(Model._meta.module_name, d["pk"])
if key.name():
data["key_name"] = key.name()
parent = None
if key.parent():
parent = FakeParent(key.parent())
m2m_data = {}
# Handle each field
for (field_name, field_value) in d["fields"].iteritems():
if isinstance(field_value, str):
field_value = smart_unicode(field_value,
options.get(
"encoding",
settings.DEFAULT_CHARSET),
strings_only=True)
field = Model.properties()[field_name]
if isinstance(field, db.Reference):
# Resolve foreign key references.
data[field.name] = resolve_key(Model._meta.module_name,
field_value)
if not data[field.name].name():
raise base.DeserializationError(
u"Cannot load Reference with "
"unnamed key: '%s'" % field_value)
else:
data[field.name] = field.validate(field_value)
# Create the new model instance with all it's data, but no parent.
object = Model(**data)
# Now add the parent into the hidden attribute, bypassing the type checks
# in the Model's __init__ routine.
object._parent = parent
# When the deserialized object is saved our replacement DeserializedObject
# class will set object._parent to force the real parent model to be loaded
# the first time it is referenced.
yield base.DeserializedObject(object, m2m_data)
def __next__(self):
d = self.data_it.__next__()
# Look up the model using the model loading mechanism.
model_path = None
try:
model_path = self.model_path_from_data(d)
model_class = self.get_model_class(model_path)
except base.DeserializationError:
if self.ignore:
return self.__next__()
else:
raise
# Start building a data dictionary from the object.
data = {}
pk = self.get_pk_from_data(d)
if (pk):
try:
data[model_class._meta.pk.attname] = self.pk_to_python(model_class, pk)
except Exception as e:
raise base.DeserializationError.WithData(e, model_path, pk, None)
if model_class not in self.field_names_cache:
self.field_names_cache[model_class] = self.field_names(model_class)
field_names = self.field_names_cache[model_class]
# Handle each field
for (field_name, field_value) in self.fields_from_data(d).items():
if self.ignore and field_name not in field_names:
continue
field = model_class._meta.get_field(field_name)
# Do not handle relation fields.
if(self.field_is_nonrelational(self.ignore, model_class, field)):
try:
data[field.name] = field.to_python(field_value)
except Exception as e:
raise base.DeserializationError("{}: ({}:pk={}) field:'{}': field_value:'{}'".format(
e,
model_path,
pk,
field_name,
field_value
))
obj = base.build_instance(model_class, data, self.db)
return base.DeserializedObject(obj)
def _get_model(model_identifier):
try:
model = apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError(
"Invalid model identifier: '{}'".format(model_identifier))
else:
for manager in managers:
model_name = manager['model_name']
manager_class = manager['manager_class']
manager_instance = manager_class()
Model = apps.get_model(model_name)
manager_instance.model = Model
Model._meta.default_manager = manager_instance
return model
def _handle_object(self, node):
"""Convert an <object> node to a DeserializedObject."""
# Look up the model using the model loading mechanism. If this fails,
# bail.
model_path = node.getAttribute("model")
model_class = self.get_model_class(model_path)
# Start building a data dictionary from the object.
data = {}
if node.hasAttribute('pk'):
data[model_class._meta.pk.attname] = self.pk_to_python(model_class,
node.getAttribute('pk'))
field_names = self.field_names(model_class)
# Deserialize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError("<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly unless ignorenonexistent=True is used.
if self.ignore and field_name not in field_names:
continue
field = model_class._meta.get_field(field_name)
# Do not handle relation fields.
if(self.field_is_nonrelational(self.ignore, model_class, field)):
if field_node.getElementsByTagName('None'):
value = None
else:
value = field.to_python(getInnerText(field_node).strip())
data[field.name] = value
obj = base.build_instance(model_class, data, self.db)
return base.DeserializedObject(obj)
def next(self):
for event, node in self.event_stream:
if event == "START_ELEMENT" and node.nodeName == "object":
if node.hasAttribute("overwrite") and \
node.getAttribute("overwrite") == 'no':
Model = self._get_model_from_node(node, "model")
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
if not node.hasAttribute("compare-by"):
filters = {'pk': Model._meta.pk.to_python(pk)}
else: # comparing by custom field defined in the fixture
field = str(node.getAttribute("compare-by"))
value = node.getAttribute(field)
filters = {field: value}
if Model._base_manager.filter(**filters):
# if object is found we will not overwrite it
# because is marked as non overridable
continue
self.event_stream.expandNode(node)
return self._handle_object(node)
raise StopIteration
def _get_model(model_identifier):
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError(
"Invalid model identifier: '%s'" % model_identifier)
else:
data[field.attname] = None
# Handle all other fields
else:
try:
data[field.name] = field.to_python(field_value)
except Exception as e:
raise base.DeserializationError.WithData(e, d['model'], d.get('pk'), field_value)
<<<<<<< HEAD
obj = base.build_instance(Model, data, db)
=======
obj = base.build_instance(Model, data, using)
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
yield base.DeserializedObject(obj, m2m_data)
def _get_model(model_identifier):
<<<<<<< HEAD
"""
Helper to look up a model from an "app_label.model_name" string.
"""
=======
"""Look up a model from an "app_label.model_name" string."""
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
try:
return apps.get_model(model_identifier)
except (LookupError, TypeError):
raise base.DeserializationError("Invalid model identifier: '%s'" % model_identifier)
model: The name of the model this key is being resolved for. Only used in
the fourth case below (a plain key_name string).
key_data: The data to create a key instance from. May be in four formats:
* The str() output of a key instance. Eg. A base64 encoded string.
* The repr() output of a key instance. Eg. A string for eval().
* A list of arguments to pass to db.Key.from_path.
* A single string value, being the key_name of the instance. When this
format is used the resulting key has no parent, and is for the model
named in the model parameter.
Returns:
An instance of db.Key. If the data cannot be used to create a Key instance
an error will be raised.
"""
if isinstance(key_data, list):
# The key_data is a from_path sequence.
return db.Key.from_path(*key_data)
elif isinstance(key_data, basestring):
if key_data.find("from_path") != -1:
# key_data is encoded in repr(key) format
return eval(key_data)
else:
try:
# key_data encoded a str(key) format
return db.Key(key_data)
except datastore_types.datastore_errors.BadKeyError, e:
# Final try, assume it's a plain key name for the model.
return db.Key.from_path(model, key_data)
else:
raise base.DeserializationError(u"Invalid key data: '%s'" % key_data)
def _handle_object(self, node):
"""
Convert an <object> node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object. If the node is
# missing the pk attribute, fail.
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
data = {Model._meta.pk.attname: Model._meta.pk.to_python(pk)}
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
# Deseralize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail (are you
# sensing a pattern here?)
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError(
"<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly.
try:
field = Model._meta.get_field(field_name)
except FieldDoesNotExist, e:
try:
language = get_field_language(field_name)
except:
raise e
else:
lang_codes = [l[0] for l in settings.LANGUAGES]
if language not in lang_codes:
# fails silently because the LANGUAGES in these settings
# are not same as fixtures data
continue
else:
raise e
# As is usually the case, relation fields get the special treatment.
if field.rel and isinstance(field.rel, models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
if field_node.getElementsByTagName('None'):
value = None
else:
value = field.to_python(
xml_serializer.getInnerText(field_node).strip())
data[field.name] = value
