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 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")