def test_document_link(self):
"""Try to export a document that links to other resources.
"""
with Transaction():
document = self.root.folder.document
version = document.get_editable()
version.content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p>
This is a reference to
<link target="_blank" reference="infrae-site" title="">Infrae</link>
</p>
</doc>""")
# Create a link that will be the target of our reference in our document
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addLink('link',
'Link to Infrae',
relative=False,
url='http://infrae.com')
service = component.getUtility(IReferenceService)
reference = service.new_reference(version, name="document link")
reference.set_target(self.root.folder.link)
reference.add_tag("infrae-site")
exported = self.assertExportEqual(self.root.folder,
'test_export_link.silvaxml')
self.assertEqual(exported.getZexpPaths(), [])
self.assertEqual(exported.getAssetPaths(), [])
self.assertEqual(exported.getProblems(), [])
def test_document_with_source_export(self):
with Transaction():
self.layer.login('manager')
factory = self.root.folder.manage_addProduct[
'SilvaExternalSources']
factory.manage_addCodeSource('codesource', 'A Code Source',
'script')
# add a script to the code source
factory = self.root.folder.codesource.manage_addProduct[
'PythonScripts']
factory.manage_addPythonScript('script')
script = self.root.folder.codesource.script
script.write('return "<ul><li>Item 1</li><li>Item 2</li></ul>"')
with Transaction():
self.layer.login('author')
doc = self.root.folder.document
doc_edit = doc.get_editable()
doc_edit.content = ParsedXML(
'test_document', """<?xml version="1.0" encoding="utf-8"?><doc>
<source id="codesource"></source>
<p type="normal">This is some text.</p>
</doc>""")
exported = self.assertExportEqual(self.root.folder,
'test_export_codesource.silvaxml')
# The code-source went into a ZEXP.
self.assertEqual(exported.getZexpPaths(),
[(('', 'root', 'folder', 'codesource'), '1.zexp')])
self.assertEqual(exported.getAssetPaths(), [])
self.assertEqual(exported.getProblems(), [])
def test_upgrade_image(self):
"""Test upgrade of an image, regular without any link
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<image alignment="image-left" title="" width="600" image_title="Chocobo" rewritten_path="http://localhost/root/chocobo" target="_self" height="177" path="/root/chocobo" link_to_hires="0" link="" />
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
images = document_dom.getElementsByTagName('image')
self.assertEqual(len(images), 1)
image = images[0]
self.assertTrue(image.hasAttribute('reference'))
self.assertFalse(image.hasAttribute('path'))
self.assertFalse(image.hasAttribute('rewritten_path'))
self.assertFalse(image.hasAttribute('target'))
self.assertFalse(image.hasAttribute('link'))
self.assertFalse(image.hasAttribute('link_to_hires'))
self.assertFalse(image.hasAttribute('silva_title'))
self.assertTrue(image.hasAttribute('title'))
self.assertEqual(image.getAttribute('title'), 'Chocobo')
reference_name = image.getAttribute('reference')
reference_service = component.getUtility(IReferenceService)
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.chocobo)
def test_document_image(self):
"""Try to export a document that use an image.
"""
with Transaction():
document = self.root.folder.document
version = document.get_editable()
version.content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc><p>Torvald last picture</p>
<image reference="torvald-pic" alignment="" title="Torvald"></image>
</doc>""")
# Create a image to use in the document
factory = self.root.folder.manage_addProduct['Silva']
with self.layer.open_fixture('chocobo.jpg') as image:
factory.manage_addImage('torvald', 'Torvald', image)
service = component.getUtility(IReferenceService)
reference = service.new_reference(version, name="document link")
reference.set_target(self.root.folder.torvald)
reference.add_tag("torvald-pic")
exported = self.assertExportEqual(self.root.folder,
'test_export_image.silvaxml')
self.assertEqual(exported.getZexpPaths(), [])
self.assertEqual(exported.getAssetPaths(),
[(('', 'root', 'folder', 'torvald'), '1')])
self.assertEqual(exported.getProblems(), [])
def test_upgrade_unicode_html(self):
"""Upgrade a document that contains some text.
"""
document = self.root.document
document.get_editable().content = ParsedXML(
'document', u"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<heading type="normal">Histoire d'un élève suisse</heading>
<p type="normal">Il était une fois, un élève qui était allé à l'école étudier.</p>
<p type="normal">Étant content, il étudiat.</p>
</doc>
""".encode('utf-8'))
# Upgrade the document
self.assertEqual(document_upgrader.validate(document), True)
self.assertNotEqual(document_upgrader.upgrade(document), document)
upgraded = self.root.document
self.assertTrue(IDocument.providedBy(upgraded))
self.assertNotEqual(upgraded.get_editable(), None)
version = upgraded.get_editable()
self.assertEqual(version.get_title(), 'Information')
self.assertXMLEqual(
str(version.body), """
<h2>Histoire d'un élève suisse</h2>
<p>Il était une fois, un élève qui était allé à l'école étudier.</p>
<p>Étant content, il étudiat.</p>
""")
def test_upgrade_simple_html(self):
"""Upgrade a document that contains some text.
"""
document = self.root.document
document.get_editable().content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">This is a simple piece of text with two paragraph.</p>
<p type="lead">This is the second paragraph.</p>
</doc>
""")
# Upgrade the document
self.assertEqual(document_upgrader.validate(document), True)
self.assertNotEqual(document_upgrader.upgrade(document), document)
upgraded = self.root.document
self.assertTrue(IDocument.providedBy(upgraded))
self.assertNotEqual(upgraded.get_editable(), None)
version = upgraded.get_editable()
self.assertEqual(version.get_title(), 'Information')
self.assertXMLEqual(
str(version.body), """
<p>This is a simple piece of text with two paragraph.</p>
<p class="lead">This is the second paragraph.</p>
""")
def test_upgrade_link_spaces(self):
"""Test upgrade of a simple link with spaces in the path.
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url=" ./publication">Publication link</link>
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertTrue(link.hasAttribute('reference'))
self.assertFalse(link.hasAttribute('url'))
self.assertFalse(link.hasAttribute('anchor'))
reference_name = link.getAttribute('reference')
reference_service = component.getUtility(IReferenceService)
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.publication)
def test_upgrade_html_with_image_path(self):
"""Try to upgrade an image with an URL inside an HTML piece.
"""
document = self.root.document
version = document.get_editable()
version.content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<image alignment="float-left" path="http://infrae.com/image.gif" />
</doc>
""")
# Upgrade the document
self.assertEqual(document_upgrader.validate(document), True)
self.assertNotEqual(document_upgrader.upgrade(document), document)
upgraded = self.root.document
self.assertTrue(IDocument.providedBy(upgraded))
self.assertNotEqual(upgraded.get_editable(), None)
version = upgraded.get_editable()
self.assertEqual(version.get_title(), 'Information')
self.assertXMLEqual(
str(version.body), """
<div class="image float-left">
<img alt="" src="http://infrae.com/image.gif" />
</div>
""")
def __call__(self, id, file):
try:
from Products.ParsedXML.ParsedXML import ParsedXML
except:
return
ob = ParsedXML(id=id,
XMLstring=file.read(),
namespaces=1,
contentType='text/xml')
return ob
def test_upgrade_image_link_to_hires(self):
"""Test to upgrade an image that contains a link to a hires
version of itself.
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<image alignment="image-left" title="Big Chocobo" width="600" image_title="Chocobo" rewritten_path="http://localhost/root/chocobo" target="_self" height="177" path="chocobo" link_to_hires="1" link="" />
</p>
</doc>""")
reference_service = component.getUtility(IReferenceService)
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
# The converter added a link to the hires chocobo
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertTrue(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('target'))
self.assertEqual(link.getAttribute('target'), '_self')
self.assertTrue(link.hasAttribute('title'))
self.assertEqual(link.getAttribute('title'), 'Big Chocobo')
reference_name = link.getAttribute('reference')
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.chocobo)
# The image points to the chocobo as well
images = link.childNodes
self.assertEqual(len(images), 1)
image = images[0]
self.assertEqual(image.nodeName, 'image')
self.assertTrue(image.hasAttribute('reference'))
self.assertFalse(image.hasAttribute('path'))
self.assertFalse(image.hasAttribute('rewritten_path'))
self.assertFalse(image.hasAttribute('target'))
self.assertFalse(image.hasAttribute('link'))
self.assertFalse(image.hasAttribute('link_to_hires'))
self.assertFalse(image.hasAttribute('silva_title'))
self.assertTrue(image.hasAttribute('title'))
self.assertEqual(image.getAttribute('title'), 'Chocobo')
reference_name = image.getAttribute('reference')
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.chocobo)
# There is only one image in the document
images = document_dom.getElementsByTagName('image')
self.assertEqual(len(images), 1)
self.assertEqual(image, images[0])
def test_upgrade_image_broken_link(self):
"""Test to upgrade an missing image that contains a link to a
different content in Silva.
"""
document = self.root.document
editable = self.root.document.get_editable()
editable.content = ParsedXML(
'content',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<image alignment="image-left" title="Pub" width="600" image_title="Nothing" rewritten_path="http://localhost/root/nothing" target="_blank" height="177" path="nothing" link_to_hires="0" link="../publication" />
</p>
</doc>""")
reference_service = component.getUtility(IReferenceService)
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
# The converter added a link to the publication
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertTrue(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('target'))
self.assertEqual(link.getAttribute('target'), '_blank')
self.assertTrue(link.hasAttribute('title'))
self.assertEqual(link.getAttribute('title'), 'Pub')
reference_name = link.getAttribute('reference')
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.publication)
# The image keeps its old path settings
images = link.childNodes
self.assertEqual(len(images), 1)
image = images[0]
self.assertEqual(image.nodeName, 'image')
self.assertFalse(image.hasAttribute('reference'))
self.assertTrue(image.hasAttribute('path'))
self.assertEqual(image.getAttribute('path'), 'nothing')
self.assertTrue(image.hasAttribute('rewritten_path'))
self.assertEqual(
image.getAttribute('rewritten_path'),
'http://localhost/root/nothing')
self.assertFalse(image.hasAttribute('target'))
self.assertFalse(image.hasAttribute('link'))
self.assertFalse(image.hasAttribute('link_to_hires'))
self.assertFalse(image.hasAttribute('silva_title'))
self.assertTrue(image.hasAttribute('title'))
self.assertEqual(image.getAttribute('title'), 'Nothing')
# There is only one image in the document
images = document_dom.getElementsByTagName('image')
self.assertEqual(len(images), 1)
self.assertEqual(image, images[0])
def test_upgrade_image_link_broken(self):
"""Test to upgrade an image that contains a link to a
different missing content in Silva. This would be the same for
link with external URLs.
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<image alignment="image-left" title="Pub" width="600" image_title="Chocobo" rewritten_path="http://localhost/root/chocobo" target="_blank" height="177" path="chocobo" link_to_hires="0" link="foo_bar" />
</p>
</doc>""")
reference_service = component.getUtility(IReferenceService)
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
# The converter added a link to the foo_bar URL.
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertFalse(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('url'))
self.assertEqual(link.getAttribute('url'), 'foo_bar')
self.assertTrue(link.hasAttribute('target'))
self.assertEqual(link.getAttribute('target'), '_blank')
self.assertTrue(link.hasAttribute('title'))
self.assertEqual(link.getAttribute('title'), 'Pub')
# The image points to the chocobo
images = link.childNodes
self.assertEqual(len(images), 1)
image = images[0]
self.assertEqual(image.nodeName, 'image')
self.assertTrue(image.hasAttribute('reference'))
self.assertFalse(image.hasAttribute('path'))
self.assertFalse(image.hasAttribute('rewritten_path'))
self.assertFalse(image.hasAttribute('target'))
self.assertFalse(image.hasAttribute('link'))
self.assertFalse(image.hasAttribute('link_to_hires'))
self.assertFalse(image.hasAttribute('silva_title'))
self.assertTrue(image.hasAttribute('title'))
self.assertEqual(image.getAttribute('title'), 'Chocobo')
reference_name = image.getAttribute('reference')
reference = reference_service.get_reference(
editable, name=reference_name)
self.assertEqual(reference.target, self.root.chocobo)
# There is only one image in the document
images = document_dom.getElementsByTagName('image')
self.assertEqual(len(images), 1)
self.assertEqual(image, images[0])
def test_document(self):
with Transaction():
document = self.root.folder.document
version = document.get_editable()
version.content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<node foo="bar">承諾広告＊既に、２億、３億、５億９千万円収入者が続出<node2>boo</node2>baz</node>
</doc>""")
exported = self.assertExportEqual(self.root.folder,
'test_export_document.silvaxml')
self.assertEqual(exported.getZexpPaths(), [])
self.assertEqual(exported.getAssetPaths(), [])
self.assertEqual(exported.getProblems(), [])
def test_upgrade_html_with_link_reference(self):
"""Try to upgrade a link inside an HTML piece.
"""
document = self.root.document
version = document.get_editable()
version.content = ParsedXML(
'document', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p>
This is a link with a Silva reference to the
<link target="_blank" reference="infrae-site" title="">Infrae site</link>.
</p>
</doc>
""")
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addLink('link',
'Link to Infrae',
relative=False,
url='http://infrae.com')
service = getUtility(IReferenceService)
reference = service.new_reference(version, name=u"document link")
reference.set_target(self.root.folder.link)
reference.add_tag(u"infrae-site")
# Upgrade the document
self.assertEqual(document_upgrader.validate(document), True)
self.assertNotEqual(document_upgrader.upgrade(document), document)
upgraded = self.root.document
self.assertTrue(IDocument.providedBy(upgraded))
self.assertNotEqual(upgraded.get_editable(), None)
version = upgraded.get_editable()
self.assertEqual(version.get_title(), 'Information')
self.assertXMLEqual(
str(version.body), """
<p>
This is a link with a Silva reference to the
<a class="link" title="" target="_blank" reference="infrae-site">
Infrae site
</a>.
</p>
""")
reference = service.get_reference(version, 'infrae-site')
self.assertIsNot(reference.target, None)
self.assertEqual(reference.target, self.root.folder.link)
self.assertItemsEqual(list(service.get_references_from(version)),
[reference])
def test_upgrade_link_broken(self):
"""Test upgrade of a link which is an external URL
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url="./../publication/inexisting_document">Document link</link>
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertFalse(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('url'))
url = link.getAttribute('url')
self.assertEqual(url, './../publication/inexisting_document')
def test_upgrade_link_only_anchor_spaces(self):
"""Test upgrade of a link that is only to an anchor on the
same page
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url=" #on_me ">On me link</link>
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertFalse(link.hasAttribute('reference'))
self.assertFalse(link.hasAttribute('url'))
self.assertTrue(link.hasAttribute('anchor'))
self.assertEqual(link.getAttribute('anchor'), 'on_me')
def test_upgrade_link_invalid(self):
"""Test upgrade of a simple link with a completely invalid
URL as a link.
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content', u"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url="Aléatoire">On me link</link>
</p>
</doc>""".encode('utf-8'))
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertTrue(link.hasAttribute('url'))
self.assertEqual(link.getAttribute('url'), u'Aléatoire')
self.assertFalse(link.hasAttribute('anchor'))
self.assertFalse(link.hasAttribute('reference'))
def test_upgrade_link_too_high(self):
"""Test upgrade of a link that have an invalid relative path
to something not possible (like too many ..).
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url="./../../../MANAGE">ME HACKER</link>
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertFalse(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('url'))
self.assertEquals(link.getAttribute('url'), './../../../MANAGE')
self.assertFalse(link.hasAttribute('anchor'))
def test_upgrade_link_not_silva_object(self):
"""Test upgrade of a link that does not point to a Silva
object, like for instance to the edit interface.
"""
document = self.root.document
editable = document.get_editable()
editable.content = ParsedXML(
'content', """<?xml version="1.0" encoding="utf-8"?>
<doc>
<p type="normal">
<link target="_blank" url="./edit">SMI</link>
</p>
</doc>""")
self.assertEqual(document_upgrader.upgrade(document), document)
document_dom = editable.content.documentElement
links = document_dom.getElementsByTagName('link')
self.assertEqual(len(links), 1)
link = links[0]
self.assertFalse(link.hasAttribute('reference'))
self.assertTrue(link.hasAttribute('url'))
self.assertEquals(link.getAttribute('url'), './edit')
self.assertFalse(link.hasAttribute('anchor'))
def test_upgrade_html_with_image_reference(self):
"""Try to upgrade an image with a reference inside an HTML
piece.
"""
document = self.root.document
version = document.get_editable()
version.content = ParsedXML(
'document',
"""<?xml version="1.0" encoding="utf-8"?>
<doc>
<image alignment="align-center" reference="chocobo-master" />
</doc>
""")
# Create the refered image
factory = self.root.manage_addProduct['Silva']
with self.layer.open_fixture('chocobo.jpg') as image:
factory.manage_addImage('chocobo', 'Chocobo', image)
service = getUtility(IReferenceService)
reference = service.new_reference(version, name="document image")
reference.set_target(self.root.chocobo)
reference.add_tag("chocobo-master")
# Upgrade the document
self.assertEqual(document_upgrader.validate(document), True)
self.assertNotEqual(document_upgrader.upgrade(document), document)
upgraded = self.root.document
self.assertTrue(IDocument.providedBy(upgraded))
self.assertNotEqual(upgraded.get_editable(), None)
version = upgraded.get_editable()
self.assertEqual(version.get_title(), 'Information')
self.assertXMLEqual(
str(version.body),
"""
<div class="image align-center">
<img alt="Chocobo" reference="chocobo-master" />
</div>
""")
class DocumentVersion(Version):
"""Silva Document version.
"""
meta_type = "Obsolete Document Version"
grok.implements(IDocumentVersion)
security = ClassSecurityInfo()
manage_options = (
{'label':'Edit', 'action':'manage_main'},
) + Version.manage_options
def __init__(self, id):
super(DocumentVersion, self).__init__(id)
self.content = ParsedXML('content', '<doc></doc>')
# display edit screen as main management screen
security.declareProtected('View management screens', 'manage_main')
manage_main = PageTemplateFile('www/documentVersionEdit', globals())
security.declareProtected(
SilvaPermissions.AccessContentsInformation, 'fulltext')
def fulltext(self):
"""Return the content of this object without any xml for cataloging.
"""
return [
self.get_content().getId(),
self.get_title(),
remove_source_xml(self.get_document_xml(text_only=True))]
security.declareProtected(
SilvaPermissions.ChangeSilvaContent, 'get_document_xml')
def get_document_xml(self, text_only=False):
"""Generate a version of the document XML. You can restrict to
only the text XML.
"""
stream = StringIO()
if not text_only:
stream.write(
'<silva_document id="%s">' % self.get_content().getId())
# Write Title
stream.write('<title>%s</title>' % translateCdata(self.get_title()))
# Write Document
self.content.documentElement.writeStream(stream)
if not text_only:
# Write Metadata
binding = self.service_metadata.getMetadata(self)
stream.write(binding.renderXML())
# End of document
stream.write('</silva_document>')
return stream.getvalue()
security.declareProtected(
SilvaPermissions.ChangeSilvaContent, 'get_document_xml_as')
def get_document_xml_as(self, format='kupu', request=None):
"""Render the Document XML on a different format.
"""
transformer = EditorTransformer(editor=format)
context = Context(self, request)
rendered_document = transformer.to_target(
sourceobj=self.get_document_xml(), context=context)
result = unicode(rendered_document.asBytes('utf8'), 'utf8')
result = result.replace(u'\xa0', u' ')
return result
security.declareProtected(
SilvaPermissions.ChangeSilvaContent, 'set_document_xml_from')
def set_document_xml_from(self, data, format='kupu', request=None):
"""Set the document xml of the version from the given data
in the given format.
"""
transformer = EditorTransformer(editor=format)
context = Context(self, request)
document = transformer.to_source(targetobj=data, context=context)[0]
title = document.find('title')[0].extract_text()
content = document.find('doc')[0].asBytes(encoding="UTF8")
self.content.manage_edit(content)
self.set_title(title)
notify(lifecycleevent.ObjectModifiedEvent(self))
class SilvaXMLAttribute(SimpleItem):
"""An attribute that contains Silva XML"""
security = ClassSecurityInfo()
meta_type = 'Silva XML Attribute'
def __init__(self, id):
self.id = id
self._content = ParsedXML(id, '<doc></doc>')
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'get_content')
def get_content(self):
"""need a way to retrieve xml content from untrusted code"""
return self._content
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'toXML')
def toXML(self, out):
"""returns contents of this field, serialized as XML"""
out.write('<%s type="xml">' % self.id)
self._content.documentElement.writeStream(out)
out.write('</%s>' % self.id)
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'render')
def render(self):
"""return the rendered contents"""
docel = self._content.documentElement
service_editor = self.service_editor
service_editor.setViewer('service_doc_viewer')
return service_editor.renderView(docel)
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'editorHTML')
def editorHTML(self, editor='kupu', encoding=None):
"""returns the HTML for a ParsedXML field"""
s = StringIO()
contents = self.toXML(s)
return self._transformSLVToHTML(s.getvalue(), editor, encoding)
security.declareProtected(SilvaPermissions.ChangeSilvaContent,
'saveEditorHTML')
def saveEditorHTML(self, html, editor='kupu', encoding=None):
"""saves the HTML to a ParsedXML field"""
title, xml = self._transformHTMLToSLV(html, editor, encoding)
self._content.manage_edit(xml)
def clearEditorCache(self):
""" Clears editor cache for this version
"""
editor_service = self.service_editor
document_element = self._content.documentElement
editor_service.clearCache(document_element)
def isCachable(self):
"""Return true if this document is cacheable.
That means the document contains no dynamic elements like
code, datasource or toc.
"""
non_cacheable_elements = [
'toc',
'code',
]
# It should suffice to test the children of the root element only,
# since currently the only non-cacheable elements are root elements
# XXX Are we very sure it isn't possible to add code elements and tocs
# inside tables or lists?
for node in self._content.documentElement.childNodes:
node_name = node.nodeName
if node_name in non_cacheable_elements:
return False
# FIXME: how can we make this more generic as it is very
# specific now..?
if node_name == 'source':
if not externalsource.isSourceCachable(self.aq_inner, node):
return False
return True
def fulltext(self):
"""Returns the text of all text nodes as a flat string"""
return self._fulltext_helper(self._content.documentElement)
def _fulltext_helper(self, node):
ret = []
for child in node.childNodes:
if child.nodeType == child.TEXT_NODE:
ret.append(child.nodeValue)
elif child.nodeType == child.ELEMENT_NODE:
ret.append(self._fulltext_helper(child))
return ' '.join(ret)
def _transformSLVToHTML(self, string, editor='kupu', encoding=None):
"""transform Silva XML to HTML"""
transformer = EditorTransformer(editor=editor)
# we need to know what browser we are dealing with in order to know
# what html to produce, unfortunately Mozilla uses different tags in
# some cases (b instead of strong, i instead of em)
browser = 'Mozilla'
if self.REQUEST['HTTP_USER_AGENT'].find('MSIE') > -1:
browser = 'IE'
ctx = Context(f=StringIO(),
last_version=1,
url=self.aq_parent.absolute_url(),
browser=browser,
model=self.aq_parent)
ctx.f.write(string)
htmlnode = transformer.to_target(sourceobj=ctx.f.getvalue(),
context=ctx)
if encoding is not None:
ret = htmlnode.asBytes(encoding=encoding)
ret = ret.replace('\xa0', ' ')
else:
ret = unicode(htmlnode.asBytes('utf8'), 'utf8')
ret = ret.replace(u'\xa0', u' ')
return ret
def _transformHTMLToSLV(self, string, editor='kupu', encoding=None):
"""transform (messy structure-wise) HTML to Silva XML"""
transformer = EditorTransformer(editor=editor)
# we need to know what browser we are dealing with in order to know
# what html to produce, unfortunately Mozilla uses different tags in
# some cases (b instead of strong, i instead of em)
browser = 'Mozilla'
if self.REQUEST['HTTP_USER_AGENT'].find('MSIE') > -1:
browser = 'IE'
ctx = Context(url=self.aq_parent.absolute_url(),
browser=browser,
model=self.aq_parent,
request=self.REQUEST)
silvanode = transformer.to_source(targetobj=string, context=ctx)[0]
title = silvanode.find('title')[0].extract_text() # unicode
docnode = silvanode.find('doc')[0]
content = docnode.asBytes(encoding="UTF8") # UTF-8
return title, content
def __init__(self, id):
self.id = id
self._content = ParsedXML(id, '<doc></doc>')
def __init__(self, id):
super(DocumentVersion, self).__init__(id)
self.content = ParsedXML('content', '<doc></doc>')
class SilvaXMLAttribute(SimpleItem):
"""An attribute that contains Silva XML"""
security = ClassSecurityInfo()
meta_type = 'Silva XML Attribute'
def __init__(self, id):
self.id = id
self._content = ParsedXML(id, '<doc></doc>')
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'get_content')
def get_content(self):
"""need a way to retrieve xml content from untrusted code"""
return self._content
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'toXML')
def toXML(self, out):
"""returns contents of this field, serialized as XML"""
out.write('<%s type="xml">' % self.id)
self._content.documentElement.writeStream(out)
out.write('</%s>' % self.id)
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'render')
def render(self):
"""return the rendered contents"""
docel = self._content.documentElement
service_editor = self.service_editor
service_editor.setViewer('service_doc_viewer')
return service_editor.renderView(docel)
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'editorHTML')
def editorHTML(self, editor='kupu', encoding=None):
"""returns the HTML for a ParsedXML field"""
s = StringIO()
contents = self.toXML(s)
return self._transformSLVToHTML(s.getvalue(), editor, encoding)
security.declareProtected(SilvaPermissions.ChangeSilvaContent,
'saveEditorHTML')
def saveEditorHTML(self, html, editor='kupu', encoding=None):
"""saves the HTML to a ParsedXML field"""
title, xml = self._transformHTMLToSLV(html, editor, encoding)
self._content.manage_edit(xml)
def clearEditorCache(self):
""" Clears editor cache for this version
"""
editor_service = self.service_editor
document_element = self._content.documentElement
editor_service.clearCache(document_element)
def isCachable(self):
"""Return true if this document is cacheable.
That means the document contains no dynamic elements like
code, datasource or toc.
"""
non_cacheable_elements = ['toc', 'code',]
# It should suffice to test the children of the root element only,
# since currently the only non-cacheable elements are root elements
# XXX Are we very sure it isn't possible to add code elements and tocs
# inside tables or lists?
for node in self._content.documentElement.childNodes:
node_name = node.nodeName
if node_name in non_cacheable_elements:
return False
# FIXME: how can we make this more generic as it is very
# specific now..?
if node_name == 'source':
if not externalsource.isSourceCachable(self.aq_inner,
node):
return False
return True
def fulltext(self):
"""Returns the text of all text nodes as a flat string"""
return self._fulltext_helper(self._content.documentElement)
def _fulltext_helper(self, node):
ret = []
for child in node.childNodes:
if child.nodeType == child.TEXT_NODE:
ret.append(child.nodeValue)
elif child.nodeType == child.ELEMENT_NODE:
ret.append(self._fulltext_helper(child))
return ' '.join(ret)
def _transformSLVToHTML(self, string, editor='kupu', encoding=None):
"""transform Silva XML to HTML"""
transformer = EditorTransformer(editor=editor)
# we need to know what browser we are dealing with in order to know
# what html to produce, unfortunately Mozilla uses different tags in
# some cases (b instead of strong, i instead of em)
browser = 'Mozilla'
if self.REQUEST['HTTP_USER_AGENT'].find('MSIE') > -1:
browser = 'IE'
ctx = Context(f=StringIO(),
last_version=1,
url=self.aq_parent.absolute_url(),
browser=browser,
model=self.aq_parent)
ctx.f.write(string)
htmlnode = transformer.to_target(sourceobj=ctx.f.getvalue(),
context=ctx)
if encoding is not None:
ret = htmlnode.asBytes(encoding=encoding)
ret = ret.replace('\xa0', ' ')
else:
ret = unicode(htmlnode.asBytes('utf8'),'utf8')
ret = ret.replace(u'\xa0', u' ')
return ret
def _transformHTMLToSLV(self, string, editor='kupu', encoding=None):
"""transform (messy structure-wise) HTML to Silva XML"""
transformer = EditorTransformer(editor=editor)
# we need to know what browser we are dealing with in order to know
# what html to produce, unfortunately Mozilla uses different tags in
# some cases (b instead of strong, i instead of em)
browser = 'Mozilla'
if self.REQUEST['HTTP_USER_AGENT'].find('MSIE') > -1:
browser = 'IE'
ctx = Context(url=self.aq_parent.absolute_url(),
browser=browser,
model=self.aq_parent,
request=self.REQUEST)
silvanode = transformer.to_source(targetobj=string, context=ctx)[0]
title = silvanode.find('title')[0].extract_text() # unicode
docnode = silvanode.find('doc')[0]
content = docnode.asBytes(encoding="UTF8") # UTF-8
return title, content
def __init__(self, id):
self.id = id
self._content = ParsedXML(id, '<doc></doc>')
