def WebFinger_HostMeta(request):
res = HttpResponse(content_type="application/xml")
xmlHandle = SimplerXMLGenerator(res, settings.DEFAULT_CHARSET)
xmlHandle.startDocument()
xmlHandle.startElement("XRD", {"xmlns": "http://docs.oasis-open.org/ns/xri/xrd-1.0"})
xmlHandle.addQuickElement("Link", attrs={"rel": "lrdd", "type": "application/xrd+xml", "template": "https://" + settings.CP_ENDPOINT + "/.well-known/webfinger?resource={uri}"})
xmlHandle.endElement("XRD")
xmlHandle.endDocument()
return res
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 sitemap_generator(request, maps, page, current_site):
output = StringIO()
protocol = request.is_secure() and 'https' or 'http'
xml = SimplerXMLGenerator(output, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement(
'urlset', {'xmlns': 'http://www.sitemaps.org/schemas/sitemap/0.9'})
yield output.getvalue()
pos = output.tell()
for site in maps:
if callable(site):
if issubclass(site, RequestSitemap):
site = site(request=request)
else:
site = site()
elif hasattr(site, 'request'):
site.request = request
try:
urls = site.get_urls(page=page, site=current_site,
protocol=protocol)
except InvalidPage:
raise Http404('Page not found')
for url in urls:
xml.startElement('url', {})
xml.addQuickElement('loc', url['location'])
try:
if url['lastmod']:
xml.addQuickElement(
'lastmod', url['lastmod'].strftime('%Y-%m-%d'))
except (KeyError, AttributeError):
pass
try:
if url['changefreq']:
xml.addQuickElement('changefreq', url['changefreq'])
except KeyError:
pass
try:
if url['priority']:
xml.addQuickElement('priority', url['priority'])
except KeyError:
pass
xml.endElement('url')
output.seek(pos)
yield output.read()
pos = output.tell()
xml.endElement('urlset')
xml.endDocument()
output.seek(pos)
last = output.read()
output.close()
yield last
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def error(self, request, status_code, error_dict=None):
"""
Return XML error response that includes a human readable error
message, application-specific errors and a machine readable
status code.
"""
from django.conf import settings
if not error_dict:
error_dict = ErrorDict()
response = HttpResponse(mimetype = self.mimetype)
response.status_code = status_code
xml = SimplerXMLGenerator(response, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement("django-error", {})
xml.addQuickElement(name="error-message", contents='%d %s' % (status_code, STATUS_CODE_TEXT[status_code]))
xml.addQuickElement(name="status-code", contents=str(status_code))
if error_dict:
xml.startElement("model-errors", {})
for (model_field, errors) in error_dict.items():
for error in errors:
xml.addQuickElement(name=model_field, contents=error)
xml.endElement("model-errors")
xml.endElement("django-error")
xml.endDocument()
return response
def place_kml(request, encoding='utf-8', mimetype='text/plain'):
"""
Write out all the known places to KML
"""
# mimetype = "application/vnd.google-earth.kml+xml"
# mimetype = "text/html"
places = Locality.objects.exclude(
latitude=None).annotate(Count('museumobject'))
response = HttpResponse(mimetype=mimetype)
handler = SimplerXMLGenerator(response, encoding)
handler.startDocument()
handler.startElement(u"kml",
{u"xmlns": u"http://www.opengis.net/kml/2.2"})
handler.startElement(u"Document", {})
for place in places:
place_url = request.build_absolute_uri(place.get_absolute_url())
handler.startElement(u"Placemark", {})
handler.addQuickElement(u"name",
"%s (%s)" % (place.name, place.museumobject__count))
handler.addQuickElement(u"description",
'<a href="%s">%s</a>' % (place_url, place.__unicode__()))
handler.startElement(u"Point", {})
handler.addQuickElement(u"coordinates", place.get_kml_coordinates())
handler.endElement(u"Point")
handler.endElement(u"Placemark")
handler.endElement(u"Document")
handler.endElement(u"kml")
return response
def error(self, request, status_code, error_dict=None):
"""
Return XML error response that includes a human readable error
message, application-specific errors and a machine readable
status code.
"""
from django.conf import settings
if not error_dict:
error_dict = ErrorDict()
response = HttpResponse(mimetype = self.mimetype)
response.status_code = status_code
xml = SimplerXMLGenerator(response, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement("django-error", {})
xml.addQuickElement(name="error-message", contents='%d %s' % (status_code, STATUS_CODE_TEXT[status_code]))
xml.addQuickElement(name="status-code", contents=str(status_code))
if error_dict:
xml.startElement("model-errors", {})
for (model_field, errors) in error_dict.items():
for error in errors:
xml.addQuickElement(name=model_field, contents=error)
xml.endElement("model-errors")
xml.endElement("django-error")
xml.endDocument()
return response
def sitemap_generator(request, maps, page, current_site):
output = StringIO()
protocol = request.is_secure() and 'https' or 'http'
xml = SimplerXMLGenerator(output, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement('urlset', {'xmlns':'http://www.sitemaps.org/schemas/sitemap/0.9'})
yield output.getvalue()
pos = output.tell()
for site in maps:
if callable(site):
if issubclass(site, RequestSitemap):
site = site(request=request)
else:
site = site()
elif hasattr(site, 'request'):
site.request = request
for url in site.get_urls(page=page, site=current_site, protocol=protocol):
xml.startElement('url', {})
xml.addQuickElement('loc', url['location'])
try:
if url['lastmod']:
xml.addQuickElement('lastmod', url['lastmod'].strftime('%Y-%m-%d'))
except (KeyError, AttributeError):
pass
try:
if url['changefreq']:
xml.addQuickElement('changefreq', url['changefreq'])
except KeyError:
pass
try:
if url['priority']:
xml.addQuickElement('priority', url['priority'])
except KeyError:
pass
xml.endElement('url')
output.seek(pos)
yield output.read()
pos = output.tell()
xml.endElement('urlset')
xml.endDocument()
output.seek(pos)
last = output.read()
output.close()
yield last
def __init__(self, error_message=None, content='', mimetype=None,
status=None, content_type='text/xml; charset=utf-8'):
super(TrackBackResponse, self).__init__(content=content,
mimetype=mimetype,
status=status,
content_type=content_type)
response_content = StringIO()
generator = SimplerXMLGenerator(response_content, 'utf-8')
generator.startDocument()
generator.startElement('response', {})
if error_message:
generator.addQuickElement('error', '1')
generator.addQuickElement('message', error_message)
else:
generator.addQuickElement('error', '0')
generator.endElement('response')
self.content = response_content.getvalue()
response_content.close()
self['Content-Length'] = str(len(self.content))
def sitemap_generator(request, maps, page, current_site):
output = StringIO()
xml = SimplerXMLGenerator(output, settings.DEFAULT_CHARSET)
xml.startDocument()
namespaces = {'xmlns':'http://www.sitemaps.org/schemas/sitemap/0.9'}
for site in maps:
ns_getter = getattr(site, "get_namespaces", lambda: {})
namespaces.update(ns_getter())
xml.startElement('urlset', namespaces)
yield output.getvalue()
pos = output.tell()
for site in maps:
if callable(site):
if issubclass(site, RequestSitemap):
site = site(request=request)
else:
site = site()
elif hasattr(site, 'request'):
site.request = request
for url in site.get_urls(page=page, site=current_site):
xml.startElement('url', {})
xml.addQuickElement('loc', url['location'])
try:
if url['lastmod']:
xml.addQuickElement('lastmod', url['lastmod'].strftime('%Y-%m-%d'))
except (KeyError, AttributeError):
pass
try:
if url['changefreq']:
xml.addQuickElement('changefreq', url['changefreq'])
except KeyError:
pass
try:
if url['priority']:
xml.addQuickElement('priority', url['priority'])
except KeyError:
pass
# Translations
translations = url.get("translations", None)
if translations:
for lang, uri in translations.items():
xml.addQuickElement("xhtml:link", attrs={
"rel": "alternate",
"hreflang": lang,
"href": uri
})
# Video extension
videos = url.get("videos", [])
if videos:
for video in videos:
xml.startElement("video:video", {})
for tag, value in video.items():
xml.addQuickElement("video:%s" % tag, value)
xml.endElement("video:video")
# Image extension
images = url.get("images", [])
if images:
for image in images:
xml.startElement("image:image", {})
for tag, value in image.items():
xml.addQuickElement("image:%s" % tag, value)
xml.endElement("image:image")
xml.endElement('url')
output.seek(pos)
yield output.read()
pos = output.tell()
xml.endElement('urlset')
xml.endDocument()
output.seek(pos)
last = output.read()
output.close()
yield last
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed["language"] is not None:
handler.startElement(u"feed", {u"xmlns": self.ns, u"xml:lang": self.feed["language"]})
else:
handler.startElement(u"feed", {u"xmlns": self.ns})
handler.addQuickElement(u"title", self.feed["title"])
handler.addQuickElement(u"link", "", {u"rel": u"alternate", u"href": self.feed["link"]})
if self.feed["feed_url"] is not None:
handler.addQuickElement(u"link", "", {u"rel": u"self", u"href": self.feed["feed_url"]})
handler.addQuickElement(u"id", self.feed["link"])
handler.addQuickElement(u"updated", rfc3339_date(self.latest_post_date()).decode("ascii"))
if self.feed["author_name"] is not None:
handler.startElement(u"author", {})
handler.addQuickElement(u"name", self.feed["author_name"])
if self.feed["author_email"] is not None:
handler.addQuickElement(u"email", self.feed["author_email"])
if self.feed["author_link"] is not None:
handler.addQuickElement(u"uri", self.feed["author_link"])
handler.endElement(u"author")
if self.feed["subtitle"] is not None:
handler.addQuickElement(u"subtitle", self.feed["subtitle"])
for cat in self.feed["categories"]:
handler.addQuickElement(u"category", "", {u"term": cat})
if self.feed["feed_copyright"] is not None:
handler.addQuickElement(u"rights", self.feed["feed_copyright"])
self.write_items(handler)
handler.endElement(u"feed")
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 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),
})
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed["title"])
handler.addQuickElement(u"link", self.feed["link"])
handler.addQuickElement(u"description", self.feed["description"])
if self.feed["language"] is not None:
handler.addQuickElement(u"language", self.feed["language"])
for cat in self.feed["categories"]:
handler.addQuickElement(u"category", cat)
if self.feed["feed_copyright"] is not None:
handler.addQuickElement(u"copyright", self.feed["feed_copyright"])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
class Serializer(base.Serializer):
"""
Serializes a QuerySet to XML.
"""
def __init__(self, *args, **kwargs):
super(Serializer, self).__init__(*args, **kwargs)
self._objects = []
def getvalue(self):
"""Wrap the serialized objects with XML headers and return."""
str = u"""<?xml version="1.0" encoding="utf-8"?>\n"""
str += u"""<django-objects version="1.0">\n"""
str += u"".join(self._objects)
str += u"""</django-objects>"""
return str
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):
"""Nothing needs to be done to start an object."""
pass
def end_object(self, obj):
"""Serialize the object to XML and add to the list of objects to output.
The output of ToXml is manipulated to replace the datastore model name in
the "kind" tag with the Django model name (which includes the Django
application name) to make importing easier.
"""
xml = obj._entity.ToXml()
xml = xml.replace(u"""kind="%s" """ % obj._entity.kind(),
u"""kind="%s" """ % unicode(obj._meta))
self._objects.append(xml)
def handle_field(self, obj, field):
"""Fields are not handled individually."""
pass
def handle_fk_field(self, obj, field):
"""Fields are not handled individually."""
pass
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.creates_table:
self._start_relational_field(field)
for relobj in getattr(obj, field.name).iterator():
self.xml.addQuickElement("object", attrs={"pk" : smart_unicode(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" : smart_unicode(field.rel.to._meta),
})
def atom_feed(request, encoding='utf-8', mimetype='application/atom+xml'):
feed_attrs = {u"xmlns": u"http://www.w3.org/2005/Atom",
u"xmlns:fh": u"http://purl.org/syndication/history/1.0"}
collections = Collection.objects.filter(is_public=True)
site = Site.objects.get(id=1)
updated = collections.order_by('-updated')[0].updated
feed_id = get_site_url(site, reverse('atom_feed'))
output = StringIO.StringIO()
handler = SimplerXMLGenerator(output, encoding)
handler.startDocument()
handler.startElement(u"feed", feed_attrs)
# Required Attributes
handler.addQuickElement(u"id", feed_id)
handler.addQuickElement(u"title", u"UQ Anthropology Museum Sub-collections")
handler.addQuickElement(u"updated", rfc3339_date(updated).decode('utf-8'))
# A complete feed, so remote client will monitor for deletes/updates
handler.addQuickElement(u"fh:complete")
# Optional
handler.addQuickElement(u"link", attrs={
u'rel': u'alternate',
u'href': get_site_url(site, reverse('collections_home')),
u'type': u'html'
})
for collection in collections:
entry_id = get_site_url(site, collection.get_absolute_url())
entry_updated = rfc3339_date(collection.updated).decode('utf-8')
handler.startElement(u"entry", {})
handler.addQuickElement(u"id", entry_id)
handler.addQuickElement(u"title", collection.title)
handler.addQuickElement(u'updated', entry_updated)
handler.addQuickElement(u'link', attrs={
u'rel': u'alternate',
u'href': get_site_url(site, collection.get_atom_url()),
u'type': u'application/atom+xml'
})
handler.endElement(u'entry')
handler.endElement(u'feed')
atom = output.getvalue()
response = HttpResponse(atom, mimetype=mimetype)
return response
def as_atom(self, encoding='utf-8'):
"""
Serialise to an Atom format
Uses the profile from http://dataspace.metadata.net/doc/atom
"""
syndication = Syndication.objects.get(id=1)
output = StringIO.StringIO()
site = Site.objects.get(id=1)
link = get_site_url(site, self.get_absolute_url())
site_id = get_site_url(site, "/")
handler = SimplerXMLGenerator(output, encoding)
handler.startDocument()
handler.startElement(u"entry", self.entry_attributes())
handler.addQuickElement(u"id", link)
handler.addQuickElement(u"title", self.title)
handler.addQuickElement(u'content', self.description, {'type': 'html'})
if self.date_published:
handler.addQuickElement(u"published", rfc3339_date(self.date_published).decode('utf-8'))
if self.last_published:
handler.addQuickElement(u"updated", rfc3339_date(self.last_published).decode('utf-8'))
handler.addQuickElement(u"link", attrs={
u'href': 'http://purl.org/dc/dcmitype/Collection',
u'rel': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
u'title': 'Collection'})
handler.addQuickElement(u"rights", self.rights)
handler.startElement(u"rdfa:meta",
{u'property': u'http://purl.org/dc/terms/accessRights',
u'content': self.access_rights})
handler.endElement(u"rdfa:meta")
handler.addQuickElement(u'link', attrs={
u'rel': u'http://purl.org/dc/terms/publisher',
u'href': syndication.curator_href,
u'title': syndication.curator_name
})
handler.startElement(u"source", {})
handler.addQuickElement(u"id", site_id)
handler.addQuickElement(u"title", site.name)
handler.startElement(u"author", {})
handler.addQuickElement(u"name", self.author.get_full_name())
handler.addQuickElement(u"email", self.author.email)
handler.endElement(u"author")
handler.endElement(u"source")
handler.startElement(u"link",
{u"rel": "http://xmlns.com/foaf/0.1/page",
u"href": link})
handler.endElement(u"link")
handler.addQuickElement(u'category', attrs={
u'term': u'http://purl.org/asc/1297.0/2008/for/1601',
u'scheme': u'http://purl.org/asc/1297.0/2008/for/',
u'label': u'1601 Anthropology'
})
# Published control
draft = u'no' if self.is_public else u'yes'
handler.startElement(u'app:control',
{u'xmlns:app': u'http://www.w3.org/2007/app'})
handler.addQuickElement(u'app:draft', draft)
handler.endElement(u'app:control')
self._add_categories(handler, site)
self._add_spatial(handler, site)
handler.endElement(u"entry")
return output.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:
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 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):
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 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", {})
"""
def write(self, outfile, encoding):
"""Write feed date into given outfile using given encoding.
@param outfile: 'file' to write feed data into, e.g. Django response
@type outfile: File
@param encoding: feed's encoding
@type encoding: string
"""
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version, u"xmlns:wfw": u"http://wellformedweb.org/CommentAPI/"})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"copyright", self.feed['feed_copyright'])
handler.addQuickElement(u"lastBuildDate", rfc2822_date(self.latest_post_date()).decode('ascii'))
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version, u"xmlns:wfw": u"http://wellformedweb.org/CommentAPI/"})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"copyright", self.feed['feed_copyright'])
handler.addQuickElement(u"lastBuildDate", rfc2822_date(self.latest_post_date()).decode('ascii'))
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
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", {})
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed['language'] is not None:
handler.startElement(u"feed", {u"xmlns": self.ns, u"xml:lang": self.feed['language']})
else:
handler.startElement(u"feed", {u"xmlns": self.ns})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", "", {u"rel": u"alternate", u"href": self.feed['link']})
if self.feed['feed_url'] is not None:
handler.addQuickElement(u"link", "", {u"rel": u"self", u"href": self.feed['feed_url']})
handler.addQuickElement(u"id", self.feed['link'])
handler.addQuickElement(u"updated", rfc3339_date(self.latest_post_date()).decode('ascii'))
if self.feed['author_name'] is not None:
handler.startElement(u"author", {})
handler.addQuickElement(u"name", self.feed['author_name'])
if self.feed['author_email'] is not None:
handler.addQuickElement(u"email", self.feed['author_email'])
if self.feed['author_link'] is not None:
handler.addQuickElement(u"uri", self.feed['author_link'])
handler.endElement(u"author")
if self.feed['subtitle'] is not None:
handler.addQuickElement(u"subtitle", self.feed['subtitle'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", "", {u"term": cat})
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"rights", self.feed['feed_copyright'])
self.write_items(handler)
handler.endElement(u"feed")
def sitemap_generator(request, maps, page, current_site):
output = StringIO()
xml = SimplerXMLGenerator(output, settings.DEFAULT_CHARSET)
xml.startDocument()
ns = {
'xmlns':'http://www.sitemaps.org/schemas/sitemap/0.9',
'xmlns:image':"http://www.google.com/schemas/sitemap-image/1.1",
}
xml.startElement('urlset', ns)
yield output.getvalue()
pos = output.tell()
for site in maps:
if callable(site):
if issubclass(site, RequestSitemap):
site = site(request=request)
else:
site = site()
elif hasattr(site, 'request'):
site.request = request
for url in site.get_urls(page=page, site=current_site):
xml.startElement('url', {})
xml.addQuickElement('loc', url['location'])
try:
if url['lastmod']:
xml.addQuickElement('lastmod', url['lastmod'].strftime('%Y-%m-%d'))
except (KeyError, AttributeError):
pass
try:
if url['changefreq']:
xml.addQuickElement('changefreq', url['changefreq'])
except KeyError:
pass
try:
if url['priority']:
xml.addQuickElement('priority', url['priority'])
except KeyError:
pass
try:
# This will generate image links, if the item has an 'image' attribute
img = url['item'].image
xml.startElement('image:image', {})
xml.addQuickElement('image:loc', request.build_absolute_uri(img.url))
try:
# if it also has name and description attributes, it will add those
# to the image sitemaps
xml.addQuickElement('image:title', url['item'].name)
xml.addQuickElement('image:caption', url['item'].description)
except: pass
xml.endElement('image:image')
except:
pass
xml.endElement('url')
output.seek(pos)
yield output.read()
pos = output.tell()
xml.endElement('urlset')
xml.endDocument()
output.seek(pos)
last = output.read()
output.close()
yield last
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),
})
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 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 write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version, u"xmlns:wfw": u"http://wellformedweb.org/CommentAPI/"})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed["title"])
handler.addQuickElement(u"link", self.feed["link"])
handler.addQuickElement(u"description", self.feed["description"])
if self.feed["language"] is not None:
handler.addQuickElement(u"language", self.feed["language"])
for cat in self.feed["categories"]:
handler.addQuickElement(u"category", cat)
if self.feed["feed_copyright"] is not None:
handler.addQuickElement(u"copyright", self.feed["feed_copyright"])
handler.addQuickElement(u"lastBuildDate", rfc2822_date(self.latest_post_date()).decode("ascii"))
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"copyright", self.feed['feed_copyright'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement("rss", {"version": self._version})
handler.startElement("channel", {})
handler.addQuickElement("title", self.feed['title'])
handler.addQuickElement("link", self.feed['link'])
handler.addQuickElement("description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement("language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement("category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement("copyright", self.feed['feed_copyright'])
handler.addQuickElement("lastBuildDate", rfc2822_date(self.latest_post_date()).decode('ascii'))
if self.feed['ttl'] is not None:
handler.addQuickElement("ttl", self.feed['ttl'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement("rss")
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),
})
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed['language'] is not None:
handler.startElement("feed", {"xmlns": self.ns, "xml:lang": self.feed['language']})
else:
handler.startElement("feed", {"xmlns": self.ns})
handler.addQuickElement("title", self.feed['title'])
handler.addQuickElement("link", "", {"rel": "alternate", "href": self.feed['link']})
if self.feed['feed_url'] is not None:
handler.addQuickElement("link", "", {"rel": "self", "href": self.feed['feed_url']})
handler.addQuickElement("id", self.feed['id'])
handler.addQuickElement("updated", rfc3339_date(self.latest_post_date()).decode('ascii'))
if self.feed['author_name'] is not None:
handler.startElement("author", {})
handler.addQuickElement("name", self.feed['author_name'])
if self.feed['author_email'] is not None:
handler.addQuickElement("email", self.feed['author_email'])
if self.feed['author_link'] is not None:
handler.addQuickElement("uri", self.feed['author_link'])
handler.endElement("author")
if self.feed['subtitle'] is not None:
handler.addQuickElement("subtitle", self.feed['subtitle'])
for cat in self.feed['categories']:
handler.addQuickElement("category", "", {"term": cat})
if self.feed['feed_copyright'] is not None:
handler.addQuickElement("rights", self.feed['feed_copyright'])
self.write_items(handler)
handler.endElement("feed")
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 write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement("rss", {"version": self._version})
handler.startElement("channel", {})
handler.addQuickElement("title", self.feed['title'])
handler.addQuickElement("link", self.feed['link'])
handler.addQuickElement("description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement("language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement("category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement("copyright", self.feed['feed_copyright'])
handler.addQuickElement(
"lastBuildDate",
rfc2822_date(self.latest_post_date()).decode('ascii'))
if self.feed['ttl'] is not None:
handler.addQuickElement("ttl", self.feed['ttl'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement("rss")
