def render(self, data, *args, **kwargs):
charset = 'utf-8'
root_node = 'xforms'
xmlns = "http://openrosa.org/xforms/xformsList"
if 'detail' in data.keys():
stream = StringIO()
xml = SimplerXMLGenerator(stream, charset)
xml.startDocument()
xml.startElement(root_node, {'xmlns': xmlns})
for key, value in six.iteritems(data):
xml.startElement(key, {})
xml.characters(smart_text(value))
xml.endElement(key)
xml.endElement(root_node)
xml.endDocument()
return stream.getvalue()
else:
json = self.transform_to_xform_json(data)
survey = create_survey_element_from_dict(json)
xml = survey.xml()
fix_languages(xml)
xml = xml.toxml()
xml = self.insert_version_attribute(xml,
data.get('id_string'),
data.get('version'))
xml = self.insert_uuid_bind(xml, data.get('id_string'))
return xml
def characters(self, content):
# TODO: figure out how to do this explicitly rather than implicitly
if any(c in content for c in CDATA_CHARS):
self._write('<![CDATA[' + content + ']]>')
else:
# can't use super, XMLGenerator is an old style class
SimplerXMLGenerator.characters(self, content)
def render(self, data, *args, **kwargs):
charset = 'utf-8'
root_node = 'xforms'
xmlns = "http://openrosa.org/xforms/xformsList"
if 'detail' in data.keys():
stream = StringIO()
xml = SimplerXMLGenerator(stream, charset)
xml.startDocument()
xml.startElement(root_node, {'xmlns': xmlns})
for key, value in six.iteritems(data):
xml.startElement(key, {})
xml.characters(smart_text(value))
xml.endElement(key)
xml.endElement(root_node)
xml.endDocument()
return stream.getvalue()
else:
json = self.transform_to_xform_json(data)
survey = create_survey_element_from_dict(json)
xml = survey.xml()
fix_languages(xml)
xml = xml.toxml()
xml = self.insert_version_attribute(xml,
data.get('id_string'),
data.get('version'))
xml = self.insert_uuid_bind(xml, data.get('id_string'))
return xml
def render(self, data, prettyprint=False):
"""
parameters:
data = dictionary of the things to be shown
prettyprint = flag for pretty printing the xml output (including whitespace and linebreaks)
"""
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
# add a comment
xml._write(self.comment)
# add namespace definitions
nsattrs = {}
nsattrs['version'] = self.version
#nsattrs['encoding'] = charser
nsattrs['xmlns:vosi'] = self.ns_vosiavail
#nsattrs['xmlns:xsi'] = self.ns_xsi
#nsattrs['xmlns:vs'] = self.ns_vs
# add root node
xml.startElement('vosi:availability', nsattrs)
# add mandatory node:
xml.startElement('vosi:available', {})
xml.characters(smart_unicode(data['available']))
xml.endElement('vosi:available')
# remove available from data dict
data.pop('available', None)
# add possible optional nodes:
for key in data.keys():
xml.startElement('vosi:' + key, {})
xml.characters(smart_unicode(data[key]))
xml.endElement('vosi:' + key)
xml.endElement('vosi:availability')
xml.endDocument()
xml_string = stream.getvalue()
# make the xml pretty, i.e. use linebreaks and indentation
# the sax XMLGenerator behind SimpleXMLGenerator does not seem to support this,
# thus need a library that can do it.
# TODO: since we use lxml anyway, maybe build the whole xml-tree with lxml.etree!
# NOTE: This removes any possibly existing comments from the xml output!
if prettyprint is True:
parsed = etree.fromstring(xml_string)
pretty_xml = etree.tostring(parsed, pretty_print=True)
xml_string = pretty_xml
return xml_string
class Serializer(NonrelationalSerializer):
def indent(self, level):
if self.options.get('indent') is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent') * level)
def start_serialization(self):
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
self.verify_object_is_model(obj)
self.indent(1)
attrs = {'model': self.model_path(obj)}
obj_pk = obj.pk
if obj_pk is not None:
attrs['pk'] = str(obj_pk)
self.xml.startElement("object", attrs)
def end_object(self, obj):
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
self.indent(2)
self.xml.startElement('field', {
'name': field.name,
'type': self.field_type(field),
})
if getattr(obj, field.name) is not None:
try:
self.xml.characters(field.value_to_string(obj))
except UnserializableContentError:
raise ValueError("%s.%s (pk:%s) contains unserializable characters" % (
obj.__class__.__name__, field.name, obj.pk))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
print(data)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
reactor_model=ReactorModel.objects.get(pk=data['reactor_model'])
xml.startElement("basecore ", {'ID':reactor_model.name,'core_type':reactor_model.reactor_type})
reactor_positions=reactor_model.positions.all()
num_side_asms=0
for reactor_position in reactor_positions:
if reactor_position.row>num_side_asms:
num_side_asms=reactor_position.row
#core_geo
xml.startElement('core_geo',{'num_side_asms':str(num_side_asms)})
xml.startElement('fuel_pitch',{})
xml.characters(smart_text(reactor_model.fuel_pitch))
xml.endElement('fuel_pitch')
xml.startElement('std_fuel_len',{})
xml.characters(smart_text(reactor_model.active_height))
xml.endElement('std_fuel_len')
xml.startElement('fuel_map',{})
fuel_map_lst=[]
for i in range(1,num_side_asms+1):
for j in range(1,num_side_asms+1):
fuel_position=reactor_model.positions.filter(row=i,column=j)
if fuel_position:
fuel_map_lst.append('1')
else:
fuel_map_lst.append('0')
xml.characters(smart_text(' '.join(fuel_map_lst)))
xml.endElement('fuel_map')
xml.endElement('core_geo')
#control rod map
xml.startElement('rcca',{})
control_rod_assembly_lst=[]
bank_id_lst=[]
for position in reactor_positions:
try:
cralp=ControlRodAssemblyLoadingPattern.objects.get(reactor_position=position)
control_rod_assembly_lst.append(cralp.control_rod_assembly.cluster_name)
if cralp.control_rod_assembly.cluster_name not in bank_id_lst:
bank_id_lst.append(cralp.control_rod_assembly.cluster_name)
except Exception:
control_rod_assembly_lst.append('0')
index=1
for name in bank_id_lst:
xml.startElement('bank_id',{'basez':"9.5875",'index':str(index)})
index+=1
xml.characters(smart_text(name))
xml.endElement('bank_id')
xml.startElement('map',{})
xml.characters(smart_text(' '.join(control_rod_assembly_lst)))
xml.endElement('map')
xml.startElement('step_size',{})
xml.characters(smart_text(1.5832))
xml.endElement('step_size')
xml.endElement('rcca')
#reflector
xml.startElement('reflector',{})
xml.startElement('bot_br',{})
xml.characters(smart_text('BR_BOT'))
xml.endElement('bot_br')
xml.startElement('top_br',{})
xml.characters(smart_text('''
BR_TOP
BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP'''))
xml.endElement('top_br')
xml.startElement('radial_br',{'index':'1'})
xml.characters(smart_text('BR3 BR3 BR3 BR9 BR6 BR5 BR7 BR3 BR3 BR9 BR6 BR5 BR7 BR9 '))
xml.endElement('radial_br')
xml.startElement('radial_br',{'index':'2'})
xml.characters(smart_text('BR4 BR4 BR4 BR10 BR12 BR11 BR8 BR4 BR4 BR10 BR12 BR11 BR8 BR10 BR12'))
xml.endElement('radial_br')
xml.endElement('reflector')
xml.endElement("basecore ")
xml.endDocument()
return stream.getvalue()
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version" : "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
self.xml.startElement("object", {
"pk" : str(obj._get_pk_val()),
"model" : str(obj._meta),
})
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(2)
self.xml.startElement("field", {
"name" : field.name,
"type" : field.get_internal_type()
})
# Get a "string version" of the object's data (this is handled by the
# serializer base class).
if getattr(obj, field.name) is not None:
value = self.get_string_value(obj, field)
self.xml.characters(str(value))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
self._start_relational_field(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)
self.xml.characters(str(related))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
self._start_relational_field(field)
for relobj in getattr(obj, field.name).iterator():
self.xml.addQuickElement("object", attrs={"pk" : str(relobj._get_pk_val())})
self.xml.endElement("field")
def _start_relational_field(self, field):
"""
Helper to output the <field> element for relational fields
"""
self.indent(2)
self.xml.startElement("field", {
"name" : field.name,
"rel" : field.rel.__class__.__name__,
"to" : str(field.rel.to._meta),
})
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version" : "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
self.xml.startElement("object", {
"pk" : str(obj._get_pk_val()),
"model" : str(obj._meta),
})
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(2)
self.xml.startElement("field", {
"name" : field.name,
"type" : field.get_internal_type()
})
# Get a "string version" of the object's data (this is handled by the
# serializer base class).
if getattr(obj, field.name) is not None:
value = self.get_string_value(obj, field)
self.xml.characters(str(value))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
self._start_relational_field(field)
related = getattr(obj, field.name)
if related is not None:
self.xml.characters(str(related._get_pk_val()))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
self._start_relational_field(field)
for relobj in getattr(obj, field.name).iterator():
self.xml.addQuickElement("object", attrs={"pk" : str(relobj._get_pk_val())})
self.xml.endElement("field")
def _start_relational_field(self, field):
"""
Helper to output the <field> element for relational fields
"""
self.indent(2)
self.xml.startElement("field", {
"name" : field.name,
"rel" : field.rel.__class__.__name__,
"to" : str(field.rel.to._meta),
})
class BackupRequest(models.Model):
user = models.OneToOneField(User)
state = models.IntegerField(choices=BACKUP_RESTORE_STATE,
default=BACKUP_RESTORE_STATE_PENDING)
creation_datetime = models.DateTimeField()
last_state_datetime = models.DateTimeField()
error_message = models.CharField(max_length=255, null=True, blank=True)
def is_done(self):
return self.state == BACKUP_RESTORE_STATE_DONE
def get_backup_filename(self):
return 'backup_%s.tar.gz' % (
self.creation_datetime.strftime('%Y%m%d%H%M'))
def backup(self):
class BackupTarInfo(tarfile.TarInfo):
def setNothing(self, value):
pass
def getUid(self):
return 10000
def getGid(self):
return 1000
def getUname(self):
return 'aemanager'
def getGname(self):
return 'aemanager'
uid = property(getUid, setNothing)
gid = property(getGid, setNothing)
uname = property(getUname, setNothing)
gname = property(getGname, setNothing)
self.state = BACKUP_RESTORE_STATE_IN_PROGRESS
self.last_state_datetime = datetime.datetime.now()
self.save()
self.backup_dir = '%s%s/backup/backup_%s' % (
settings.FILE_UPLOAD_DIR, self.user.get_profile().uuid,
self.creation_datetime.strftime('%Y%m%d%H%M'))
try:
# delete previous export dir
shutil.rmtree(
'%s%s/backup' %
(settings.FILE_UPLOAD_DIR, self.user.get_profile().uuid), True)
# create export dir
mkdir_p(self.backup_dir)
# backup objects
self.stream = open("%s/data.xml" % (self.backup_dir), 'w')
self.backup_objects()
self.stream.close()
# backup files
self.backup_files()
# create the archive
file = gzip.GzipFile('%s.tar.gz' % (self.backup_dir), 'w')
tar = tarfile.TarFile(mode='w',
fileobj=file,
tarinfo=BackupTarInfo)
tar.add(self.backup_dir, 'backup')
tar.close()
file.close()
self.state = BACKUP_RESTORE_STATE_DONE
except Exception as e:
self.state = BACKUP_RESTORE_STATE_ERROR
self.error_message = unicode(e)
mail_subject = _('Backup failed')
mail_message = _(
'Backup for %(user)s failed with message : %(message)s') % {
'user': self.user,
'message': e
}
mail_admins(mail_subject,
mail_message,
fail_silently=(not settings.DEBUG))
shutil.rmtree(self.backup_dir, True)
self.last_state_datetime = datetime.datetime.now()
self.save()
def indent(self, level):
self.xml.ignorableWhitespace('\n' + ' ' * 4 * level)
def backup_objects(self):
models = [
Address, Contact, Contract, PhoneNumber, Project, Proposal,
ProposalRow, Invoice, InvoiceRow, Expense
]
self.xml = SimplerXMLGenerator(self.stream, settings.DEFAULT_CHARSET)
self.xml.startDocument()
self.xml.startElement("aemanager", {"version": common()['version']})
for model in models:
for object in model.objects.filter(owner=self.user):
# do not export address of user profile
if not (type(object) == Address
and object.userprofile_set.count()):
self.indent(1)
self.xml.startElement(object._meta.object_name,
{'uuid': object.uuid})
for field in object._meta.local_fields:
if field.name not in ['ownedobject_ptr']:
self.indent(2)
self.xml.startElement(field.name, {})
if getattr(object, field.name) is not None:
if type(field) == ForeignKey:
related = getattr(object, field.name)
if type(related) == Country:
self.xml.addQuickElement(
"object",
attrs={
'country_code':
smart_unicode(
related.country_code2)
})
else:
self.xml.addQuickElement(
"object",
attrs={
'uuid':
smart_unicode(related.uuid)
})
elif type(field) == OneToOneField:
related = getattr(object, field.name)
self.xml.addQuickElement(
"object",
attrs={
'uuid': smart_unicode(related.uuid)
})
else:
self.xml.characters(
field.value_to_string(object))
else:
self.xml.addQuickElement("None")
self.xml.endElement(field.name)
for field in object._meta.many_to_many:
self.indent(2)
self.xml.startElement(field.name, {})
for relobj in getattr(object, field.name).iterator():
self.indent(3)
self.xml.addQuickElement(
"object",
attrs={'uuid': smart_unicode(relobj.uuid)})
self.indent(2)
self.xml.endElement(field.name)
self.indent(1)
self.xml.endElement(smart_unicode(
object._meta.object_name))
self.indent(0)
self.xml.endElement("aemanager")
self.xml.endDocument()
def backup_files(self):
dirs = ['contract', 'logo', 'proposal']
for dir in dirs:
from_path = '%s%s/%s' % (settings.FILE_UPLOAD_DIR,
self.user.get_profile().uuid, dir)
to_path = '%s/%s' % (self.backup_dir, dir)
if os.path.exists(from_path):
shutil.copytree(from_path, to_path)
class CirkwiPOISerializer(object):
def __init__(self, request, stream):
self.xml = SimplerXMLGenerator(stream, 'utf8')
self.request = request
self.stream = stream
def serialize_field(self, name, value, attrs={}):
if not value and not attrs:
return
value = unicode(value)
self.xml.startElement(name, attrs)
if u'<' in value or u'>' in value or u'&' in value:
self.stream.write('<![CDATA[%s]]>' % value)
else:
self.xml.characters(value)
self.xml.endElement(name)
def serialize_medias(self, request, pictures):
if not pictures:
return
self.xml.startElement('medias', {})
self.xml.startElement('images', {})
for picture in pictures[:10]:
self.xml.startElement('image', {})
if picture['legend']:
self.serialize_field('legende', picture['legend'])
self.serialize_field('url',
request.build_absolute_uri(picture['url']))
if picture['author']:
self.serialize_field('credit', picture['author'])
self.xml.endElement('image')
self.xml.endElement('images')
self.xml.endElement('medias')
def serialize_pois(self, pois):
if not pois:
return
for poi in pois:
self.xml.startElement(
'poi', {
'date_creation': timestamp(poi.date_insert),
'date_modification': timestamp(poi.date_update),
'id_poi': str(poi.pk),
})
if poi.type.cirkwi:
self.xml.startElement('categories', {})
self.serialize_field('categorie', str(poi.type.cirkwi.eid),
{'nom': poi.type.cirkwi.name})
self.xml.endElement('categories')
orig_lang = translation.get_language()
self.xml.startElement('informations', {})
for lang in poi.published_langs:
translation.activate(lang)
self.xml.startElement('information', {'langue': lang})
self.serialize_field('titre', poi.name)
self.serialize_field('description',
plain_text(poi.description))
self.serialize_medias(self.request, poi.serializable_pictures)
self.xml.endElement('information')
translation.activate(orig_lang)
self.xml.endElement('informations')
self.xml.startElement('adresse', {})
self.xml.startElement('position', {})
coords = poi.geom.transform(4326, clone=True).coords
self.serialize_field('lat', coords[1])
self.serialize_field('lng', coords[0])
self.xml.endElement('position')
self.xml.endElement('adresse')
self.xml.endElement('poi')
def serialize(self, pois):
self.xml.startDocument()
self.xml.startElement('pois', {'version': '2'})
self.serialize_pois(pois)
self.xml.endElement('pois')
self.xml.endDocument()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
print(data)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
reactor_model = ReactorModel.objects.get(pk=data['reactor_model'])
xml.startElement("basecore ", {
'ID': reactor_model.name,
'core_type': reactor_model.reactor_type
})
reactor_positions = reactor_model.positions.all()
num_side_asms = 0
for reactor_position in reactor_positions:
if reactor_position.row > num_side_asms:
num_side_asms = reactor_position.row
#core_geo
xml.startElement('core_geo', {'num_side_asms': str(num_side_asms)})
xml.startElement('fuel_pitch', {})
xml.characters(smart_text(reactor_model.fuel_pitch))
xml.endElement('fuel_pitch')
xml.startElement('std_fuel_len', {})
xml.characters(smart_text(reactor_model.active_height))
xml.endElement('std_fuel_len')
xml.startElement('fuel_map', {})
fuel_map_lst = []
for i in range(1, num_side_asms + 1):
for j in range(1, num_side_asms + 1):
fuel_position = reactor_model.positions.filter(row=i, column=j)
if fuel_position:
fuel_map_lst.append('1')
else:
fuel_map_lst.append('0')
xml.characters(smart_text(' '.join(fuel_map_lst)))
xml.endElement('fuel_map')
xml.endElement('core_geo')
#control rod map
xml.startElement('rcca', {})
control_rod_assembly_lst = []
bank_id_lst = []
for position in reactor_positions:
try:
cralp = ControlRodAssemblyLoadingPattern.objects.get(
reactor_position=position)
control_rod_assembly_lst.append(
cralp.control_rod_assembly.cluster_name)
if cralp.control_rod_assembly.cluster_name not in bank_id_lst:
bank_id_lst.append(cralp.control_rod_assembly.cluster_name)
except Exception:
control_rod_assembly_lst.append('0')
index = 1
for name in bank_id_lst:
xml.startElement('bank_id', {
'basez': "9.5875",
'index': str(index)
})
index += 1
xml.characters(smart_text(name))
xml.endElement('bank_id')
xml.startElement('map', {})
xml.characters(smart_text(' '.join(control_rod_assembly_lst)))
xml.endElement('map')
xml.startElement('step_size', {})
xml.characters(smart_text(1.5832))
xml.endElement('step_size')
xml.endElement('rcca')
#reflector
xml.startElement('reflector', {})
xml.startElement('bot_br', {})
xml.characters(smart_text('BR_BOT'))
xml.endElement('bot_br')
xml.startElement('top_br', {})
xml.characters(
smart_text('''
BR_TOP
BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP
BR_TOP BR_TOP BR_TOP'''))
xml.endElement('top_br')
xml.startElement('radial_br', {'index': '1'})
xml.characters(
smart_text(
'BR3 BR3 BR3 BR9 BR6 BR5 BR7 BR3 BR3 BR9 BR6 BR5 BR7 BR9 '
))
xml.endElement('radial_br')
xml.startElement('radial_br', {'index': '2'})
xml.characters(
smart_text(
'BR4 BR4 BR4 BR10 BR12 BR11 BR8 BR4 BR4 BR10 BR12 BR11 BR8 BR10 BR12'
))
xml.endElement('radial_br')
xml.endElement('reflector')
xml.endElement("basecore ")
xml.endDocument()
return stream.getvalue()
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace(
'\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(
self.stream, self.options.get("encoding",
settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError(
"Non-model object (%s) encountered during serialization" %
type(obj))
self.indent(1)
obj_pk = obj._get_pk_val()
if obj_pk is None:
attrs = {
"model": smart_unicode(obj._meta),
}
else:
attrs = {
"pk": smart_unicode(obj._get_pk_val()),
"model": smart_unicode(obj._meta),
}
self.xml.startElement("object", attrs)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(2)
self.xml.startElement("field", {
"name": field.name,
"type": field.get_internal_type()
})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
self.xml.characters(field.value_to_string(obj))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
self._start_relational_field(field)
related_att = getattr(obj, field.get_attname())
if related_att is not None:
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
related = getattr(obj, field.name)
# If related object has a natural key, use it
related = related.natural_key()
# Iterable natural keys are rolled out as subelements
for key_value in related:
self.xml.startElement("natural", {})
self.xml.characters(smart_unicode(key_value))
self.xml.endElement("natural")
else:
self.xml.characters(smart_unicode(related_att))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
if field.rel.through._meta.auto_created:
self._start_relational_field(field)
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
# Iterable natural keys are rolled out as subelements
self.xml.startElement("object", {})
for key_value in natural:
self.xml.startElement("natural", {})
self.xml.characters(smart_unicode(key_value))
self.xml.endElement("natural")
self.xml.endElement("object")
else:
def handle_m2m(value):
self.xml.addQuickElement(
"object",
attrs={'pk': smart_unicode(value._get_pk_val())})
for relobj in getattr(obj, field.name).iterator():
handle_m2m(relobj)
self.xml.endElement("field")
def _start_relational_field(self, field):
"""
Helper to output the <field> element for relational fields
"""
self.indent(2)
self.xml.startElement(
"field", {
"name": field.name,
"rel": field.rel.__class__.__name__,
"to": smart_unicode(field.rel.to._meta),
})
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
print(data)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
unit = UnitParameter.objects.get(pk=data[0]['unit'])
plant = unit.plant
reactor_model = unit.reactor_model
reactor_positions = reactor_model.positions.all()
cycles = unit.cycles.all()
#fuel_assembly_model=FuelAssemblyLoadingPattern.objects.get(pk=data[0]['fuel_assembly_loading_patterns'][0]).fuel_assembly.type.model
xml.startElement(
"loading_pattern ", {
'basecore_ID': reactor_model.name,
'core_id': reactor_model.name + '_U' + str(unit.unit)
})
for cycle in cycles:
control_rod_assembly_loading_patterns = cycle.control_rod_assembly_loading_patterns.all(
)
if control_rod_assembly_loading_patterns:
xml.startElement('control_rod', {'cycle': str(cycle.cycle)})
xml.startElement('map', {})
cra_position_lst = []
for reactor_position in reactor_positions:
cra_pattern = control_rod_assembly_loading_patterns.filter(
reactor_position=reactor_position)
if cra_pattern:
cra = cra_pattern.get().control_rod_assembly
cra_position_lst.append('CR1')
else:
cra_position_lst.append('0')
xml.characters(smart_text(' '.join(cra_position_lst)))
xml.endElement('map')
xml.endElement('control_rod')
for cycle in cycles:
#fuel_assembly_loading_patterns=cycle.fuel_assembly_loading_patterns.all()
#burnable_posison_assembly_positions=cycle.burnable_posison_assembly_positions.all()
fuel_lst = []
previous_cycle_lst = []
'''
for fuel_assembly_loading_pattern in fuel_assembly_loading_patterns:
fuel_assembly_type=fuel_assembly_loading_pattern.fuel_assembly.type
burnable_poison_assembly_position=burnable_posison_assembly_positions.filter(reactor_position=fuel_assembly_loading_pattern.reactor_position)
if burnable_poison_assembly_position:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=burnable_poison_assembly_position.get().burnable_poison_assembly).get()
base_fuel=ibis.base_fuels.get()
print(base_fuel)
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
else:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=None).get()
base_fuels=ibis.base_fuels.all()
for base_fuel in base_fuels:
if not base_fuel.base_fuel.if_insert_burnable_fuel:
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
'''
for reactor_position in reactor_positions:
fuel_assembly_loading_pattern = cycle.fuel_assembly_loading_patterns.filter(
reactor_position=reactor_position).get()
burnable_poison_assembly_position = cycle.burnable_posison_assembly_positions.filter(
reactor_position=reactor_position)
fuel_assembly_type = fuel_assembly_loading_pattern.fuel_assembly.type
if fuel_assembly_loading_pattern.get_previous():
[
previous_cycle, previous_position_row,
previous_position_column
] = fuel_assembly_loading_pattern.get_previous().split('-')
position = '{}{}'.format(previous_position_row.zfill(2),
previous_position_column.zfill(2))
fuel_lst.append(position)
if previous_cycle != cycle.cycle - 1:
previous_cycle_lst.append([
previous_cycle, reactor_position.row,
reactor_position.column
])
else:
if burnable_poison_assembly_position:
ibis = Ibis.objects.filter(
fuel_assembly_type=fuel_assembly_type,
burnable_poison_assembly=
burnable_poison_assembly_position.get(
).burnable_poison_assembly).get()
base_fuel = ibis.base_fuels.get()
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
else:
ibis = Ibis.objects.filter(
fuel_assembly_type=fuel_assembly_type,
burnable_poison_assembly=None).get()
base_fuels = ibis.base_fuels.all()
for base_fuel in base_fuels:
if not base_fuel.base_fuel.if_insert_burnable_fuel(
):
fuel_lst.append(
base_fuel.base_fuel.fuel_identity)
print(len(fuel_lst))
xml.startElement('fuel', {'cycle': str(cycle.cycle)})
xml.startElement('map', {})
xml.characters(smart_text(' '.join(fuel_lst)))
xml.endElement('map')
for previous_cycle_info in previous_cycle_lst:
if int(previous_cycle_info[0]) != cycle.cycle - 1:
xml.startElement(
'cycle', {
'row': str(previous_cycle_info[1]),
'col': str(previous_cycle_info[2])
})
xml.characters(smart_text(previous_cycle_info[0]))
xml.endElement('cycle')
xml.endElement('fuel')
xml.endElement("loading_pattern ")
xml.endDocument()
return stream.getvalue()
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def _get_obj_pk(self, obj):
"""
returns the objects pk or the natural key, joined
"""
if self.use_natural_keys and hasattr(obj, 'natural_key'):
raw_nat_key = obj.natural_key()
obj_pk = smart_text(NATURAL_KEY_JOINER.join(raw_nat_key))
keytype = 'natural'
else:
obj_pk = obj._get_pk_val()
keytype = 'pk'
return obj_pk, keytype
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace(
'\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(
self.stream, self.options.get("encoding",
settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement(
"xliff", {
"version": "1.2",
"xmlns": "urn:oasis:names:tc:xliff:document:1.2",
"xmlns:d": "https://docs.djangoproject.com/"
})
def start_fileblock(self, obj):
"""
Start the <file><body> block
"""
self.indent(1)
obj_key, keytype = self._get_obj_pk(obj)
self.xml.startElement(
"file", {
"original": "%s.%s" % (smart_text(obj._meta), obj_key),
"datatype": "database",
"source-language": settings.LANGUAGE_CODE,
"d:keytype": keytype,
})
self.xml.startElement("body", {})
def end_fileblock(self):
"""
End the <file><body> block
"""
self.indent(1)
self.xml.endElement("body")
self.xml.endElement("file")
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("xliff")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError(
"Non-model object (%s) encountered during serialization" %
type(obj))
self.start_fileblock(obj)
self.indent(2)
obj_pk, keytype = self._get_obj_pk(obj)
attrs = {"restype": "row", "d:keytype": keytype}
if obj_pk is not None:
attrs["resname"] = "%s.%s" % (smart_text(obj._meta), obj_pk)
else:
attrs["resname"] = smart_text(obj._meta)
self.xml.startElement("group", attrs)
if obj._meta.pk.__class__.__name__ != "AutoField":
self.handle_field(obj, obj._meta.pk)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(2)
self.xml.endElement("group")
self.indent(1)
self.end_fileblock()
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(3)
internal_type = field.get_internal_type()
attrs = {
"id": field.name,
"resname": field.name,
"restype": "x-%s" % internal_type,
"translate": "no",
}
if internal_type in ("CharField", "TextField"):
attrs["translate"] = "yes"
if internal_type == "CharField":
attrs["size-unit"] = "char"
attrs["maxwidth"] = str(field.max_length)
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
self.xml.characters(field.value_to_string(obj))
else:
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
related_att = getattr(obj, field.get_attname())
if related_att is not None:
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
self._start_relational_field(field, keytype="natural")
related = getattr(obj, field.name)
# If related object has a natural key, use it
related = related.natural_key()
nat_key = NATURAL_KEY_JOINER.join(related)
self.xml.characters(smart_text(nat_key))
# Iterable natural keys are rolled out as subelements
# for key_value in related:
# self.xml.startElement("natural", {})
# self.xml.characters(smart_text(key_value))
# self.xml.endElement("natural")
else:
self._start_relational_field(field)
self.xml.characters(smart_text(related_att))
else:
self._start_relational_field(field)
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
if field.rel.through._meta.auto_created:
# self._start_relational_field(field)
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
nat_key = NATURAL_KEY_JOINER.join(natural)
field_id = "%s.%s" % (obj.pk, nat_key)
self._start_relational_field(field,
field_id=field_id,
keytype="natural")
self.xml.characters(smart_text(nat_key))
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
# Iterable natural keys are rolled out as subelements
# self.xml.startElement("object", {})
# for key_value in natural:
# self.xml.startElement("natural", {})
# self.xml.characters(smart_text(key_value))
# self.xml.endElement("natural")
# self.xml.endElement("object")
else:
def handle_m2m(value):
field_id = "%s.%s" % (obj.pk, value._get_pk_val())
self._start_relational_field(field, field_id)
self.xml.characters(smart_text(value._get_pk_val()))
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
# self.xml.addQuickElement("object", attrs={
# 'pk' : smart_text(value._get_pk_val())
# })
for relobj in getattr(obj, field.name).iterator():
handle_m2m(relobj)
def handle_gfk_field(self, obj, field):
"""
Handle the GenericForeignKey
<trans-unit id=<gfk.name>
"""
obj_pk, keytype = self._get_obj_pk(getattr(obj, field.ct_field))
attrs = {
"id": field.name,
"resname": field.name,
"restype": "x-%s" % field.__class__.__name__,
"translate": "no",
"d:keytype": keytype,
"d:rel": "GenericManyToOneRel",
"d:to": obj_pk,
}
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
# Get a "string version" of the object's data.
gfk_obj = getattr(obj, field.name)
if gfk_obj is not None:
gfk_pk, keytype = self._get_obj_pk(gfk_obj)
if keytype == 'natural':
self.xml.characters(gfk_pk)
else:
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def _start_relational_field(self, field, field_id="", keytype="pk"):
"""
Helper to output the <trans-unit> element for relational fields
"""
self.indent(3)
internal_type = field.get_internal_type()
attrs = {
"id": field_id or field.name,
"resname": field.name,
"restype": "x-%s" % internal_type,
"translate": "no",
"d:rel": field.rel.__class__.__name__,
"d:to": smart_text(field.rel.to._meta),
"d:keytype": keytype,
}
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
"""
class CirkwiPOISerializer:
def __init__(self, request, stream):
self.xml = SimplerXMLGenerator(stream, "utf8")
self.request = request
self.stream = stream
def serialize_field(self, name, value, attrs={}):
if not value and not attrs:
return
value = unicode(value)
self.xml.startElement(name, attrs)
if u"<" in value or u">" in value or u"&" in value:
self.stream.write("<![CDATA[%s]]>" % value)
else:
self.xml.characters(value)
self.xml.endElement(name)
def serialize_medias(self, request, pictures):
if not pictures:
return
self.xml.startElement("medias", {})
self.xml.startElement("images", {})
for picture in pictures:
self.xml.startElement("image", {})
self.serialize_field("legende", picture["legend"])
self.serialize_field("url", request.build_absolute_uri(picture["url"]))
self.serialize_field("credit", picture["author"])
self.xml.endElement("image")
self.xml.endElement("images")
self.xml.endElement("medias")
def serialize_pois(self, pois):
for poi in pois:
self.xml.startElement(
"poi",
{
"date_creation": timestamp(poi.date_insert),
"date_modification": timestamp(poi.date_update),
"id_poi": str(poi.pk),
},
)
if poi.type.cirkwi:
self.xml.startElement("categories", {})
self.serialize_field("categorie", str(poi.type.cirkwi.eid), {"nom": poi.type.cirkwi.name})
self.xml.endElement("categories")
orig_lang = translation.get_language()
self.xml.startElement("informations", {})
for lang in poi.published_langs:
translation.activate(lang)
self.xml.startElement("information", {"langue": lang})
self.serialize_field("titre", poi.name)
self.serialize_field("description", plain_text(poi.description))
self.serialize_medias(self.request, poi.serializable_pictures)
self.xml.endElement("information")
translation.activate(orig_lang)
self.xml.endElement("informations")
self.xml.startElement("adresse", {})
self.xml.startElement("position", {})
coords = poi.geom.transform(4326, clone=True).coords
self.serialize_field("lat", coords[1])
self.serialize_field("lng", coords[0])
self.xml.endElement("position")
self.xml.endElement("adresse")
self.xml.endElement("poi")
def serialize(self, pois):
self.xml.startDocument()
self.xml.startElement("pois", {"version": "2"})
self.serialize_pois(pois)
self.xml.endElement("pois")
self.xml.endDocument()
class Serializer(base.Serializer):
key_map = {}
def __init__(self):
#self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
pass
#if (self.key_map):
# _validate_keymap(self.__class__.__name__, self.model_class, self.key_map)
#? Dry
def model_name(self, obj):
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
return str(obj._meta)
def indent(self, level):
if self.options.get('indent') is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent') * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
#self.stream.write('<?xml version = "1.0" encoding = "UTF-8"?>\n')
#self.stream.write('<queryset>\n')
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
#self.stream.write('</queryset>\n')
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
self.xml.startElement("object", {'model': self.model_name(obj) })
#self.stream.write('<object model="{}">\n'.format(self.model_name(obj)))
obj_pk = obj.pk
if obj_pk is not None:
#self.stream.write('<field name="pk">{}</field>\n'.format(obj_pk))
#self.xml.addQuickElement("field", contents=, attrs={'name': 'pk'})
self.xml.startElement('field', {
'name': 'pk'
})
self.xml.characters(str(obj_pk))
self.xml.endElement("field")
def end_object(self, obj):
#self.stream.write('</object>\n')
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
#? DRY
field_name = field.name
k = self.key_map[fn] if (field_name in self.key_map) else field_name
self.indent(2)
self.xml.startElement('field', {
'name': field_name
})
if getattr(obj, field_name) is not None:
try:
#? investigate this parser function
#? does what?
self.xml.characters(field.value_to_string(obj))
#v = field.value_from_object(obj)
#self.stream.write('<field name="{0}">{1}</field>\n'.format(k, v))
except UnserializableContentError:
raise ValueError("%s.%s (pk:%s) contains unserializable characters" % (
obj.__class__.__name__, fn, obj.pk))
else:
#self.stream.write('<field name="{0}">None</field>\n'.format(k))
self.xml.addQuickElement("None")
self.xml.endElement("field")
class BackupRequest(models.Model):
user = models.OneToOneField(User)
state = models.IntegerField(choices=BACKUP_RESTORE_STATE, default=BACKUP_RESTORE_STATE_PENDING)
creation_datetime = models.DateTimeField()
last_state_datetime = models.DateTimeField()
error_message = models.CharField(max_length=255, null=True, blank=True)
def is_done(self):
return self.state == BACKUP_RESTORE_STATE_DONE
def get_backup_filename(self):
return 'backup_%s.tar.gz' % (self.creation_datetime.strftime('%Y%m%d%H%M'))
def backup(self):
class BackupTarInfo(tarfile.TarInfo):
def setNothing(self, value):
pass
def getUid(self):
return 10000
def getGid(self):
return 1000
def getUname(self):
return 'aemanager'
def getGname(self):
return 'aemanager'
uid = property(getUid, setNothing)
gid = property(getGid, setNothing)
uname = property(getUname, setNothing)
gname = property(getGname, setNothing)
self.state = BACKUP_RESTORE_STATE_IN_PROGRESS
self.last_state_datetime = datetime.datetime.now()
self.save()
self.backup_dir = '%s%s/backup/backup_%s' % (settings.FILE_UPLOAD_DIR,
self.user.get_profile().uuid,
self.creation_datetime.strftime('%Y%m%d%H%M'))
try:
# delete previous export dir
shutil.rmtree('%s%s/backup' % (settings.FILE_UPLOAD_DIR,
self.user.get_profile().uuid),
True)
# create export dir
mkdir_p(self.backup_dir)
# backup objects
self.stream = open("%s/data.xml" % (self.backup_dir), 'w')
self.backup_objects()
self.stream.close()
# backup files
self.backup_files()
# create the archive
file = gzip.GzipFile('%s.tar.gz' % (self.backup_dir), 'w')
tar = tarfile.TarFile(mode='w', fileobj=file, tarinfo=BackupTarInfo)
tar.add(self.backup_dir, 'backup')
tar.close()
file.close()
self.state = BACKUP_RESTORE_STATE_DONE
except Exception as e:
self.state = BACKUP_RESTORE_STATE_ERROR
self.error_message = unicode(e)
mail_subject = _('Backup failed')
mail_message = _('Backup for %(user)s failed with message : %(message)s') % {'user': self.user,
'message': e}
mail_admins(mail_subject, mail_message, fail_silently=(not settings.DEBUG))
shutil.rmtree(self.backup_dir, True)
self.last_state_datetime = datetime.datetime.now()
self.save()
def indent(self, level):
self.xml.ignorableWhitespace('\n' + ' ' * 4 * level)
def backup_objects(self):
models = [Address, Contact, Contract, PhoneNumber, Project, Proposal, ProposalRow, Invoice, InvoiceRow, Expense]
self.xml = SimplerXMLGenerator(self.stream, settings.DEFAULT_CHARSET)
self.xml.startDocument()
self.xml.startElement("aemanager", {"version" : common()['version']})
for model in models:
for object in model.objects.filter(owner=self.user):
# do not export address of user profile
if not(type(object) == Address and object.userprofile_set.count()):
self.indent(1)
self.xml.startElement(object._meta.object_name, {'uuid': object.uuid})
for field in object._meta.local_fields:
if field.name not in ['ownedobject_ptr']:
self.indent(2)
self.xml.startElement(field.name, {})
if getattr(object, field.name) is not None:
if type(field) == ForeignKey:
related = getattr(object, field.name)
if type(related) == Country:
self.xml.addQuickElement("object", attrs={
'country_code' : smart_unicode(related.country_code2)
})
else:
self.xml.addQuickElement("object", attrs={
'uuid' : smart_unicode(related.uuid)
})
elif type(field) == OneToOneField:
related = getattr(object, field.name)
self.xml.addQuickElement("object", attrs={
'uuid' : smart_unicode(related.uuid)
})
else:
self.xml.characters(field.value_to_string(object))
else:
self.xml.addQuickElement("None")
self.xml.endElement(field.name)
for field in object._meta.many_to_many:
self.indent(2)
self.xml.startElement(field.name, {})
for relobj in getattr(object, field.name).iterator():
self.indent(3)
self.xml.addQuickElement("object", attrs={
'uuid' : smart_unicode(relobj.uuid)
})
self.indent(2)
self.xml.endElement(field.name)
self.indent(1)
self.xml.endElement(smart_unicode(object._meta.object_name))
self.indent(0)
self.xml.endElement("aemanager")
self.xml.endDocument()
def backup_files(self):
dirs = ['contract', 'logo', 'proposal']
for dir in dirs:
from_path = '%s%s/%s' % (settings.FILE_UPLOAD_DIR,
self.user.get_profile().uuid,
dir)
to_path = '%s/%s' % (self.backup_dir, dir)
if os.path.exists(from_path):
shutil.copytree(from_path, to_path)
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
print(data)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
unit=UnitParameter.objects.get(pk=data[0]['unit'])
plant=unit.plant
reactor_model=unit.reactor_model
reactor_positions=reactor_model.positions.all()
cycles=unit.cycles.all()
#fuel_assembly_model=FuelAssemblyLoadingPattern.objects.get(pk=data[0]['fuel_assembly_loading_patterns'][0]).fuel_assembly.type.model
xml.startElement("loading_pattern ", {'basecore_ID':reactor_model.name,'core_id':reactor_model.name+'_U'+str(unit.unit)})
for cycle in cycles:
control_rod_assembly_loading_patterns=cycle.control_rod_assembly_loading_patterns.all()
if control_rod_assembly_loading_patterns:
xml.startElement('control_rod', {'cycle':str(cycle.cycle)})
xml.startElement('map', {})
cra_position_lst=[]
for reactor_position in reactor_positions:
cra_pattern=control_rod_assembly_loading_patterns.filter(reactor_position=reactor_position)
if cra_pattern:
cra=cra_pattern.get().control_rod_assembly
cra_position_lst.append('CR1')
else:
cra_position_lst.append('0')
xml.characters(smart_text(' '.join(cra_position_lst)))
xml.endElement('map')
xml.endElement('control_rod')
for cycle in cycles:
#fuel_assembly_loading_patterns=cycle.fuel_assembly_loading_patterns.all()
#burnable_posison_assembly_positions=cycle.burnable_posison_assembly_positions.all()
fuel_lst=[]
previous_cycle_lst=[]
'''
for fuel_assembly_loading_pattern in fuel_assembly_loading_patterns:
fuel_assembly_type=fuel_assembly_loading_pattern.fuel_assembly.type
burnable_poison_assembly_position=burnable_posison_assembly_positions.filter(reactor_position=fuel_assembly_loading_pattern.reactor_position)
if burnable_poison_assembly_position:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=burnable_poison_assembly_position.get().burnable_poison_assembly).get()
base_fuel=ibis.base_fuels.get()
print(base_fuel)
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
else:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=None).get()
base_fuels=ibis.base_fuels.all()
for base_fuel in base_fuels:
if not base_fuel.base_fuel.if_insert_burnable_fuel:
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
'''
for reactor_position in reactor_positions:
fuel_assembly_loading_pattern=cycle.fuel_assembly_loading_patterns.filter(reactor_position=reactor_position).get()
burnable_poison_assembly_position=cycle.burnable_posison_assembly_positions.filter(reactor_position=reactor_position)
fuel_assembly_type=fuel_assembly_loading_pattern.fuel_assembly.type
if fuel_assembly_loading_pattern.get_previous():
[previous_cycle,previous_position_row,previous_position_column]=fuel_assembly_loading_pattern.get_previous().split('-')
position='{}{}'.format(previous_position_row.zfill(2), previous_position_column.zfill(2))
fuel_lst.append(position)
if previous_cycle!=cycle.cycle-1:
previous_cycle_lst.append([previous_cycle,reactor_position.row,reactor_position.column])
else:
if burnable_poison_assembly_position:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=burnable_poison_assembly_position.get().burnable_poison_assembly).get()
base_fuel=ibis.base_fuels.get()
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
else:
ibis=Ibis.objects.filter(fuel_assembly_type=fuel_assembly_type,burnable_poison_assembly=None).get()
base_fuels=ibis.base_fuels.all()
for base_fuel in base_fuels:
if not base_fuel.base_fuel.if_insert_burnable_fuel():
fuel_lst.append(base_fuel.base_fuel.fuel_identity)
print(len(fuel_lst))
xml.startElement('fuel', {'cycle':str(cycle.cycle)})
xml.startElement('map', {})
xml.characters(smart_text(' '.join(fuel_lst)))
xml.endElement('map')
for previous_cycle_info in previous_cycle_lst:
if int(previous_cycle_info[0])!=cycle.cycle-1:
xml.startElement('cycle', {'row':str(previous_cycle_info[1]),'col':str(previous_cycle_info[2])})
xml.characters(smart_text(previous_cycle_info[0]))
xml.endElement('cycle')
xml.endElement('fuel')
xml.endElement("loading_pattern ")
xml.endDocument()
return stream.getvalue()
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def _get_obj_pk(self, obj):
"""
returns the objects pk or the natural key, joined
"""
if self.use_natural_keys and hasattr(obj, 'natural_key'):
raw_nat_key = obj.natural_key()
obj_pk = smart_text(NATURAL_KEY_JOINER.join(raw_nat_key))
keytype = 'natural'
else:
obj_pk = obj._get_pk_val()
keytype = 'pk'
return obj_pk, keytype
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("xliff", {
"version": "1.2",
"xmlns": "urn:oasis:names:tc:xliff:document:1.2",
"xmlns:d": "https://docs.djangoproject.com/"
})
def start_fileblock(self, obj):
"""
Start the <file><body> block
"""
self.indent(1)
obj_key, keytype = self._get_obj_pk(obj)
self.xml.startElement("file", {
"original": "%s.%s" % (smart_text(obj._meta), obj_key),
"datatype": "database",
"source-language": settings.LANGUAGE_CODE,
"d:keytype": keytype,
})
self.xml.startElement("body", {})
def end_fileblock(self):
"""
End the <file><body> block
"""
self.indent(1)
self.xml.endElement("body")
self.xml.endElement("file")
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("xliff")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.start_fileblock(obj)
self.indent(2)
obj_pk, keytype = self._get_obj_pk(obj)
attrs = {
"restype": "row",
"d:keytype": keytype
}
if obj_pk is not None:
attrs["resname"] = "%s.%s" % (smart_text(obj._meta), obj_pk)
else:
attrs["resname"] = smart_text(obj._meta)
self.xml.startElement("group", attrs)
if obj._meta.pk.__class__.__name__ != "AutoField":
self.handle_field(obj, obj._meta.pk)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(2)
self.xml.endElement("group")
self.indent(1)
self.end_fileblock()
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(3)
internal_type = field.get_internal_type()
attrs = {
"id": field.name,
"resname": field.name,
"restype": "x-%s" % internal_type,
"translate": "no",
}
if internal_type in ("CharField", "TextField"):
attrs["translate"] = "yes"
if internal_type == "CharField":
attrs["size-unit"] = "char"
attrs["maxwidth"] = str(field.max_length)
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
self.xml.characters(field.value_to_string(obj))
else:
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
related_att = getattr(obj, field.get_attname())
if related_att is not None:
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
self._start_relational_field(field, keytype="natural")
related = getattr(obj, field.name)
# If related object has a natural key, use it
related = related.natural_key()
nat_key = NATURAL_KEY_JOINER.join(related)
self.xml.characters(smart_text(nat_key))
# Iterable natural keys are rolled out as subelements
# for key_value in related:
# self.xml.startElement("natural", {})
# self.xml.characters(smart_text(key_value))
# self.xml.endElement("natural")
else:
self._start_relational_field(field)
self.xml.characters(smart_text(related_att))
else:
self._start_relational_field(field)
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
if field.rel.through._meta.auto_created:
# self._start_relational_field(field)
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
nat_key = NATURAL_KEY_JOINER.join(natural)
field_id = "%s.%s" % (obj.pk, nat_key)
self._start_relational_field(field, field_id=field_id, keytype="natural")
self.xml.characters(smart_text(nat_key))
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
# Iterable natural keys are rolled out as subelements
# self.xml.startElement("object", {})
# for key_value in natural:
# self.xml.startElement("natural", {})
# self.xml.characters(smart_text(key_value))
# self.xml.endElement("natural")
# self.xml.endElement("object")
else:
def handle_m2m(value):
field_id = "%s.%s" % (obj.pk, value._get_pk_val())
self._start_relational_field(field, field_id)
self.xml.characters(smart_text(value._get_pk_val()))
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
# self.xml.addQuickElement("object", attrs={
# 'pk' : smart_text(value._get_pk_val())
# })
for relobj in getattr(obj, field.name).iterator():
handle_m2m(relobj)
def handle_gfk_field(self, obj, field):
"""
Handle the GenericForeignKey
<trans-unit id=<gfk.name>
"""
obj_pk, keytype = self._get_obj_pk(getattr(obj, field.ct_field))
attrs = {
"id": field.name,
"resname": field.name,
"restype": "x-%s" % field.__class__.__name__,
"translate": "no",
"d:keytype": keytype,
"d:rel": "GenericManyToOneRel",
"d:to": obj_pk,
}
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
# Get a "string version" of the object's data.
gfk_obj = getattr(obj, field.name)
if gfk_obj is not None:
gfk_pk, keytype = self._get_obj_pk(gfk_obj)
if keytype == 'natural':
self.xml.characters(gfk_pk)
else:
self.xml.addQuickElement("None")
self.xml.endElement("source")
self.indent(3)
self.xml.endElement("trans-unit")
def _start_relational_field(self, field, field_id="", keytype="pk"):
"""
Helper to output the <trans-unit> element for relational fields
"""
self.indent(3)
internal_type = field.get_internal_type()
attrs = {
"id": field_id or field.name,
"resname": field.name,
"restype": "x-%s" % internal_type,
"translate": "no",
"d:rel": field.rel.__class__.__name__,
"d:to": smart_text(field.rel.to._meta),
"d:keytype": keytype,
}
self.xml.startElement("trans-unit", attrs)
self.indent(4)
self.xml.startElement("source", {})
class XML(object):
"""
Serializes a QuerySet to XML.
"""
def __init__(self, stream, **kwargs):
self.options = kwargs
self.stream = stream
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
def dumps(self, data, indent=0):
#print indent
#self.indent(indent)
#self.xml.startElement("object", {})
if isinstance(data, (list, tuple)):
for item in data:
#self.indent(indent)
#self.xml.startElement("list-item", {})
self.dumps(item, indent)
#self.xml.endElement("list-item")
elif isinstance(data, dict):
for key, value in data.iteritems():
self.indent(indent + 1)
self.xml.startElement(key, {})
self.dumps(value, indent + 1)
self.xml.endElement(key)
self.indent(indent)
else:
self.xml.characters(smart_unicode(data))
#self.xml.endElement("object")
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml.startDocument()
self.xml.startElement("django-objects", {"version" : "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
# def start_object(self, obj):
# """
# Called as each object is handled.
# """
# if not hasattr(obj, "_meta"):
# raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
#
# self.indent(1)
# obj_pk = obj._get_pk_val()
# if obj_pk is None:
# attrs = {"model": smart_unicode(obj._meta),}
# else:
# attrs = {
# "pk": smart_unicode(obj._get_pk_val()),
# "model": smart_unicode(obj._meta),
# }
#
# self.xml.startElement("object", attrs)
#
# def end_object(self, obj):
# """
# Called after handling all fields for an object.
# """
# self.indent(1)
# self.xml.endElement("object")
#
# def handle_field(self, obj, field):
# """
# Called to handle each field on an object (except for ForeignKeys and
# ManyToManyFields)
# """
# self.indent(2)
# self.xml.startElement("field", {
# "name" : field.name,
# "type" : field.get_internal_type()
# })
#
# # Get a "string version" of the object's data.
# if getattr(obj, field.name) is not None:
# self.xml.characters(field.value_to_string(obj))
# else:
# self.xml.addQuickElement("None")
#
# self.xml.endElement("field")
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
single_object = False
objects_started = False
list_elem_name = None
ns = None
def serialize(self, queryset, **options):
self.single_object = options.get("single_object", False)
return base.Serializer.serialize(self, queryset, **options)
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace(
'\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(
self.stream, self.options.get("encoding",
settings.DEFAULT_CHARSET))
self.xml.startDocument()
def end_serialization(self):
"""
End serialization -- end the document.
"""
if self.objects_started:
self.indent(0)
if not self.single_object:
elem = ""
if self.ns:
elem += self.ns + ":"
elem += self.list_elem_name
self.xml.endElement(elem)
self.indent(0)
else:
self.xml.startElement("empty", {})
self.xml.endElement("empty")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError(
"Non-model object (%s) encountered during serialization" %
type(obj))
model_name = smart_unicode(obj._meta)
elem_name = model_name.split(".")[-1]
if not hasattr(obj._meta, 'ns'):
setattr(obj._meta, 'ns', "_".join(model_name.split(".")[:-1]))
if not self.ns:
self.ns = obj._meta.ns
if not hasattr(obj._meta, 'ns_uri'):
setattr(obj._meta, 'ns_uri',
"urn:x-ns:hotjazz:" + ".".join(model_name.split(".")[:-1]))
xmlnstag = "xmlns:" + obj._meta.ns
attrs = {
"xmlns:hotjazz": "urn:x-ns:hotjazz",
xmlnstag: obj._meta.ns_uri,
"xmlns": obj._meta.ns_uri
}
if not self.objects_started:
self.objects_started = True
if not self.single_object:
self.list_elem_name = elem_name + "_list"
attrs["hotjazz:type"] = "model_list"
self.xml.startElement(obj._meta.ns + ":" + self.list_elem_name,
attrs)
self.indent(1)
else:
if self.single_object:
raise base.SerializationError(
"Expecting one model object but got another one (%s) during serialization"
% type(obj))
obj_pk = obj._get_pk_val()
attrs["hotjazz:type"] = "model"
if obj_pk is not None:
attrs["hotjazz:pk"] = smart_unicode(obj._get_pk_val())
self.xml.startElement(obj._meta.ns + ":" + elem_name, attrs)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
if self.single_object:
self.indent(0)
else:
self.indent(1)
model_name = smart_unicode(obj._meta)
elem_name = model_name.split(".")[-1]
self.xml.endElement(obj._meta.ns + ":" + elem_name)
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(2)
self.xml.startElement(obj._meta.ns + ":" + field.name,
{"hotjazz:type": field.get_internal_type()})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
self.xml.characters(
escape_xml_illegal_chars(field.value_to_string(obj)))
else:
pass
#self.xml.addQuickElement("None")
self.xml.endElement(obj._meta.ns + ":" + field.name)
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
self._start_relational_field(obj, field, "ForeignKeyRelation")
related = getattr(obj, field.name)
if related is not None:
elem_name = field.name + "_natural_ref"
self.xml.startElement(obj._meta.ns + ":" + elem_name, {})
if self.use_natural_keys and hasattr(related, 'natural_key'):
# If related object has a natural key, use it
related = related.natural_key()
# Iterable natural keys are rolled out as subelements
for key_value in related:
self.xml.startElement("hotjazz:natural_ref", {})
self.xml.characters(
escape_xml_illegal_chars(smart_unicode(key_value)))
self.xml.endElement("hotjazz:natural_ref")
else:
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)
self.xml.startElement("hotjazz:pk_ref", {})
self.xml.characters(
escape_xml_illegal_chars(smart_unicode(related)))
self.xml.endElement("hotjazz:pk_ref")
self.xml.endElement(obj._meta.ns + ":" + elem_name)
else:
pass
#self.xml.addQuickElement("None")
self.xml.endElement(obj._meta.ns + ":" + field.name)
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
item_name = smart_unicode(field.rel.to._meta)
item_elem_name = item_name.split(".")[-1]
if field.rel.through._meta.auto_created:
self._start_relational_field(obj, field, "ManyToManyRelation")
if self.use_natural_keys and hasattr(field.rel.to, 'natural_key') and \
hasattr(field.rel.to._default_manager, 'get_by_natural_key'): # to match deserialize
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
# Iterable natural keys are rolled out as subelements
self.xml.startElement(obj._meta.ns + ":" + item_elem_name,
{})
for key_value in natural:
self.xml.startElement("hotjazz:natural_ref", {})
self.xml.characters(
escape_xml_illegal_chars(smart_unicode(key_value)))
self.xml.endElement("hotjazz:natural_ref")
self.xml.endElement(obj._meta.ns + ":" + item_elem_name)
else:
def handle_m2m(value):
self.xml.addQuickElement(
obj._meta.ns + ":" + item_elem_name,
attrs={
'hotjazz:pk_ref':
smart_unicode(value._get_pk_val())
})
at_least_one = False
for relobj in getattr(obj, field.name).iterator():
at_least_one = True
self.indent(3)
handle_m2m(relobj)
if at_least_one:
self.indent(2)
self.xml.endElement(obj._meta.ns + ":" + field.name)
def _start_relational_field(self, obj, field, reltype):
"""
Helper to output the <field> element for relational fields
"""
self.indent(2)
self.xml.startElement(obj._meta.ns + ":" + field.name, {
"hotjazz:type": reltype + "Field",
})
class Serializer(base.Serializer):
internal_use_only = False
ROOT_ELEMENT = "objects"
def get_loader(self):
return Loader
def serialize(self, queryset, **options):
self.finalize = options.pop("finalize", True)
self.indent_level = options.pop("indent", None)
self.encoding = options.pop("encoding", settings.DEFAULT_CHARSET)
return super(Serializer, self).serialize(queryset, **options)
def indent(self, level):
if self.indent_level is not None:
self.xml.ignoreWhitespace("\n" + " " * self.indent_level * level)
def start_object(self, obj):
super(Serializer, self).start_object(obj)
self._current["xml_verbose_name"] = smart_str(obj._meta.verbose_name)
def handle_m2m_field(self, obj, field):
super(Serializer, self).handle_m2m_field(obj, field)
self._current[field.name].insert(0, smart_str(getattr(obj, field.name).model._meta.verbose_name))
def serialize_reverse_fields(self, obj):
super(Serializer, self).serialize_reverse_fields(obj)
for fieldname in self.reverse_fields:
related = getattr(obj, fieldname)
if isinstance(self._current[fieldname], list):
self._current[fieldname].insert(0, smart_str(related.model._meta.verbose_name))
def end_serialization(self):
super(Serializer, self).end_serialization()
if not self.finalize:
return
self.xml = SimplerXMLGenerator(self.stream, self.encoding)
self.xml.startDocument()
self.xml.startElement(self.ROOT_ELEMENT, {})
if not isinstance(self.objects, list):
self.objects = [self.objects]
for object in self.objects:
self.indent(1)
name = self._get_xml_name(object)
self.xml.startElement(name, {})
self.handle_dict(object)
self.xml.endElement(name)
self.indent(0)
self.xml.endElement(self.ROOT_ELEMENT)
self.xml.endDocument()
def handle_dict(self, d):
# Make sure this key is removed.
if d.has_key("xml_verbose_name"):
del d["xml_verbose_name"]
for k, v in d.items():
self.indent(2)
if self.render_only and isinstance(v, list):
self.handle_list(v, name=k)
else:
self.xml.startElement(k, {})
if isinstance(v, list):
self.handle_list(v)
elif isinstance(v, dict):
self.handle_dict(v)
else:
self.xml.characters(smart_str(v))
self.xml.endElement(k)
def handle_list(self, l, name=None):
if l and not name:
name = smart_str(l.pop(0))
else:
if not name:
name = "object"
for object in l:
self.xml.startElement(name, {})
if isinstance(object, dict):
self.handle_dict(object)
else:
self.xml.characters(smart_str(object))
self.xml.endElement(name)
def getvalue(self):
if callable(getattr(self.stream, "getvalue", None)):
return self.stream.getvalue()
def _get_xml_name(self, obj):
if isinstance(obj, dict) and obj.has_key("xml_verbose_name"):
return obj.pop("xml_verbose_name")
return "object"
class CirkwiPOISerializer:
def __init__(self, request, stream):
self.xml = SimplerXMLGenerator(stream, 'utf8')
self.request = request
self.stream = stream
def serialize_field(self, name, value, attrs={}):
if not value and not attrs:
return
value = unicode(value)
self.xml.startElement(name, attrs)
if u'<' in value or u'>' in value or u'&' in value:
self.stream.write('<![CDATA[%s]]>' % value)
else:
self.xml.characters(value)
self.xml.endElement(name)
def serialize_medias(self, request, pictures):
if not pictures:
return
self.xml.startElement('medias', {})
self.xml.startElement('images', {})
for picture in pictures:
self.xml.startElement('image', {})
self.serialize_field('legende', picture['legend'])
self.serialize_field('url', request.build_absolute_uri(picture['url']))
self.serialize_field('credit', picture['author'])
self.xml.endElement('image')
self.xml.endElement('images')
self.xml.endElement('medias')
def serialize_pois(self, pois):
for poi in pois:
self.xml.startElement('poi', {
'date_creation': timestamp(poi.date_insert),
'date_modification': timestamp(poi.date_update),
'id_poi': str(poi.pk),
})
if poi.type.cirkwi:
self.xml.startElement('categories', {})
self.serialize_field('categorie', str(poi.type.cirkwi.eid), {'nom': poi.type.cirkwi.name})
self.xml.endElement('categories')
orig_lang = translation.get_language()
self.xml.startElement('informations', {})
for lang in poi.published_langs:
translation.activate(lang)
self.xml.startElement('information', {'langue': lang})
self.serialize_field('titre', poi.name)
self.serialize_field('description', plain_text(poi.description))
self.serialize_medias(self.request, poi.serializable_pictures)
self.xml.endElement('information')
translation.activate(orig_lang)
self.xml.endElement('informations')
self.xml.startElement('adresse', {})
self.xml.startElement('position', {})
coords = poi.geom.transform(4326, clone=True).coords
self.serialize_field('lat', coords[1])
self.serialize_field('lng', coords[0])
self.xml.endElement('position')
self.xml.endElement('adresse')
self.xml.endElement('poi')
def serialize(self, pois):
self.xml.startDocument()
self.xml.startElement('pois', {'version': '2'})
self.serialize_pois(pois)
self.xml.endElement('pois')
self.xml.endDocument()
def render(self, capabilities, prettyprint=False):
"""
parameters:
capabilities = queryset of voresource_capabilities
prettyprint = flag for pretty printing the xml output (including whitespace and linebreaks)
"""
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
# add a comment
xml._write(self.comment)
# add namespace definitions
nsattrs = {}
nsattrs['version'] = self.version
#nsattrs['encoding'] = charser
nsattrs['xmlns:vosi'] = self.ns_vosicap
nsattrs['xmlns:xsi'] = self.ns_xsi
nsattrs['xmlns:vs'] = self.ns_vs
nsattrs['xmlns:vr'] = self.ns_vr
# add root node
xml.startElement('vosi:capabilities', nsattrs)
# Add all the capabilities, including those for VOSI endpoint,
# extract them from the database using the provided queryset.
# The following lookup is not efficient, since there is a database
# call for each object, it would be more efficient to get a list of
# all capabilities, interfaces and accessurls and then match them here.
for capability in capabilities:
attrs = {}
if capability.standardID:
attrs['standardID'] = str(capability.standardID)
xml.startElement('capability', attrs)
interfaces = capability.voresource_interface_set.all()
for interface in interfaces:
attrs = {}
if interface.type:
attrs['xsi:type'] = interface.type
xml.startElement('interface', attrs)
accessurls = interface.voresource_accessurl_set.all()
for accessurl in accessurls:
attrs = {}
attrs[
'use'] = accessurl.use # throw error, if its not there?
xml.startElement('accessURL', attrs)
xml.characters(smart_unicode(accessurl.url))
xml.endElement('accessURL')
xml.endElement('interface')
xml.endElement('capability')
xml.endElement('vosi:capabilities')
xml.endDocument()
xml_string = stream.getvalue()
# make the xml pretty, i.e. use linebreaks and indentation
# the sax XMLGenerator behind SimpleXMLGenerator does not seem to support this,
# thus need a library that can do it.
# TODO: since we use lxml anyway, maybe build the whole xml-tree with lxml.etree!
# NOTE: This removes any possibly existing comments from the xml output!
if prettyprint is True:
parsed = etree.fromstring(xml_string)
pretty_xml = etree.tostring(parsed, pretty_print=True)
xml_string = pretty_xml
return xml_string
class Serializer(base.Serializer):
"""Serialize a QuerySet to XML."""
def indent(self, level):
if self.options.get('indent') is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent') * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
attrs = {'model': str(obj._meta)}
if not self.use_natural_primary_keys or not hasattr(obj, 'natural_key'):
obj_pk = obj.pk
if obj_pk is not None:
attrs['pk'] = str(obj_pk)
self.xml.startElement("object", attrs)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Handle each field on an object (except for ForeignKeys and
ManyToManyFields).
"""
self.indent(2)
self.xml.startElement('field', {
'name': field.name,
'type': field.get_internal_type(),
})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
value = field.value_to_string(obj)
if field.get_internal_type() == 'JSONField':
# Dump value since JSONField.value_to_string() doesn't output
# strings.
value = json.dumps(value, cls=field.encoder)
try:
self.xml.characters(value)
except UnserializableContentError:
raise ValueError("%s.%s (pk:%s) contains unserializable characters" % (
obj.__class__.__name__, field.name, obj.pk))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
Handle a ForeignKey (they need to be treated slightly
differently from regular fields).
"""
self._start_relational_field(field)
related_att = getattr(obj, field.get_attname())
if related_att is not None:
if self.use_natural_foreign_keys and hasattr(field.remote_field.model, 'natural_key'):
related = getattr(obj, field.name)
# If related object has a natural key, use it
related = related.natural_key()
# Iterable natural keys are rolled out as subelements
for key_value in related:
self.xml.startElement("natural", {})
self.xml.characters(str(key_value))
self.xml.endElement("natural")
else:
self.xml.characters(str(related_att))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_m2m_field(self, obj, field):
"""
Handle a ManyToManyField. Related objects are only serialized as
references to the object's PK (i.e. the related *data* is not dumped,
just the relation).
"""
if field.remote_field.through._meta.auto_created:
self._start_relational_field(field)
if self.use_natural_foreign_keys and hasattr(field.remote_field.model, 'natural_key'):
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
# Iterable natural keys are rolled out as subelements
self.xml.startElement("object", {})
for key_value in natural:
self.xml.startElement("natural", {})
self.xml.characters(str(key_value))
self.xml.endElement("natural")
self.xml.endElement("object")
else:
def handle_m2m(value):
self.xml.addQuickElement("object", attrs={
'pk': str(value.pk)
})
m2m_iter = getattr(obj, '_prefetched_objects_cache', {}).get(
field.name,
getattr(obj, field.name).iterator(),
)
for relobj in m2m_iter:
handle_m2m(relobj)
self.xml.endElement("field")
def _start_relational_field(self, field):
"""Output the <field> element for relational fields."""
self.indent(2)
self.xml.startElement('field', {
'name': field.name,
'rel': field.remote_field.__class__.__name__,
'to': str(field.remote_field.model._meta),
})
class Serializer(base.Serializer):
"""Serialize a QuerySet to XML."""
def indent(self, level):
if self.options.get('indent') is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent') * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
attrs = {'model': str(obj._meta)}
if not self.use_natural_primary_keys or not hasattr(obj, 'natural_key'):
obj_pk = obj.pk
if obj_pk is not None:
attrs['pk'] = str(obj_pk)
self.xml.startElement("object", attrs)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Handle each field on an object (except for ForeignKeys and
ManyToManyFields).
"""
self.indent(2)
self.xml.startElement('field', {
'name': field.name,
'type': field.get_internal_type(),
})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
try:
self.xml.characters(field.value_to_string(obj))
except UnserializableContentError:
raise ValueError("%s.%s (pk:%s) contains unserializable characters" % (
obj.__class__.__name__, field.name, obj.pk))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def indent(self, level):
if self.options.get('indent', None) is not None:
self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version": "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-objects")
self.xml.endDocument()
def start_object(self, obj):
"""
Called as each object is handled.
"""
if not hasattr(obj, "_meta"):
raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
self.indent(1)
attrs = {"model": smart_text(obj._meta)}
if not self.use_natural_primary_keys or not hasattr(obj, 'natural_key'):
obj_pk = obj._get_pk_val()
if obj_pk is not None:
attrs['pk'] = smart_text(obj_pk)
self.xml.startElement("object", attrs)
def end_object(self, obj):
"""
Called after handling all fields for an object.
"""
self.indent(1)
self.xml.endElement("object")
def handle_field(self, obj, field):
"""
Called to handle each field on an object (except for ForeignKeys and
ManyToManyFields)
"""
self.indent(2)
self.xml.startElement("field", {
"name": field.name,
"type": field.get_internal_type()
})
# Get a "string version" of the object's data.
if getattr(obj, field.name) is not None:
self.xml.characters(field.value_to_string(obj))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_fk_field(self, obj, field):
"""
Called to handle a ForeignKey (we need to treat them slightly
differently from regular fields).
"""
self._start_relational_field(field)
related_att = getattr(obj, field.get_attname())
if related_att is not None:
if self.use_natural_foreign_keys and hasattr(field.rel.to, 'natural_key'):
related = getattr(obj, field.name)
# If related object has a natural key, use it
related = related.natural_key()
# Iterable natural keys are rolled out as subelements
for key_value in related:
self.xml.startElement("natural", {})
self.xml.characters(smart_text(key_value))
self.xml.endElement("natural")
else:
self.xml.characters(smart_text(related_att))
else:
self.xml.addQuickElement("None")
self.xml.endElement("field")
def handle_m2m_field(self, obj, field):
"""
Called to handle a ManyToManyField. Related objects are only
serialized as references to the object's PK (i.e. the related *data*
is not dumped, just the relation).
"""
if field.rel.through._meta.auto_created:
self._start_relational_field(field)
if self.use_natural_foreign_keys and hasattr(field.rel.to, 'natural_key'):
# If the objects in the m2m have a natural key, use it
def handle_m2m(value):
natural = value.natural_key()
# Iterable natural keys are rolled out as subelements
self.xml.startElement("object", {})
for key_value in natural:
self.xml.startElement("natural", {})
self.xml.characters(smart_text(key_value))
self.xml.endElement("natural")
self.xml.endElement("object")
else:
def handle_m2m(value):
self.xml.addQuickElement("object", attrs={
'pk': smart_text(value._get_pk_val())
})
for relobj in getattr(obj, field.name).iterator():
handle_m2m(relobj)
self.xml.endElement("field")
def _start_relational_field(self, field):
"""
Helper to output the <field> element for relational fields
"""
self.indent(2)
self.xml.startElement("field", {
"name": field.name,
"rel": field.rel.__class__.__name__,
"to": smart_text(field.rel.to._meta),
})
def characters(self, contents):
try:
cdata = '<![CDATA[{}]]>'.format(contents) # noqa
self.ignorableWhitespace(contents)
except ValueError:
SimplerXMLGenerator.characters(self, contents[start:]) # noqa
