def federador(self):
log.debug('Leyendo catalog')
data_dict = {
'page': toolkit.request.params.get('page'),
'modified_since': toolkit.request.params.get('modified_since'),
}
try:
log.debug('Obteniendo datasets para el federador')
dataset_dict = toolkit.get_action('iaest_federador')({}, data_dict)
log.debug('Creando extra_vars')
c = {'c': {'pkg': dataset_dict}}
log.debug('Creando c %s', c)
toolkit.response.headers[
'Content-Type'] = 'application/rdf+xml;charset=UTF-8'
loader_render = NewTextTemplate(
"application/rdf+xml; charset=utf-8", True, 'rdf')
return render('package/federador.rdf',
extra_vars=c,
loader=loader_render)
except toolkit.ValidationError, e:
toolkit.abort(409, str(e))
def test_exec_import(self):
tmpl = NewTextTemplate(u"""{% python from datetime import timedelta %}
${timedelta(days=2)}
""")
self.assertEqual("""
2 days, 0:00:00
""", str(tmpl.generate()))
def notify(self, to, cc=None, subject=None, body=None):
"""
Provide a direct way to send an email
:param list to: Email addresses where to send email to
:param list cc: CC email addresses
:param str subject: Email subject if not set in init (or want to override it)
:param str subject: Email body if not set in init (or want to override it)
:raises: TracError if email sending fails
"""
self.to = [to] if isinstance(to, basestring) else to
self.cc = cc or []
self.subject = subject or self.subject
# If body msg is set, use it as-is
if body:
self.data = {'body':body}
self.template = NewTextTemplate('${body}')
# Load non-default template
elif self.template_name != 'notify.txt':
# Reload template so that it can be set after for the instance
self.template = Chrome(self.env).load_template(self.template_name, method='text')
# Raise possible exceptions (connection, smtp) as unified TracError
try:
return super(EmailNotifier, self).notify(None, self.subject)
except (socket.error, smtplib.SMTPException), e:
self.env.log.exception('Failed to send email to: %s' % self.to)
raise TracError(e)
def _format_subj(self, event):
is_newticket = event.category == 'created'
ticket = event.target
summary = ticket['summary']
if event.changes and 'summary' in event.changes['fields']:
change = event.changes['fields']['summary']
summary = "%s (was: %s)" % (change['new'], change['old'])
prefix = self.config.get('notification', 'smtp_subject_prefix')
if prefix == '__default__':
prefix = '[%s]' % self.env.project_name
data = {
'prefix': prefix,
'summary': summary,
'ticket': ticket,
'changes': event.changes,
'env': self.env,
}
template = self.config.get('notification', 'ticket_subject_template')
template = NewTextTemplate(template.encode('utf8'))
subj = template.generate(**data).render('text', encoding=None).strip()
if not is_newticket:
subj = "Re: " + subj
return subj
def test_exec_import(self):
tmpl = NewTextTemplate("""{% python from datetime import timedelta %}
${timedelta(days=2)}
""")
self.assertEqual("""
2 days, 0:00:00
""",
tmpl.generate().render(encoding=None))
def test_exec_with_trailing_space(self):
"""
Verify that a code block with trailing space does not cause a syntax
error (see ticket #127).
"""
NewTextTemplate(u"""
{% python
bar = 42
$}
""")
def test_exec_def(self):
tmpl = NewTextTemplate(u"""{% python
def foo():
return 42
%}
${foo()}
""")
self.assertEqual(u"""
42
""", str(tmpl.generate()))
def test_exec_def(self):
tmpl = NewTextTemplate("""{% python
def foo():
return 42
%}
${foo()}
""")
self.assertEqual("""
42
""",
tmpl.generate().render(encoding=None))
def _notify_admins(self, permission, email_path, debug='false'):
is_debug = debug.lower() in ('true', 'yes')
if permission != 'TRAC_ADMIN':
raise AdminCommandError('Only TRAC_ADMIN permission is supported')
# A standard thing to do in IAdminCommandProviders (otherwise,
# accessing project_identifier would give errors)
if not hasattr(self.env, 'project_identifier'):
MultiProjectEnvironmentInit(self.env).environment_needs_upgrade(None)
env_name = self.env.project_identifier
if env_name == self.env.config.get('multiproject', 'sys_home_project_name'):
raise AdminCommandError('Command does not support home project')
if not os.path.exists(email_path):
raise AdminCommandError(_("Email template was not found!"))
project = Project.get(self.env)
email_template = ''
try:
with open(email_path) as fd:
email_template = fd.read()
except OSError as e:
raise AdminCommandError(_("Error with opening file %(path)s: %(error_msg)s",
path=email_path, error_msg=e))
except Exception as e:
raise AdminCommandError(_("Unknown error when parsing file %(path)s: %(error_msg)s",
path=email_path, error_msg=e))
email_template = [i.strip() for i in email_template.split('\n', 1) if i]
if not len(email_template) > 1 or not all(email_template):
raise AdminCommandError(_("Email template %(path)s was invalid.", path=email_path))
subject, body = email_template
text_template = NewTextTemplate(body)
admins = project.get_admin_email_addresses()
data = {'env_name': env_name}
if is_debug:
printout('## DEBUG MODE - NOT SENDING EMAILS ##')
printout("project: {0}".format(env_name))
printout("to: {0}".format(','.join(admins)))
printout("subject: {0}".format(subject))
printout("----------------------------")
printout(text_template.generate(**data))
printout("----------------------------")
if not is_debug:
notifier = EmailNotifier(self.env, subject=subject, data=data)
notifier.template = text_template
notifier.notify(admins)
printout('Emails sent')
def format_subject(self):
template = self.config.get('fullblog-notification', 'subject_template')
template = NewTextTemplate(template.encode('utf8'))
prefix = self.config.get('notification', 'smtp_subject_prefix')
if prefix == '__default__':
prefix = '[%s]' % self.config.get('project', 'name')
action = self.action.strip('post_').replace('_', ' ')
data = {'blog': self.blog, 'prefix': prefix, 'action': action}
return template.generate(**data).render('text', encoding=None).strip()
def test_empty_lines1(self):
tmpl = NewTextTemplate("""Your items:
{% for item in items %}\
* ${item}
{% end %}""")
self.assertEqual("""Your items:
* 0
* 1
* 2
""",
tmpl.generate(items=range(3)).render())
def test_empty_lines1_with_crlf(self):
tmpl = NewTextTemplate('Your items:\r\n'
'\r\n'
'{% for item in items %}\\\r\n'
' * ${item}\r\n'
'{% end %}')
self.assertEqual(
'Your items:\r\n'
'\r\n'
' * 0\r\n'
' * 1\r\n'
' * 2\r\n',
tmpl.generate(items=range(3)).render(encoding=None))
def format_subject(self, action):
template = self.config.get('wiki-notification', 'subject_template')
template = NewTextTemplate(template.encode('utf8'))
prefix = self.config.get('notification', 'smtp_subject_prefix')
if prefix == '__default__':
prefix = '[%s]' % self.config.get('project', 'name')
data = {
'pagename': self.old_name or self.page.name,
'prefix': prefix,
'action': action,
'env': self.env,
}
return template.generate(**data).render('text', encoding=None).strip()
def format_subj(self, tickets_descr):
template = self.config.get('notification', 'batch_subject_template')
template = NewTextTemplate(template.encode('utf8'))
prefix = self.config.get('notification', 'smtp_subject_prefix')
if prefix == '__default__':
prefix = '[%s]' % self.env.project_name
data = {
'prefix': prefix,
'tickets_descr': tickets_descr,
'env': self.env,
}
subj = template.generate(**data).render('text', encoding=None).strip()
return shorten_line(subj)
def format_subj(self, summary):
template = self.config.get('notification', 'ticket_subject_template')
template = NewTextTemplate(template.encode('utf8'))
prefix = self.config.get('notification', 'smtp_subject_prefix')
if prefix == '__default__':
prefix = '[%s]' % self.env.project_name
data = {
'prefix': prefix,
'summary': summary,
'ticket': self.ticket,
'env': self.env,
}
return template.generate(**data).render('text', encoding=None).strip()
def build_clone_form(self, req, ticket, data):
fields = {}
for derivation in self.derived_fields:
template, new_field = derivation.split('->')
if new_field in self.excluded_fields:
continue
template = NewTextTemplate(
template.replace("\\n", "\n").encode('utf8'))
fields[new_field] = template.generate(ticket=ticket).render(
'text', encoding=None).strip()
for f in data.get('fields', []):
name = f['name']
if name in fields:
continue
if name not in self.excluded_fields:
fields[name] = ticket[name]
return fields
def test_unicode_input(self):
text = u'$foo\xf6$bar'
tmpl = NewTextTemplate(text)
self.assertEqual(u'x\xf6y', unicode(tmpl.generate(foo='x', bar='y')))
def test_latin1_encoded(self):
text = u'$foo\xf6$bar'.encode('iso-8859-1')
tmpl = NewTextTemplate(text, encoding='iso-8859-1')
self.assertEqual(u'x\xf6y', unicode(tmpl.generate(foo='x', bar='y')))
def test_end_with_args(self):
tmpl = NewTextTemplate("""
{% if foo %}
bar
{% end 'if foo' %}""")
self.assertEqual('\n', str(tmpl.generate(foo=False)))
def test_comment_escaping(self):
tmpl = NewTextTemplate('\\{# escaped comment #}')
self.assertEqual('{# escaped comment #}', str(tmpl.generate()))
def test_end_with_args(self):
tmpl = NewTextTemplate("""
{% if foo %}
bar
{% end 'if foo' %}""")
self.assertEqual('\n', tmpl.generate(foo=False).render(encoding=None))
def test_comment(self):
tmpl = NewTextTemplate('{# a comment #}')
self.assertEqual('', tmpl.generate().render(encoding=None))
def test_unicode_input(self):
text = u'$foo\xf6$bar'
tmpl = NewTextTemplate(text)
self.assertEqual(u'x\xf6y',
tmpl.generate(foo='x', bar='y').render(encoding=None))
def test_latin1_encoded(self):
text = '$foo\xf6$bar'.encode('iso-8859-1')
tmpl = NewTextTemplate(text, encoding='iso-8859-1')
self.assertEqual('x\xf6y',
tmpl.generate(foo='x', bar='y').render(encoding=None))
def test_escaping(self):
tmpl = NewTextTemplate('\\{% escaped %}')
self.assertEqual('{% escaped %}', str(tmpl.generate()))
("factory3.py", "%s-factory3.py" % name),
("factoryMate.py", "%s-factoryMate.py" % name),
("panel-applet.template", "org.gnome.applets.%s.panel-applet" % name),
]
for root, dirs, files in walk("templates/debian"):
for f in files:
fullpath = join(root, f)[len("templates/"):]
templates.append((fullpath, fullpath))
for (src, dest) in templates:
src = join("templates", src)
dest = join(opts.folder, dest)
destdir = dirname(dest)
if destdir != "" and not exists(destdir):
makedirs(destdir)
tmpl = NewTextTemplate(open(src).read())
stream = tmpl.generate(name=opts.name,
scriptRoot=scriptRoot,
description=opts.description,
icon=opts.icon,
category=opts.category,
lowerName=opts.name.lower(),
maintainer=opts.maintainer,
email=opts.email,
now=now)
open(dest, "wb").write(stream.render())
bits = stat(src).st_mode
chmod(dest, bits)
def test_comment(self):
tmpl = NewTextTemplate('{# a comment #}')
self.assertEqual('', str(tmpl.generate()))
def genshiText(indented_string):
t = NewTextTemplate(trim(indented_string))
return lambda **kw: t.generate(**kw).render()
def test_comment_escaping(self):
tmpl = NewTextTemplate('\\{# escaped comment #}')
self.assertEqual('{# escaped comment #}',
tmpl.generate().render(encoding=None))
