def getEditFolderPage(
user,
folder,
parent,
files,
is_empty,
errors=None,
title="",
description="",
messages=None,
admin_context="",
gallery_context="",
):
editfolder = Template(name="templates.editfolder")
editfolder.user = user
if folder:
editfolder.folder = folder.replace("\\", "/")
editfolder.folder_name = path.basename(folder)
else:
editfolder.folder = ""
editfolder.folder_name = ""
editfolder.files = files
editfolder.parent = parent
editfolder.errors = errors
editfolder.messages = messages
editfolder.is_empty = is_empty
editfolder.description = description
editfolder.title = title
editfolder.admin_context = admin_context
editfolder.gallery_context = gallery_context
return editfolder.serialize(output="html")
def index(req):
try:
url_list = _get_url_list()
page = Template(name='downloadform')
page.url_list = url_list
except:
return "Unexpected error: " + str(sys.exc_info()[1])
return page.serialize(output='html')
def demoResponse(school_name, rooms, status=''):
template = Template(encoding="utf-8",
format='xhtml',
file='web-form.kid',
rooms=rooms,
school_name=school_name,
status=status,
current_room=current_room)
return template.serialize(output="xhtml")
def getUploadPage(user, tree, errors=None, messages=None, admin_context="", gallery_context=""):
upload = Template(name="templates.upload")
upload.user = user
upload.root_node = tree
upload.errors = errors
upload.messages = messages
upload.admin_context = admin_context
upload.gallery_context = gallery_context
return upload.serialize(output="html")
def buildMessage(self, notice_type, channel, outages, anomalies, replyto_address, from_address):
"""
Construct an alert message for the given list of outages and anomalies, to be sent to the given channel.
General process is to construct fragments for each item to be reported on, then assemble them all
together into the final message. Need to take into consideration whether we're building text email,
HTML email, short text email or SMS message, which is determined by the channel.
"""
customer = channel.contact.customer
brand = customer.brand
brand_name = "Panopta"
if brand and brand.isWhiteLabel():
brand_name = brand.name
shorttext_body = u""
text_body = u""
html_body = u""
# Make a list of server names to notify, for use in the subject header
items = outages + anomalies
server_names = set()
for o in outages:
try:
target = o.outage_target
except:
continue
server_names.add(target.name)
for a in anomalies:
server_names.add(a.server.name)
server_names = list(server_names)
server_names.sort()
# Construct the message body
if channel.contact_type.textkey in ('sms', 'email.shorttext'):
# Figure out the limit on the message length - shorter for SMS to avoid truncation
length_limit = 148
if channel.contact_type.textkey == 'email.shorttext': length_limit = 350
# Build up a list of all of the things to notify about
fragments = []
for o in outages:
notice_time = o.start_time
if notice_type == ALL_CLEAR:
notice_time = o.end_time
fragments.append(_("%(server_name)s %(notice_type)s at %(start_time)s: %(service_list)s") % \
{'server_name': o.outage_target.name,
'notice_type': _(notice_type),
'start_time': channel.contact.formatLocalTime(notice_time, hide_same_day=1),
'service_list': o.getServiceDisplayNames(join_str=',')})
for a in anomalies:
notice_time = a.start_time
notice_desc = a.server_resource_threshold.getAnomalyDescription(short=1)
if notice_type == ALL_CLEAR:
notice_time = a.end_time
notice_desc = a.server_resource_threshold.getAllClearDescription(short=1)
fragments.append(_("%(server_name)s %(notice_type)s at %(start_time)s") % {'server_name': a.server.name,
'notice_type': notice_desc,
'start_time': channel.contact.formatLocalTime(notice_time, hide_same_day=1)})
# Complete the message by including as many fragments as possible while staying under
# the length limit.
shorttext_body = fragments.pop(0)
while fragments and (len(shorttext_body) + len(fragments[0]) + 2 < length_limit):
shorttext_body += "; %s" % fragments.pop(0)
if fragments:
shorttext_body += _(" + %(count)s more") % {'count': len(fragments)}
else:
# Build a list of formatted things to report
fragments = []
for o in outages:
fragments.append(self.buildOutageFragment(notice_type, o, customer, channel))
for a in anomalies:
fragments.append(self.buildAnomalyFragment(notice_type, a, customer, channel))
# Get the template fragments, in case the customer has customized them
header = customer.getTemplateFragment('email.header')
if notice_type == OUTAGE:
intro = customer.getTemplateFragment('email.outage.notice.intro')
conclusion = customer.getTemplateFragment('email.outage.notice.conclusion')
elif notice_type == ALL_CLEAR:
intro = customer.getTemplateFragment('email.outage.allclear.intro')
conclusion = customer.getTemplateFragment('email.outage.allclear.conclusion')
copyright = customer.getTemplateFragment('email.copyright')
# Build the text rendering of the list, as we can't easily do this with interpolation
alert_list = ""
for (head, sub_list) in fragments:
alert_list += " o %s\n" % head
for line in sub_list:
alert_list += " - %s\n" % line
alert_list += "\n"
# Build the text body
if header: text_body += header.body_text + "\n\n"
if intro: text_body += intro.body_text + "\n\n"
template = _(unicode(outage_text_template))
if notice_type == ALL_CLEAR: template = _(unicode(allclear_text_template))
text_body += template % {'alerts': alert_list,
'brand_name': brand_name}
if conclusion: text_body += conclusion.body_text + "\n\n"
if copyright: text_body += copyright.body_text
if channel.contact_type.textkey == 'email.html':
# Build the HTML body
template_data = {'alerts': fragments,
'brand_name': brand_name,
'source': unicode(_(outage_html_template)) }
if notice_type == ALL_CLEAR: template_data['source'] = unicode(_(allclear_html_template))
if header: html_body += unicode(header.body_html) + u"\n\n"
if intro: html_body += unicode(intro.body_html) + u"\n\n"
# tmpl = MarkupTemplate(unicode(_(outage_html_template)))
# stream = tmpl.generate(alerts=fragments, brand_name=brand_name)
# frag = stream.render('xhtml')
# frag = apply(kid.Template, [], template_data).serialize(encoding='utf-8')
from kid import Template
t=Template(unicode(_(outage_html_template)),
brand_name = brand_name,
alerts = fragments)
frag = unicode(t.serialize(output='xhtml', encoding='utf-8'), 'utf8')
html_body += frag
if conclusion: html_body += conclusion.body_html + "\n\n"
if copyright: html_body += copyright.body_html
# Build the list of extra headers to embed in the message
extra_headers = []
if brand and brand.isWhiteLabel():
extra_headers.append(('X-Panopta-PartnerKey', customer.partner_key))
extra_headers.append(('X-Panopta-Package', customer.package.textkey))
extra_headers.append(('X-Panopta-OutageStatus', notice_type==ALL_CLEAR and 'all-clear' or 'outage'))
extra_headers.append(('X-Panopta-OutageId', replyto_address.split('@')[0])) # Grab the email hash from the replyto address
for server_name in server_names:
logging.critical("Adding server name %s" % server_name)
extra_headers.append(('X-Panopta-ServerFQDN', server_name))
# Build the subject header
subject = "%s %s: %s" % (brand_name, _(notice_type), server_names.pop(0))
while server_names and len(subject) < 80:
subject += "; %s" % server_names.pop(0)
if server_names:
subject += _(" + %(count)s more") % {'count': len(server_names)}
# Build the message object
if channel.contact_type.textkey == 'sms':
# If we're sending an SMS, just return the body - there's nothing else to be done
return shorttext_body
elif channel.contact_type.textkey == 'email.shorttext':
msg = buildEmail(from_address, channel.email_address, subject, shorttext_body, "", replyto_address, extra_headers)
elif channel.contact_type.textkey == 'email.text':
msg = buildEmail(from_address, channel.email_address, subject, text_body, "", replyto_address, extra_headers)
else:
msg = buildEmail(from_address, channel.email_address, subject, text_body, html_body, replyto_address, extra_headers)
return msg.as_string()
def test_expand_fragments():
"""Testcase for expanding XML fragments (ticket #145)."""
template = """<div xmlns:py="http://purl.org/kid/ns#"
py:replace="stream" />"""
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#">
<div py:for="i in range(3)">
<p>Hello World #$i</p>
</div>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<div>
<p>Hello World #0</p>
</div><div>
<p>Hello World #1</p>
</div><div>
<p>Hello World #2</p>
</div>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#" py:for="i in range(3)">
<p>Hello World #$i</p>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<p>Hello World #0</p>
</div><div>
<p>Hello World #1</p>
</div><div>
<p>Hello World #2</p>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#">
<div py:strip="True">
<p>Hello World</p>
</div>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<p>Hello World</p>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#" py:strip="True">
<p>Hello World</p>
</div>""")
s = t.serialize(fragment=True).strip()
expected = """<p>Hello World</p>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True).strip()
assert s2 == s
def test_expand_fragments():
"""Testcase for expanding XML fragments (ticket #145)."""
template = """<div xmlns:py="http://purl.org/kid/ns#"
py:replace="stream" />"""
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#">
<div py:for="i in range(3)">
<p>Hello World #$i</p>
</div>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<div>
<p>Hello World #0</p>
</div><div>
<p>Hello World #1</p>
</div><div>
<p>Hello World #2</p>
</div>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#" py:for="i in range(3)">
<p>Hello World #$i</p>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<p>Hello World #0</p>
</div><div>
<p>Hello World #1</p>
</div><div>
<p>Hello World #2</p>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#">
<div py:strip="True">
<p>Hello World</p>
</div>
</div>""")
s = t.serialize(fragment=True)
expected = """<div>
<p>Hello World</p>
</div>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True)
assert s2 == s
t = Template("""\
<div xmlns:py="http://purl.org/kid/ns#" py:strip="True">
<p>Hello World</p>
</div>""")
s = t.serialize(fragment=True).strip()
expected = """<p>Hello World</p>"""
assert s == expected
stream = ElementStream(t.transform()).expand()
t2 = Template(source=template, stream=stream)
s2 = t2.serialize(fragment=True).strip()
assert s2 == s
def do_rss(self, repo_data, latest):
"""
Write the RSS feed.
@param repo_data: the dict containing repository data
@type repo_data: dict
@param latest: the list of tuples returned by get_latest_packages
@type latest: list
@rtype: void
"""
self.say('Generating rss feed...')
etb = TreeBuilder()
out = os.path.join(self.outdir, RSSFILE)
etb.start('rss', {'version': '2.0'})
etb.start('channel')
etb.start('title')
etb.data(repo_data['title'])
etb.end('title')
etb.start('link')
etb.data('%s/repoview/%s' % (self.opts.url, RSSFILE))
etb.end('link')
etb.start('description')
etb.data('Latest packages for %s' % repo_data['title'])
etb.end('description')
etb.start('lastBuildDate')
etb.data(time.strftime(ISOFORMAT))
etb.end('lastBuildDate')
etb.start('generator')
etb.data('Repoview-%s' % repo_data['my_version'])
etb.end('generator')
rss_tpt = os.path.join(self.opts.templatedir, RSSKID)
rss_kid = Template(file=rss_tpt)
rss_kid.assume_encoding = "utf-8"
rss_kid.repo_data = repo_data
rss_kid.url = self.opts.url
for row in latest:
pkg_data = self.get_package_data(row[0])
rpm = pkg_data['rpms'][0]
(epoch, version, release, arch, built) = rpm[:5]
etb.start('item')
etb.start('guid')
etb.data('%s/repoview/%s+%s:%s-%s.%s' %
(self.opts.url, pkg_data['filename'], epoch, version,
release, arch))
etb.end('guid')
etb.start('link')
etb.data('%s/repoview/%s' % (self.opts.url, pkg_data['filename']))
etb.end('link')
etb.start('pubDate')
etb.data(time.strftime(ISOFORMAT, time.gmtime(int(built))))
etb.end('pubDate')
etb.start('title')
etb.data('Update: %s-%s-%s' % (pkg_data['name'], version, release))
etb.end('title')
rss_kid.pkg_data = pkg_data
description = rss_kid.serialize()
etb.start('description')
etb.data(description.decode('utf-8'))
etb.end('description')
etb.end('item')
etb.end('channel')
etb.end('rss')
rss = etb.close()
etree = ElementTree(rss)
out = os.path.join(self.outdir, RSSFILE)
etree.write(out, 'utf-8')
self.say('done\n')
from kid import Template
class Node (object):
def __init__(self, name, children=[]):
self.children = children
self.name = name
def children(self):
return self.children
top = Node("top")
a = Node("A", [Node("a")])
b = Node("B", [Node("x"),Node("y")])
top.children = [a, b]
template = Template(name="xx")
template.tree = top
print template.serialize(output='html')
def do_rss(self, repo_data, latest):
"""
Write the RSS feed.
@param repo_data: the dict containing repository data
@type repo_data: dict
@param latest: the list of tuples returned by get_latest_packages
@type latest: list
@rtype: void
"""
self.say('Generating rss feed...')
etb = TreeBuilder()
out = os.path.join(self.outdir, RSSFILE)
etb.start('rss', {'version': '2.0'})
etb.start('channel')
etb.start('title')
etb.data(repo_data['title'])
etb.end('title')
etb.start('link')
etb.data('%s/repoview/%s' % (self.opts.url, RSSFILE))
etb.end('link')
etb.start('description')
etb.data('Latest packages for %s' % repo_data['title'])
etb.end('description')
etb.start('lastBuildDate')
etb.data(time.strftime(ISOFORMAT))
etb.end('lastBuildDate')
etb.start('generator')
etb.data('Repoview-%s' % repo_data['my_version'])
etb.end('generator')
rss_tpt = os.path.join(self.opts.templatedir, RSSKID)
rss_kid = Template(file=rss_tpt)
rss_kid.assume_encoding = "utf-8"
rss_kid.repo_data = repo_data
rss_kid.url = self.opts.url
for row in latest:
pkg_data = self.get_package_data(row[0])
rpm = pkg_data['rpms'][0]
(epoch, version, release, arch, built) = rpm[:5]
etb.start('item')
etb.start('guid')
etb.data('%s/repoview/%s+%s:%s-%s.%s' % (self.opts.url,
pkg_data['filename'],
epoch, version, release,
arch))
etb.end('guid')
etb.start('link')
etb.data('%s/repoview/%s' % (self.opts.url, pkg_data['filename']))
etb.end('link')
etb.start('pubDate')
etb.data(time.strftime(ISOFORMAT, time.gmtime(int(built))))
etb.end('pubDate')
etb.start('title')
etb.data('Update: %s-%s-%s' % (pkg_data['name'], version, release))
etb.end('title')
rss_kid.pkg_data = pkg_data
description = rss_kid.serialize()
etb.start('description')
etb.data(description.decode('utf-8'))
etb.end('description')
etb.end('item')
etb.end('channel')
etb.end('rss')
rss = etb.close()
etree = ElementTree(rss)
out = os.path.join(self.outdir, RSSFILE)
etree.write(out, 'utf-8')
self.say('done\n')
def render_500(message="None"):
set_header()
template = Template(file='views/500.xml', message=message)
print template.serialize()
def item_render(self):
template = Template(file='views/item.xml', speech_data=self.speech)
set_header()
print template.serialize()
