def test_right_macro(self):
# fixes #8016
class MyField:
__name__ = 'the field'
required = True
default = u'the value'
missing_value = None
title = ""
description = ""
# Let's add a custom editor using our own widget html:
from zope.pagetemplate.pagetemplatefile import PageTemplate
template = PageTemplate()
template.pt_edit(BODY, 'text/html')
self.skins.custom.cool_editor_wysiwyg_support = template
# The wysiwyg widget depends on the used editor.
# Let's change it to `cool_editor`.
pm = self.pm
member = pm.getAuthenticatedMember()
member.setMemberProperties({'wysiwyg_editor': 'cool_editor'})
w = WYSIWYGWidget(MyField(), self.request)
# The test is partially that this call does not give an error:
html = w()
# This is true for standard Plone as well:
self.assertIn(
'<textarea name="field.the field" rows="25" id="field.the field">'
'the value</textarea>', html)
# Only our cool editor has this:
self.assertIn('Cool Editor Box', html)
def test_right_macro(self):
# fixes #8016
class MyField:
__name__ = 'the field'
required = True
default = u'the value'
missing_value = None
title = ""
description = ""
# Let's add a custom editor using our own widget html:
from zope.pagetemplate.pagetemplatefile import PageTemplate
template = PageTemplate()
template.pt_edit(BODY, 'text/html')
site = getSite()
site.portal_skins.custom.cool_editor_wysiwyg_support = template
# The wysiwyg widget depends on the used editor.
# Let's change it to `cool_editor`.
pm = getToolByName(self.portal, 'portal_membership')
member = pm.getAuthenticatedMember()
member.setMemberProperties({'wysiwyg_editor': 'cool_editor'})
w = WYSIWYGWidget(MyField(), TestRequest())
# The test is partially that this call does not give an error:
html = w()
# This is true for standard Plone as well:
self.assertTrue(
'<textarea name="field.the field" rows="25" id="field.the field">'
'the value</textarea>' in html)
# Only our cool editor has this:
self.assertTrue('Cool Editor Box' in html)
def pt_getContext(self, args=(), options={}, **kw):
rval = PageTemplate.pt_getContext(self, args=args)
options.update(rval)
return options
def render(self, soup, headings, pub_date, mod_date):
try:
settings = getUtility(IRegistry).forInterface(ISettings)
except BaseException:
settings = None
# XXX: This seems very complicated and brittle!
persistent = queryUtility(IResourceDirectory, name="persistent")
if persistent is not None:
try:
templates = persistent[RESOURCE_PATH]
source = templates[settings.template.decode('utf-8')]
except NotFound:
try:
name = "++%s++%s" % tuple(RESOURCE_PATH.split('/')[:2])
templates = getUtility(IResourceDirectory, name=name)
source = templates[settings.template]
except NotFound:
raise InternalError(
"Template not found: %r." % settings.template
)
try:
body = source.lastModifiedTimestamp
except AttributeError:
body = str(source)
cache_key = hash((source, body))
template, cached_key = getattr(
self.context, "_v_render_template", None
) or (None, cache_key)
if template is None or cached_key != cache_key:
try:
path = source.path
except AttributeError:
template = PageTemplate()
template.pt_edit(str(source), 'text/xml')
else:
template = PageTemplateFile(path)
logger.info("compiling template %r (with class %r)" % (
settings.template, template.__class__.__name__,
))
# Always use the Zope 2 expression engine.
template.pt_getEngine = lambda: self.engine
# Pass options directly into the template namespace.
template.pt_getContext = lambda args=(), options=None, **_: options
# We need to cook the template again to make sure the
# above settings are applied (double work!)
template._cook()
# Cache template on context.
self.context._v_render_template = (template, cache_key)
namespace = dict(
context=aq_inner(self.context),
request=self.request,
macros=template.macros,
soup=soup,
headings=headings,
inline=LoadBase64(templates),
publication_date=pub_date,
modification_date=mod_date,
)
namespace.update(self.namespace)
html = template(**namespace)
soup = BeautifulSoup(html)
portal = self.context.portal_url.getPortalObject()
portal_url = portal.absolute_url()
# Write out external links.
for link in soup.findAll("a"):
self.transformLink(portal_url, link)
return unicode(soup)
def pt_getContext(self, args=(), options={}, **kw):
rval = PageTemplate.pt_getContext(self, args=args)
options.update(rval)
return options
def _zope(body):
from zope.pagetemplate.pagetemplatefile import PageTemplate
template = PageTemplate()
template.pt_edit(body, 'text/xhtml')
return template
def _chameleon(body, **kwargs):
from .zpt.template import PageTemplate
return PageTemplate(body, **kwargs)
def __call2__(self, *args, **kw):
""" URL parameters:
'language' - 'de', 'en'....used to override the language of the
document
'converter' - default to on the converters registered with
zopyx.convert2 (default: pdf-prince)
'resource' - the name of a registered resource (directory)
'resource_url' - a URL referencing a ZIPped resource archive
'template' - the name of a custom template name within the choosen
'resource'
'supplementary_css' - a CSS string injected into the template
'cover' - Url to an image to be used as cover
'cmd_options' More options for the converter
"""
# Output directory
tmpdir_prefix = os.path.join(tempfile.gettempdir(), 'produce-and-publish')
if not os.path.exists(tmpdir_prefix):
os.makedirs(tmpdir_prefix)
destdir = tempfile.mkdtemp(dir=tmpdir_prefix, prefix=self.context.getId() + '-')
# debug/logging
params = kw.copy()
params.update(self.request.form)
LOG.info('new job (%s, %s) - outdir: %s' % (args, params, destdir))
# get hold of the language (hyphenation support)
language = getLanguageForObject(self.context)
if params.get('language'):
language = params.get('language')
# call the dedicated @@asHTML on the top-level node. For a leaf document
# this will return either a HTML fragment for a single document or @@asHTML
# might be defined as an aggregator for a bunch of documents (e.g. if the
# top-level is a folderish object
html_view = self.context.restrictedTraverse('@@asXML', None)
if not html_view:
html_view = self.context.restrictedTraverse('@@asHTML', None)
if not html_view:
raise RuntimeError('Object neither provides @@asHTML or @@asXML views (%s, %s)' %
(self.context.absolute_url(1), self.context.portal_type))
html_fragment = html_view()
# arbitrary application data
data = params.get('data', None)
resource_id = self.request.get('resource', 'pp-default')
resource_url = self.request.get('resource_url')
cmdoptions = self.request.get('cmd_options', '')
#import pdb; pdb.set_trace()
cover = self.request.get('cover', '')
if cover:
cmdoptions += " --remove-first-image --cover=%s" % cover
cmdoptions += " --level1-toc=//h:h1 --level2-toc=//h:h2 --level3-toc=//h:h3"
cmdoptions += " --language=%s" % language
if resource_url:
self.copyResourceFromURL(resource_url, destdir)
else:
self.copyResourceFiles(destdir)
template_id = params.get('template', 'pdf_template.pt')
template = PageTemplate()
if not os.path.exists(os.path.join(destdir, template_id)):
raise IOError('Resource does not contain template file {}'.format(template_id))
with open(os.path.join(destdir, template_id), 'rb') as fp:
template.write(fp.read())
# Now render the complete HTML document
supplementary_css = params.get('supplementary_css', None)
html = template(self,
context=self.context,
request=self.request,
language=language,
body=html_fragment,
supplementary_css=supplementary_css,
data=data,
)
# and apply transformations
transformations = params.get('transformations', self.transformations)
html = self.transformHtml(html, destdir, transformations)
# and store it in a dedicated working directory
dest_filename = os.path.join(destdir, 'index.html')
with codecs.open(dest_filename, 'wb', encoding='utf-8') as fp:
fp.write(html)
# create a local ZIP file containing all the data for the conversion
# basically for debugging purposes only.
if ZIP_OUTPUT or 'zip_output' in params:
archivename = tempfile.mktemp(suffix='.zip')
fp = zipfile.ZipFile(archivename, "w", zipfile.ZIP_DEFLATED)
for root, dirs, files in os.walk(destdir):
for fn in files:
absfn = os.path.join(root, fn)
zfn = absfn[len(destdir)+len(os.sep):] #XXX: relative path
fp.write(absfn, zfn)
fp.close()
LOG.info('ZIP file written to %s' % archivename)
if 'no_conversion' in params:
return destdir
converter = params.get('converter', 'pdfreactor8')
# Produce & Publish server integration
registry = getUtility(IRegistry)
settings = registry.forInterface(IPPClientPloneSettings)
r = furl.furl(settings.server_url)
if settings.server_username:
r.username = settings.server_username
if settings.server_password:
r.password = settings.server_password
server_url = str(r)
from pp.client.python import pdf
#import pdb; pdb.set_trace()
#result = pdf.pdf(destdir, converter, server_url=server_url, ssl_cert_verification=True, cover=cover)
result = pdf.pdf(destdir, converter, server_url=server_url, ssl_cert_verification=True, cmd_options=cmdoptions)
if result['status'] == 'OK':
output_filename = result['output_filename']
LOG.info('Output file: %s' % output_filename)
return output_filename
else:
LOG.error('Conversion failed ({})'.format(result['output']))
raise RuntimeError(result['output'])
def _zope(body):
from zope.pagetemplate.pagetemplatefile import PageTemplate
template = PageTemplate()
template.pt_edit(body, 'text/xhtml')
return template
