def render_admin_panel(self, req, cat, page, path_info):
add_stylesheet(req, 'googlesads/googleads.css')
self.log.debug('Saving Google Ads Options')
if req.method == 'POST':
self.config.set('google.ads', 'hide_for_authenticated',
req.args.get('hide_for_authenticated') in
_TRUE_VALUES)
self.config.save()
code = req.args.get('ads_html')
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('SELECT value FROM system WHERE name=%s',
('google.ads_html',))
if cursor.fetchone():
self.log.debug('Updating Ads HTML Code')
cursor.execute('UPDATE system SET value=%s WHERE name=%s',
(code, 'google.ads_html'))
else:
self.log.debug('Inserting Ads HTML Code')
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('google.ads_html', code))
db.commit()
req.redirect(req.href.admin(cat, page))
self._update_config()
return 'google_ads_admin.html', {'ads_options': self.options}
def process_request(self, req):
from tractags.macros import TagMacros
from tractags.parseargs import parseargs
from trac.web.chrome import add_stylesheet
add_stylesheet(req, 'tags/css/tractags.css')
req.hdf['trac.href.tags'] = self.env.href.tags()
if req.path_info == '/tags':
index = self.env.config.get('tags', 'index', 'cloud')
index_kwargs = {'smallest': 10, 'biggest': 30}
_, config_kwargs = parseargs(self.env.config.get('tags', 'index.args', ''))
index_kwargs.update(config_kwargs)
index_kwargs.update(req.args)
if index == 'cloud':
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_tagcloud(req, **index_kwargs))
elif index == 'list':
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_listtagged(req, **index_kwargs))
else:
raise TracError("Invalid index style '%s'" % index)
else:
_, args = parseargs(self.env.config.get('tags', 'listing.args', ''))
args.update(req.args)
tag = req.path_info[6:]
req.hdf['tag.name'] = tag
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_listtagged(req, tag, **args))
return 'tags.cs', None
def post_process_request(self, req, template, data, content_type):
self.log.debug("TicketRefsTemplate: post_process_request, %s, %s" % (
req.path_info, template))
if req.path_info.startswith("/ticket/"):
add_stylesheet(req, "ticketref/ticket.css")
add_script(req, "ticketref/ticket.js")
return template, data, content_type
def post_process_request(self, req, template, data, content_type):
"""
Add pygments colorscheme stylesheet into request
"""
add_stylesheet(req, '/pygments/{0}.css'.format(self.pygments_theme_name))
return template, data, content_type
def filter_stream(self, req, method, filename, stream, data):
crumbs = self._get_crumbs(req.session)
if not crumbs:
return stream
add_stylesheet(req, 'breadcrumbs/css/breadcrumbs.css')
li = []
href = req.href(req.base_path)
for crumb in crumbs:
realm, resource = crumb.split('/', 1)
name = resource.replace('_', ' ')
if realm == "ticket":
name = "#" + resource
elif realm != "wiki":
name = "%s:%s" % (realm, name)
link = req.href(realm, resource)
li.append(
tag.li(
tag.a(title=name, href=link,
)(name)
)
)
insert = tag.ul(class_="nav", id="breadcrumbs")(("Breadcrumbs:"), li)
return stream | Transformer('//div[@id="metanav"]/ul').after(insert)
def post_process_request(self, req, template, data, content_type):
path = req.path_info
if path.startswith('/ticket/') or path.startswith('/wiki') \
or path.startswith('/attachment/'):
add_script(req, EMBED_PATH_FLOWPLAYER['js'])
add_stylesheet(req, EMBED_PATH_FLOWPLAYER['css'])
return template, data, content_type
def expand_macro(self, formatter, name, args):
req = formatter.req
chrome = Chrome(self.env)
report = ReportModule(self.env)
comma_splitter = re.compile(r'(?<!\\),')
kwargs = {}
for arg in comma_splitter.split(args):
arg = arg.replace(r'\,', ',')
m = re.match(r'\s*[^=]+=', arg)
if m:
kw = arg[:m.end() - 1].strip()
value = arg[m.end():]
if re.match(r'^\$[A-Z]*$', value):
value = req.args.get(value[1:])
kwargs[kw] = value if value!= None else ''
else:
if re.match(r'^\$[A-Z]*$', arg):
arg = req.args.get(arg[1:])
id = int(arg)
req.args = kwargs
req.args['page'] = '1'
template, data, content_type = report._render_view(req, id)
add_stylesheet(req, 'common/css/report.css')
fullpath = ''
if pkg_resources.resource_exists('wikireport', 'WikiReport.html'):
fullpath = pkg_resources.resource_filename('wikireport', 'WikiReport.html')
else:
filepath = os.path.dirname(os.path.abspath( __file__ ))
fullpath = os.path.join(filepath, 'WikiReport.html')
return chrome.render_template(req, fullpath, data, None, fragment=True)
def process_admin_request(self, req, cat, page, path_info):
assert req.perm.has_permission('PROJECT_CREATE')
if page != 'createproj':
raise TracError("Invalid page %s" % page)
# filter out the project-specific arguments and remove the prefix
prefix = 'createproject.'
projkeys = filter(lambda x: x.startswith(prefix), req.args.iterkeys())
args = dict((key[len(prefix):], req.args[key]) for key in projkeys)
if req.method == 'POST':
# handle form submission
(projects_root_url, _) = os.path.split(self.env.project_url)
(projects_root_path, _) = os.path.split(self.env.path)
project_url = os.path.join(projects_root_url, args['dir_name'])
path = os.path.join(projects_root_path, args['dir_name'])
args.setdefault('url', project_url)
args.setdefault('path', path)
new_env = self._do_create_proj(args)
self._add_global_settings(new_env, args)
self._delete_unwanted_files(new_env)
req.redirect(project_url)
args.setdefault('repos_type', 'svn')
# store the input arguments back in the form fields so the user
# can correct errors
for name, val in args.iteritems():
req.hdf[prefix + name] = val
add_stylesheet(req, 'createproj/css/createproj.css')
return 'createproj.cs', None
def post_process_request(self, req, template, data, content_type):
if req.path_info.startswith('/ticket/') or \
req.path_info.startswith('/newticket'):
add_script(req, 'keywordsuggest/jquery.bgiframe.min.js')
add_script(req, 'keywordsuggest/jquery.autocomplete.pack.js')
add_stylesheet(req, 'keywordsuggest/autocomplete.css')
return template, data, content_type
def expand_layout(self, name, context, options):
"""Specify bootstrap layout template
"""
req = context.req
add_stylesheet(req, 'dashboard/css/bootstrap.css')
add_stylesheet(req, 'dashboard/css/bootstrap-responsive.css')
if name == 'bootstrap_btnbar':
self._process_btnbar(req, options)
results = {
('bootstrap_grid', False) : {
'template' : 'bs_grid_full.html',
},
('bootstrap_grid', True) : {
'template' : 'bs_grid.html',
},
('bootstrap_btnbar', False) : {
'template' : 'bs_btnbar_full.html',
},
('bootstrap_btnbar', True) : {
'template' : 'bs_btnbar.html',
},
}
return results[( name , bool(options.get('embed')) )]
def render_admin_panel( self, req, cat, page, path_info):
# here comes the page content, handling, etc.
try:
logfile = self.api.get_logfile_name()
if not logfile:
self.env.log.debug('No log file configured.')
self.data['err'].append('There is no log file configured for this environment.')
except IOError:
self.env.log.debug('Got IOError - configured log file does not exist!')
self.data['err'].append('The configured log file does not exist.')
self.data = {}
self.data['err'] = []
self.data['msg'] = []
self.data['log'] = []
data = {}
# OK to process?
if logfile and req.method=="POST":
self._do_process(req, logfile)
# append the messages
data['us_message'] = self.data['msg']
data['us_error'] = self.data['err']
data['us_log'] = self.data['log']
# adding stylesheets
add_stylesheet(req, 'logviewer/css/logviewer.css')
return 'logviewer.html', data
def filter_stream(self, req, method, filename, stream, data):
filter_ = []
if req.path_info.startswith("/ticket"):
filter_.extend(self._ticket_filter(req, data))
elif req.path_info.startswith("/timeline"):
filter_.extend(self._timeline_filter(req, data))
elif req.path_info.startswith("/browser") or req.path_info.startswith("/changeset"):
filter_.extend(self._browser_filter(req, data))
elif req.path_info.startswith("/log"):
filter_.extend(self._log_filter(req, data))
elif req.path_info.startswith("/search"):
filter_.extend(self._search_filter(req, data))
elif req.path_info.startswith("/report") or req.path_info.startswith("/query"):
filter_.extend(self._report_filter(req, data))
elif req.path_info.startswith("/wiki"):
filter_.extend(self._wiki_filter(req, data))
elif req.path_info.startswith("/attachment"):
filter_.extend(self._attachment_filter(req, data))
if 'attachments' in data and data.get('attachments', {}).get('attachments'):
filter_.extend(self._page_attachments_filter(req, data))
for f in filter_:
if f is not None:
stream |= f
add_stylesheet(req, 'userpictures/userpictures.css')
return stream
def process_request(self, req):
req.perm.require(self.BILLING_PERMISSION)
messages = []
def addMessage(s):
messages.extend([s]);
if req.method == 'POST':
if req.args.has_key('setbillingtime'):
self.set_bill_date(req.authname)
addMessage("All tickets last bill date updated")
mgr = CustomReportManager(self.env, self.log)
data = {};
data["statuses"] = get_statuses(self)
data["reports"] = mgr.get_reports_by_group(CustomReportManager.TimingAndEstimationKey);
#self.log.debug("DEBUG got %s, %s" % (data["reports"], type(data["reports"])));
data["billing_info"] = {"messages": messages,
"href": req.href.Billing(),
"report_base_href": req.href.report(),
"usermanual_href": req.href.wiki(user_manual_wiki_title),
"usermanual_title": user_manual_title }
self.set_request_billing_dates(data)
add_stylesheet(req, "Billing/billingplugin.css")
add_script(req, "Billing/date.js")
add_script(req, "Billing/linkifyer.js")
return 'billing.html', data, None
def process_request(self, req):
regexp = re.compile(r'^(.+?)(\s(B\[(.*?)\])? C\[(.+?)\] D\[(.+?)\] A\[(.+?)\] E\[(.+?)\] S\[(.+?)\])?$')
p = Popen('git log --graph --date-order -C -M --all --date=iso --pretty=format:"B[%d] C[%H] D[%ad] A[%an] E[%ae] S[%s]"', stdout=PIPE, shell=True, cwd=self.env.get_repository().gitrepo, close_fds=True)
p_stdoutdata, p_stderrdata = p.communicate()
graph_raw_list = unicode(p_stdoutdata, 'utf-8', errors="ignore").split("\n")
graph_list = []
for graph_raw_line in graph_raw_list:
regexp_result = regexp.search(graph_raw_line)
if not regexp_result:
continue;
graph_list.append({
"relation":regexp_result.group(1),
"branch":regexp_result.group(4),
"rev":regexp_result.group(5),
"date":regexp_result.group(6),
"author":regexp_result.group(7),
"author_email":regexp_result.group(8),
"subject":regexp_result.group(9),
}
)
data = {'graph_list':graph_list}
add_stylesheet(req, 'gitgraph/gitgraph.css')
add_script(req, 'gitgraph/jquery.js')
add_script(req, 'gitgraph/gitgraph.js')
add_script(req, 'gitgraph/chart.js')
return 'graph.html', data, None
def process_request(self, req):
if not req.perm.has_permission('PROJECT_MANAGER'):
raise TracError('Need PROJECT_MANAGER permission')
pages, providers = self._get_pages(req)
if not pages:
raise TracError('No projmanager pages available')
cat_id = req.args.get('cat_id') or pages[0][0]
page_id = req.args.get('page_id')
path_info = req.args.get('path_info')
if not page_id:
page_id = filter(lambda page: page[0] == cat_id, pages)[0][2]
provider = providers.get((cat_id, page_id), None)
if not provider:
raise TracError('Unknown Proj Manager Page')
# Do the action
template, content_type = provider.process_projmanager_request(req, cat_id,
page_id,
path_info)
# Get the list of pages
req.hdf['projmanager.pages'] = [{'cat_id': page[0],
'cat_label': page[1],
'page_id': page[2],
'page_label': page[3],
'href': self.env.href.projmanager(page[0], page[2])
} for page in pages]
req.hdf['projmanager.active_cat'] = cat_id
req.hdf['projmanager.active_page'] = page_id
req.hdf['projmanager.page_template'] = template
add_stylesheet(req, 'projmanager/css/projmanager.css')
return 'projmanager.cs', content_type
def post_process_request(self, req, template, data, content_type):
"""Do any post-processing the request might need; typically adding
values to the template `data` dictionary, or changing template or
mime type.
`data` may be update in place.
Always returns a tuple of (template, data, content_type), even if
unchanged.
Note that `template`, `data`, `content_type` will be `None` if:
- called when processing an error page
- the default request handler did not return any result
(Since 0.11)
"""
if template == 'ticket.html':
add_stylesheet(req, '%s/css/autocomplete.css' % self.prefix)
add_script(req, '%s/js/autocomplete.js' % self.prefix)
restrict_owner = self.env.config.getbool('ticket', 'restrict_owner')
add_script(req, '%s/js/format_item.js' % self.prefix)
if req.path_info.rstrip() == '/newticket':
add_script(req, '%s/js/autocomplete_newticket_cc.js' % self.prefix)
if not restrict_owner:
add_script(req, '%s/js/autocomplete_newticket.js' % self.prefix)
else:
add_script(req, '%s/js/autocomplete_ticket_cc.js' % self.prefix)
if not restrict_owner:
add_script(req, '%s/js/autocomplete_ticket.js' % self.prefix)
return (template, data, content_type)
def _prepare_diff(self, req, page, old_text, new_text,
old_version, new_version):
diff_style, diff_options, diff_data = get_diff_options(req)
diff_context = 3
for option in diff_options:
if option.startswith('-U'):
diff_context = int(option[2:])
break
if diff_context < 0:
diff_context = None
diffs = diff_blocks(old_text, new_text, context=diff_context,
ignore_blank_lines='-B' in diff_options,
ignore_case='-i' in diff_options,
ignore_space_changes='-b' in diff_options)
def version_info(v, last=0):
return {'path': get_resource_name(self.env, page.resource),
# TRANSLATOR: wiki page
'rev': v or _('currently edited'),
'shortrev': v or last + 1,
'href': req.href.wiki(page.name, version=v) if v else None}
changes = [{'diffs': diffs, 'props': [],
'new': version_info(new_version, old_version),
'old': version_info(old_version)}]
add_stylesheet(req, 'common/css/diff.css')
add_script(req, 'common/js/diff.js')
return diff_data, changes
def post_process_request(self, req, template, content_type):
if template == 'ticket.cs' and req.perm.has_permission('TICKET_ADMIN'):
add_script(req, 'ticketdelete/jquery.js')
add_script(req, 'ticketdelete/ticketdelete.js')
add_stylesheet(req, 'ticketdelete/ticketdelete.css')
add_script(req, 'ticketchange/ticketchange.js')
return template, content_type
def post_process_request(self, req, template, data, content_type):
if data is None:
return
js_data = {
'comments_rest_url': req.href(CommentsREST.href),
'formatting_help_url': req.href.wiki('WikiFormatting'),
'delete_url': req.href(DeleteCommentForm.href),
'preview_url': req.href(WikiPreview.href),
'templates': self.templates_js_data(),
'active_comment_id': req.args.get('codecomment'),
'username': req.authname,
'is_admin': 'TRAC_ADMIN' in req.perm,
}
original_return_value = template, data, content_type
if req.path_info.startswith('/changeset/'):
js_data.update(self.changeset_js_data(req, data))
elif req.path_info.startswith('/browser'):
js_data.update(self.browser_js_data(req, data))
elif re.match(r'/attachment/ticket/\d+/.*', req.path_info):
js_data.update(self.attachment_js_data(req, data))
else:
return original_return_value
add_script(req, 'code-comments/json2.js')
add_script(req, 'code-comments/underscore-min.js')
add_script(req, 'code-comments/backbone-min.js')
# jQuery UI includes: UI Core, Interactions, Button & Dialog Widgets, Core Effects, custom theme
add_script(req, 'code-comments/jquery-ui/jquery-ui.js')
add_stylesheet(req, 'code-comments/jquery-ui/trac-theme.css')
add_script(req, 'code-comments/jquery.ba-throttle-debounce.min.js')
add_script(req, 'code-comments/code-comments.js')
add_script_data(req, {'CodeComments': js_data})
return original_return_value
def _do_login(self, req):
# check the referer
referer = req.get_header('Referer')
if referer and not (referer == req.base_url or referer.startswith(req.base_url.rstrip('/')+'/')):
# only redirect to referer if it is from the same site
referer = None
if referer:
req.session['oid.referer'] = referer
if self.default_openid:
req.args['openid_identifier'] = self.default_openid
return self._do_verify(req)
add_stylesheet(req, 'authopenid/css/openid.css')
add_script(req, 'authopenid/js/openid-jquery.js')
return 'openidlogin.html', {
'images': req.href.chrome('authopenid/images') + '/',
'action': req.href.openidverify(),
'message': 'Login using OpenID.',
'signup': self.signup_link,
'whatis': self.whatis_link,
'css_class': 'error',
'providers_regexp': self.providers_regexp,
'custom_provider_name': self.custom_provider_name,
'custom_provider_label': self.custom_provider_label,
'custom_provider_url': self.custom_provider_url,
'custom_provider_image': self.custom_provider_image,
'custom_provider_size': self.custom_provider_size,
}, None
def process_request(self, req):
from tractags.api import TagEngine
from trac.web.chrome import add_stylesheet
add_stylesheet(req, 'tags/css/tractags.css')
pagename = req.args.get('page', 'WikiStart')
action = req.args.get('action', 'view')
engine = TagEngine(self.env)
wikitags = engine.tagspace.wiki
tags = list(wikitags.get_tags([pagename]))
tags.sort()
if action == 'edit':
req.hdf['tags'] = req.args.get('tags', ', '.join(tags))
elif action == 'view':
hdf_tags = []
for tag in tags:
href, title = engine.get_tag_link(tag)
hdf_tags.append({'name': tag,
'href': href,
'title': title})
req.hdf['tags'] = hdf_tags
result = WikiModule.process_request(self, req)
if result is None:
return None
if result[0] == 'wiki.cs':
return 'tagswiki.cs', None
return result
def list_users(self, req):
"""
Handle user listing
"""
req.perm.require('USER_AUTHOR')
data = {}
userstore = get_userstore()
# State
data['states'] = userstore.USER_STATUS_LABELS
# Available backend organizations
# TODO: Add support for listing users based on organization in user REST API
orgman = self.env[OrganizationManager]
data['organizations'] = [org for org in orgman.get_organizations() if org['type'] == 'backend']
# Add jquery ui for autocomplete
add_script(req, 'multiproject/js/jquery-ui.js')
add_script(req, 'multiproject/js/transparency.js')
add_script(req, 'multiproject/js/multiproject.js')
add_script(req, 'multiproject/js/admin_user_list.js')
add_stylesheet(req, 'multiproject/css/jquery-ui.css')
return 'admin_user_list.html', data
def render_admin_panel(self, req, cat, page, path_info):
if req.method == 'POST':
self.config.set('theme', 'theme', req.args['theme'].lower())
self.config.save()
req.redirect(req.href.admin(cat, page))
data = {
'themeengine': {
'info': self.system.info.items(),
},
}
theme_name = self.system.theme and self.system.theme['name'] or 'default'
theme_name = theme_name.islower() and theme_name.title() or theme_name
data['themeengine']['current'] = theme_name
index = 0
curtheme = None
for i, (k, v) in enumerate(data['themeengine']['info']):
if k.lower() == theme_name.lower():
index = i
curtheme = v
break
data['themeengine']['current_index'] = index
data['themeengine']['current_theme'] = curtheme
#add_stylesheet(req, 'themeengine/jquery.jcarousel.css')
#add_stylesheet(req, 'themeengine/skins/tango/skin.css')
#add_script(req, 'themeengine/jquery.jcarousel.pack.js')
add_stylesheet(req, 'themeengine/admin.css')
add_script(req, 'themeengine/jcarousellite_1.0.1.js')
return 'admin_theme.html', data
def process_request(self, req):
# Create request context.
context = Context.from_request(req)
context.realm = 'screenshots-core'
# Template data dictionary.
req.data = {}
# Get database access.
db = self.env.get_db_cnx()
context.cursor = db.cursor()
# Prepare data structure.
req.data['title'] = self.mainnav_title or self.metanav_title
req.data['has_tags'] = self.env.is_component_enabled(
'tracscreenshots.tags.ScreenshotsTags')
# Get action from request and perform them.
actions = self._get_actions(context)
self.log.debug('actions: %s' % (actions,))
template, content_type = self._do_actions(context, actions)
# Add CSS style and JavaScript scripts.
add_stylesheet(req, 'screenshots/css/screenshots.css')
add_script(req, 'screenshots/js/screenshots.js')
# Return template and its data.
db.commit()
return (template + '.html', {'screenshots' : req.data}, content_type)
def match_request(self, req): """ Never Match a request but always load the css, trac seems to do some caching, so this only happens once per session? """ add_stylesheet(req, 'shellexampleHdocs/css/shellexample.css') return False;
def expand_macro(self, formatter, name, content):
req = formatter.req
stats_provider, kwargs, is_preview_with_self = self._parse_macro_content(content, req)
if is_preview_with_self:
# previewing newticket, without a number but with a reference
# to current ticket number; show a helpful message
return tag.div('Progress meter will be inserted here in final ticket')
# Create & execute the query string
qstr = '&'.join(['%s=%s' % item
for item in kwargs.iteritems()])
query = Query.from_string(self.env, qstr, max=0)
try:
constraints = query.constraints[0]
except IndexError:
constraints = query.constraints
# Calculate stats
qres = query.execute(req)
tickets = apply_ticket_permissions(self.env, req, qres)
stats = get_ticket_stats(stats_provider, tickets)
stats_data = query_stats_data(req, stats, constraints)
# ... and finally display them
add_stylesheet(req, 'common/css/roadmap.css')
chrome = Chrome(self.env)
return chrome.render_template(req, 'progressmeter.html', stats_data,
fragment=True)
def process_admin_request(self, req, cat, page, path_info):
assert req.perm.has_permission('BLOG_ADMIN')
add_stylesheet(req, 'blog/css/blog.css')
add_stylesheet(req, 'common/css/wiki.css')
req.hdf['blogadmin.page'] = page
admin_fields = {
'date_format' : '%x %X',
'page_format' : '%Y/%m/%d/%H.%M',
'default_tag' : 'blog',
'post_size' : 1024,
'history_days' : 30,
'new_blog_link' : 'New Blog Post',
'first_week_day' : 'SUNDAY',
'mark_updated' : 'true',
'nav_link' : 'Blog',
'nav_bar' : 'true',
'macro_blacklist': '',
'rss' : 'true',
}
if req.method == 'POST':
if page == 'defaults':
for field in admin_fields.keys():
self._set_field_value(req, field)
self.env.config.save()
for field, default in admin_fields.items():
self._get_field_value(req, field, default)
req.hdf['blogadmin.docs'] = wiki_to_html(self._get_docs(page),
self.env, req)
return 'blog_admin.cs', None
def post_process_request(self, req, template, data, content_type):
"""Do any post-processing the request might need; typically adding
values to the template `data` dictionary, or changing template or
mime type.
`data` may be update in place.
Always returns a tuple of (template, data, content_type), even if
unchanged.
Note that `template`, `data`, `content_type` will be `None` if:
- called when processing an error page
- the default request handler did not return any result
(Since 0.11)
"""
if template == 'ticket.html':
add_stylesheet(req, '%s/css/autocomplete.css' % self.prefix)
add_script(req, '%s/js/autocomplete.js' % self.prefix)
if req.path_info.rstrip() == '/newticket':
add_script_data(req, {'KEYWORDS_AC_PATH': 'ac-keywords'})
else:
add_script_data(req, {'KEYWORDS_AC_PATH': '../ac-keywords'})
add_script(req, '%s/js/autocomplete_ticket_keywords.js' % self.prefix)
return (template, data, content_type)
def prepare_for_action(self, req):
add_stylesheet(req, 'pmmm/pmmm.css')
self.is_project_admin = req.perm.has_permission("PROJECT_ADMIN")
self.is_trac_admin = req.perm.has_permission("TRAC_ADMIN")
self.is_dep_admin = req.perm.has_permission("DEPARTMENT_ADMIN")
self.log.debug("User %s is_admin %d" % (req.authname,
self.is_project_admin))
def process_request(self, req):
req.perm.assert_permission('TICKET_VIEW')
action = req.args.get('action', 'view')
if not req.args.has_key('id'):
req.redirect(self.env.href.wiki())
db = self.env.get_db_cnx()
id = int(req.args.get('id'))
ticket = Ticket(self.env, id, db=db)
reporter_id = util.get_reporter_id(req)
if req.method == 'POST':
if not req.args.has_key('preview'):
self._do_save(req, db, ticket)
else:
# Use user supplied values
ticket.populate(req.args)
req.hdf['ticket.action'] = action
req.hdf['ticket.ts'] = req.args.get('ts')
req.hdf['ticket.reassign_owner'] = req.args.get('reassign_owner') \
or req.authname
req.hdf['ticket.resolve_resolution'] = req.args.get('resolve_resolution')
reporter_id = req.args.get('author')
comment = req.args.get('comment')
if comment:
req.hdf['ticket.comment'] = comment
# Wiki format a preview of comment
req.hdf['ticket.comment_preview'] = wiki_to_html(comment,
self.env,
req, db)
else:
req.hdf['ticket.reassign_owner'] = req.authname
# Store a timestamp in order to detect "mid air collisions"
req.hdf['ticket.ts'] = ticket.time_changed
self._insert_ticket_data(req, db, ticket, reporter_id)
# If the ticket is being shown in the context of a query, add
# links to help navigate in the query result set
if 'query_tickets' in req.session:
tickets = req.session['query_tickets'].split()
if str(id) in tickets:
idx = tickets.index(str(ticket.id))
if idx > 0:
add_link(req, 'first', self.env.href.ticket(tickets[0]),
'Ticket #%s' % tickets[0])
add_link(req, 'prev', self.env.href.ticket(tickets[idx - 1]),
'Ticket #%s' % tickets[idx - 1])
if idx < len(tickets) - 1:
add_link(req, 'next', self.env.href.ticket(tickets[idx + 1]),
'Ticket #%s' % tickets[idx + 1])
add_link(req, 'last', self.env.href.ticket(tickets[-1]),
'Ticket #%s' % tickets[-1])
add_link(req, 'up', req.session['query_href'])
add_stylesheet(req, 'common/css/ticket.css')
return 'ticket.cs', None
def process_request(self, req):
add_stylesheet(req, 'redports/redports.css')
add_script(req, 'redports/flot/jquery.flot.js')
add_ctxtnav(req, _('Environments'), req.href.buildgroups())
add_ctxtnav(req, _('Statistics'), req.href.buildstats())
if req.args.get('owner', None) != None:
username = req.args.get('owner', None)
elif req.authname != 'anonymous':
username = req.authname
else:
username = None
return ('buildstats.html', {
'alljobs': BuildstatsAllIterator(self.env),
'userjobs': BuildstatsUserIterator(self.env, username),
'userjobname': username,
'authname': req.authname
}, None)
def _wiki_view(self, req, stream):
add_stylesheet(req, 'tags/css/tractags.css')
tags = self._page_tags(req)
if not tags:
return stream
tag_system = TagSystem(self.env)
li = []
for tag_ in tags:
resource = Resource('tag', tag_)
anchor = render_resource_link(self.env,
Context.from_request(req, resource),
resource)
anchor = anchor(rel='tag')
li.append(tag.li(anchor, ' '))
# TRANSLATOR: Header label text for tag list at wiki page bottom.
insert = tag.ul(class_='tags')(tag.li(_("Tags"), class_='header'), li)
return stream | Transformer(
'//div[contains(@class,"wikipage")]').after(insert)
def expand_macro(self, formatter, name, content):
args, kw = parse_args(content)
args = [arg.strip() for arg in args]
stack_names = kw.get('stack', '').split('|')
if not stack_names:
raise TracError('Missing stack names')
stacks = CardStack.select_by_names(self.env, stack_names)
cards = Card.select_by_stacks(self.env, stack_names)
labels = [label for label in kw.get('label', '').split('|') if label]
labels = dict(zip(stack_names, labels + stack_names[len(labels):]))
width = int(kw.get('width', 400))
req = formatter.req
context = formatter.context
board_data = {
'form_token': req.form_token,
'api_url': formatter.href('card'),
'cards_by_id': serialized_cards_by_id(cards, self.env, context),
'stacks_by_name': serialized_stacks_by_name(stacks, stack_names),
'auto_refresh': self.auto_refresh,
'auto_refresh_interval': self.auto_refresh_interval,
}
board_data_id = '%012x' % id(board_data)
chrome = Chrome(self.env)
add_stylesheet(req, 'cards/css/cards.css')
chrome.add_jquery_ui(req)
add_script_data(req, {'cards_%s' % board_data_id: board_data})
add_script(req, 'cards/js/cards.js')
data = {
'board_data_id': board_data_id,
'stack_names': stack_names,
'labels': labels,
'width': width,
}
return chrome.render_template(req, 'cards_macro.html', data, 'text/html', True)
def filter_stream(self, req, method, filename, stream, data):
if req.path_info.startswith('/timeline'):
closure_state = [0]
cache = {}
def f(stream):
# Update the closed value
n = closure_state[0]
closure_state[0] += 1
# Extract the user information
author = data['events'][n]['author'].strip()
user_info = cache.get(author)
if user_info is not None:
author, name, email = user_info
else:
db = self.env.get_db_cnx()
user_info = self._get_info(author, db)
cache[author] = user_info
author, name, email = user_info
# Try to find a provider
for provider in self.providers:
href = provider.get_hackergotchi(req.href, author, name,
email)
if href is not None:
break
else:
href = req.href.chrome('hackergotchi', 'default.png')
# Build our element
elm = tag.img(src=href,
alt='Hackergotchi for %s' % author,
class_='hackergotchi')
# Output the combined stream
return itertools.chain(elm.generate(), stream)
stream |= Transformer(
'//div[@id="content"]/dl/dt/a/span[@class="time"]').filter(f)
add_stylesheet(req, 'hackergotchi/hackergotchi.css')
return stream
def send_error(self, exc_info, template='error.html',
content_type='text/html', status=500, env=None, data={}):
try:
if template.endswith('.html'):
if env:
from trac.web.chrome import Chrome, add_stylesheet
add_stylesheet(self, 'common/css/code.css')
metadata = {'content_type': 'text/html'}
try:
out = Chrome(env).render_template(self, template, data,
metadata)
except Exception:
# second chance rendering, in "safe" mode
data['trac_error_rendering'] = True
out = Chrome(env).render_template(self, template, data,
metadata)
else:
content_type = 'text/plain'
out = '%s\n\n%s: %s' % (data.get('title'),
data.get('type'),
data.get('message'))
except Exception: # failed to render
out = get_last_traceback()
content_type = 'text/plain'
if isinstance(out, unicode):
out = out.encode('utf-8')
self.send_response(status)
self._outheaders = []
self.send_header('Cache-Control', 'must-revalidate')
self.send_header('Expires', 'Fri, 01 Jan 1999 00:00:00 GMT')
self.send_header('Content-Type', content_type + ';charset=utf-8')
self.send_header('Content-Length', len(out))
self._send_cookie_headers()
self._write = self._start_response(self._status, self._outheaders,
exc_info)
if self.method != 'HEAD':
self.write(out)
raise RequestDone
def render_admin_panel(self, req, cat, page, path_info):
req.perm.require("TRAC_ADMIN")
arch = ProjectArchive()
projects = arch.list()
if req.method == 'POST':
archived_project_id = int(req.args.get('archived_project_id', 0))
action = req.args.get('action', 'noop')
try:
if action == 'restore':
if arch.restore(archived_project_id, self.env):
add_notice(req, _('Restored project successfully'))
elif action == 'remove':
if arch.remove(archived_project_id):
add_notice(req, _('Removed project successfully'))
elif action == 'remove_expired':
if arch.remove_expired():
add_notice(req,
_('Removed expired projects successfully'))
else:
add_warning(req, _('Unknown action'))
except Exception:
add_warning(req, _('Failed to complete the action'))
self.log.exception('Failed to {0} for project {1}'.format(
action, archived_project_id))
# After post method, redirect back to listing
return req.redirect(req.href('/admin/projects/prjarchive'))
add_script(req, 'multiproject/js/jquery-ui.js')
add_stylesheet(req, 'multiproject/css/jquery-ui.css')
add_script(req, 'multiproject/js/multiproject.js')
add_script(req, 'multiproject/js/admin_project_archive.js')
return 'multiproject_admin_project_archive.html', {
'projects': projects
}
def render_admin_panel(self, req, cat, page, path_info):
"""
Returns the admin view and handles the form actions
"""
req.perm.require('TRAC_ADMIN')
if req.method == 'POST':
if req.args.get("repos[]"):
self.delete(req.args.get("repos[]"))
url = "/admin/general/vcm"
req.redirect(req.href(url))
elif req.args.get("repo_name") and req.args.get("repo_type"):
self.add_repository(req.args.get("repo_name"),
req.args.get("repo_type"), req)
add_script(req, 'multiproject/js/admin_vcm.js')
add_stylesheet(req, 'multiproject/css/vcm.css')
vcs_types = self.get_enabled_vcs(self.env)
repos = self.get_repositories()
data = {'repositories': repos, 'repository_types': vcs_types}
return 'admin_vcm.html', data
def expand_macro(self, formatter, name, content):
'''
Wiki Macro Method which generates a Genshi Markup Stream
'''
# conf = PPConfiguration( self.env )
macroenv = PPEnv(self.env, formatter.req, content)
addExternFiles(formatter.req)
# needed because of ajax call while showing ticket details (on mouseover)
add_stylesheet(formatter.req, 'common/css/ticket.css')
if macroenv.conf.get('use_ajax_for_fetching_reports',
'enabled') == 'enabled':
# HTML block with AJAX load block
return ProjectPlanGenerator.get_ajax(macroenv, formatter.req,
content)
else:
# HTML block embedding finished rendered report block
return ProjectPlanGenerator.get_html(macroenv, formatter.req,
content)
def do_get(self, req):
# Metrics is higher in the hierarchy
from agilo.scrum.metrics import MetricsController
add_stylesheet(req, "common/css/report.css")
get_team = TeamController.GetTeamCommand(self.env, team=req.args['name'])
team = self.controller.process_command(get_team)
req.perm.assert_permission(Action.TEAM_VIEW, team.resource)
cmd = MetricsController.ListMetricsCommand(self.env, team=team.name)
metrics_by_sprint = MetricsController(self.env).process_command(cmd)
available_metrics = self._get_available_metrics(metrics_by_sprint)
data = {'team': team}
data['chart_widgets'] = self._get_charts(req, team, available_metrics)
data['metric_labels'] = [get_label(m) for m in available_metrics]
data['metric_names'] = available_metrics
data['sprints'] = self._format_sprint_and_metrics(req, metrics_by_sprint,
available_metrics, team)
return data
class TeamCityAdmin(Component):
implements(IAdminPanelProvider)
def get_admin_panels(self, req):
if req.perm.has_permission('TEAMCITY_ADMIN'):
yield ('teamcity', 'TeamCity', 'builds', 'Builds')
def render_admin_panel(self, req, category, page, path_info):
if not req.perm.has_permission('TEAMCITY_ADMIN'):
raise HTTPForbidden('You are not allowed to configure TC plugin')
if req.method == 'POST':
options, errors = self._save_options(req.args)
if not errors:
# redirect here
req.redirect(req.href(req.path_info))
else:
options, errors = get_options(self.config), []
tc = TeamCityQuery(options)
url = "%s/httpAuth/app/rest/buildTypes" % options['base_url']
# load builds from TC using REST API
try:
builds_xml = tc.xml_query(url)
except TeamCityError, e:
errors.append("Fix base config options: %s" % e)
t_data = {'options': options, 'projects': {}, 'errors': errors}
return 'teamcity_admin.html', t_data
projects = {}
for build in builds_xml.iterfind('buildType'):
pr_name = build.attrib['projectName']
pr_id = build.attrib['projectId']
if pr_id not in projects:
projects[pr_id] = {
'id': pr_id,
'name': pr_name,
'checked': False,
'builds': []
}
btype_id = build.attrib['id']
if btype_id in options.get('builds', []):
projects[pr_id]['checked'] = True
projects[pr_id]['builds'].append({
'btype_id':
btype_id,
'btype_name':
build.attrib['name'],
'btype_url':
build.attrib['webUrl'],
'checked':
btype_id in options.get('builds', [])
})
add_stylesheet(req, 'teamcity/css/admin.css')
add_javascript(req, 'teamcity/js/admin.js')
t_data = {'options': options, 'projects': projects, 'errors': errors}
return 'teamcity_admin.html', t_data
def process_request(self, req):
panel_id = req.args['panel_id']
panels = []
chosen_provider = None
for provider in self.panel_providers:
for name, label in provider.get_preference_panels(req) or []:
if name == panel_id or None:
chosen_provider = provider
panels.append((name, label))
if not chosen_provider:
self.log.warn('Unknown preference panel %r', panel_id)
raise HTTPNotFound(_('Unknown preference panel'))
template, data = chosen_provider.render_preference_panel(req, panel_id)
data.update({'active_panel': panel_id, 'panels': panels})
add_stylesheet(req, 'common/css/prefs.css')
return template, data, None
def filter_stream(self, req, method, filename, stream, formdata):
# Don't check for req.path_info == '/query'. This will cause an
# infinite loop. I think it is matching the actual QueryModule
# component then.
if filename == 'query.html':
self.log.debug("WhiteboardPlugin: rendering template")
add_script(req, 'whiteboard/js/jquery.equalheights.js')
add_script(req, 'whiteboard/js/jquery-ui.js')
add_script(req, 'whiteboard/js/whiteboard.js')
add_stylesheet(req, 'whiteboard/css/whiteboard.css')
add_ctxtnav(req, "Whiteboard", "/#whiteboard")
formdata['query_href']= req.session['query_href'] \
or req.href.query()
whiteboard_stream = Chrome(self.env).render_template(req,
'whiteboard.html', formdata, fragment=True)
return stream | Transformer('//h2[@class="report-result"]..'). \
before(whiteboard_stream.select('//form[@id="whiteboard_form"]'))
return stream
def pre_process_request(self, req, handler):
tags = req.args.get('tags')
if isinstance(handler, WikiModule):
add_stylesheet(req, 'tags/css/tractags.css')
if req.method == 'POST' and tags is not None:
page_name = req.path_info[6:] or 'WikiStart'
new_tags = set(
[t.strip() for t in tags.split(',') if t.strip()])
old_tags = TagEngine(self.env).tagspace.wiki.get_tags(
[page_name])
if old_tags != new_tags:
TagEngine(self.env).tagspace.wiki.replace_tags(
req, page_name, new_tags)
if req.args.get('text') == WikiPage(self.env,
page_name).text:
# The wiki module would think this is wasn't changed,
# so redirect around it.
req.redirect(req.href.wiki(page_name))
return handler
def process_request(self, req):
header = req.get_header('X-Requested-With')
if not header or header.lower() != 'xmlhttprequest':
# Not an XHR request from the debugger, so send a help page
add_stylesheet(req, 'common/css/code.css')
return 'developer/debug_help.html', {}, None
path = req.args['path']
token = req.args['token']
assert path is not None and token is not None
key = token + ':' + path.split(':', 1)[0]
data = self._cache.get(key)
if not data:
raise HTTPNotFound()
node = data.lookup(path)
data = {'node': node, 'drillable': self._is_drillable(req)}
output = Chrome(self.env).render_template(req, 'developer/debug_node.html',
data, fragment=True)
req.send(output.render('xhtml'), 'text/html')
def show_repositories(self, req):
if req.method == 'POST':
if req.args.get('delete') and req.args.get('id'):
repo = PortRepository(self.env, req.args.get('id'))
repo.delete()
req.redirect(req.href.admin('redports/repository'))
elif req.args.get('add'):
repo = PortRepository(self.env, req.args.get('id'))
repo.type = req.args.get('type')
repo.name = req.args.get('name')
repo.url = req.args.get('url')
repo.browseurl = req.args.get('browseurl')
repo.username = req.args.get('username')
repo.add()
req.redirect(req.href.admin('redports/repository'))
add_stylesheet(req, 'redports/redports.css')
return 'adminrepositories.html', {
'repositories': PortRepositoryIterator(self.env)
}
def render_preference_panel(self, req, panel):
styles = list(get_all_styles())
if req.method == 'POST':
style = req.args.get('style')
if style and style in styles:
req.session['pygments_style'] = style
add_notice(req, _("Your preferences have been saved."))
req.redirect(req.href.prefs(panel or None))
for style in sorted(styles):
add_stylesheet(req,
'/pygments/%s.css' % style,
title=style.title())
output = self._generate('html', self.EXAMPLE)
return 'prefs_pygments.html', {
'output': output,
'selection': req.session.get('pygments_style', self.default_style),
'styles': styles
}
def render_preference_panel(self, req, panel):
"""Process a request for a preference panel."""
notifier = self.env[GrowlNotifierSystem]
sources = notifier.get_available_sources()
if req.method == 'POST':
if 'GROWL_MODIFY' not in req.perm:
raise PermissionError("No permission to change Growl settings")
host = req.args.get('host')
if notifier.validate_host('GROWL_ADMIN' in req.perm, host):
req.session['growl.host'] = host
# send a registration request to the host
notifier.register_notifications([host])
if True:
for source in sources:
key = 'growl.source.%s' % source
if source in req.args:
req.session[key] = '1'
elif key in req.session:
del req.session[key]
req.redirect(req.href.prefs(panel or None))
data = {}
data['sources'] = []
for source in sources:
label = '%s%s' % (source[0].upper(), source[1:])
key = 'growl.source.%s' % source
enabled = req.session.has_key(key) and req.session[key]
data['sources'].append({
'name': source,
'label': label,
'enabled': enabled
})
data['host'] = req.session.has_key('growl.host') and \
req.session['growl.host']
data['settings'] = {'session': req.session}
# add custom stylesheet
add_stylesheet(req, 'growl/css/growl.css')
return 'pref_growl.html', data
def process_request(self, req):
path = req.args.get('path', '/')
rev = req.args.get('rev')
repos = self.env.get_repository(req.authname)
node = repos.get_node(path, rev)
hidden_properties = [
p.strip() for p in self.config.get('browser', 'hide_properties',
'svk:merge').split(',')
]
req.hdf['title'] = path
req.hdf['browser'] = {
'path':
path,
'revision':
rev or repos.youngest_rev,
'props':
dict([(util.escape(name), util.escape(value))
for name, value in node.get_properties().items()
if not name in hidden_properties]),
'href':
util.escape(
self.env.href.browser(path, rev=rev or repos.youngest_rev)),
'log_href':
util.escape(self.env.href.log(path))
}
path_links = get_path_links(self.env.href, path, rev)
if len(path_links) > 1:
add_link(req, 'up', path_links[-2]['href'], 'Parent directory')
req.hdf['browser.path'] = path_links
if node.isdir:
req.hdf['browser.is_dir'] = True
self._render_directory(req, repos, node, rev)
else:
self._render_file(req, repos, node, rev)
add_stylesheet(req, 'common/css/browser.css')
return 'browser.cs', None
def filter_stream(self, req, method, filename, stream, data):
if filename == "ticket.html" and 'ticket' in data:
ticket = data['ticket']
if ticket.id > 0 and self._have_schedule(ticket):
add_stylesheet(req, 'ticketrelation/css/schedule.css')
schedule = self._get_schedule_info(ticket)
stream |= Transformer('//div[@id="ticket"]').after(
tag.div(
tag.h3(
tag.a('Schedule', id='schedule_label', href='#schedule_label'),
class_='foldable'),
tag.div(tag.schedule(**{':schedule': 'schedule', ':config': 'config'}), class_='schedule_container', id='schedule_container'),
id='schedule')
)
config = {
'url': req.base_url,
'startDate': None,
'finishDate': None,
'showUnavailable': 1
}
stream |= Transformer('//body').append(tag.script("""
$(window).load(function() {
var data = %s;
var config = %s;
var app = new Vue({
el: '#schedule_container',
data: {
schedule: data,
config: config,
}
});
});
""" % (json.dumps(schedule, cls=DateTimeEncoder), json.dumps(config, cls=DateTimeEncoder))))
return stream
def post_process_request(self, req, template, data, content_type):
if (template, data) != (None, None) or \
sys.exc_info() != (None, None, None):
try:
theme = self.system.theme
except ThemeNotFound, e:
add_warning(
req, "Unknown theme %s configured. Please check "
"your trac.ini. You may need to enable "
"the theme\'s plugin." % e.theme_name)
else:
if theme and 'css' in theme:
add_stylesheet(req, 'theme/' + theme['css'])
if theme and 'template' in theme:
req.chrome['theme'] = os.path.basename(theme['template'])
if theme and 'scripts' in theme:
for script_def in theme['scripts']:
if (isinstance(script_def, tuple)
and 1 <= len(script_def) <= 4):
add_script(req, *script_def)
else:
self.log.warning('Bad script def %s for theme %s',
script_def, theme['name'])
if theme and theme.get('disable_trac_css'):
links = req.chrome.get('links')
if links and 'stylesheet' in links:
for i, link in enumerate(links['stylesheet']):
if link.get('href', '') \
.endswith('common/css/trac.css'):
del links['stylesheet'][i]
break
if theme:
req.chrome['theme_info'] = theme
# Template overrides (since 2.2.0)
overrides = self._get_template_overrides(theme)
template, modifier = overrides.get(template,
(template, None))
if modifier is not None:
modifier(req, template, data, content_type)
if self.custom_css:
add_stylesheet(req, 'site/theme.css')
def process_request(self, req):
req.perm.require(self.BILLING_PERMISSION)
messages = []
def addMessage(s):
messages.extend([s])
if req.method == 'POST':
if req.args.has_key('setbillingtime'):
self.set_bill_date(req.authname, req.args.get('newbilltime'))
addMessage("All tickets last bill date updated")
mgr = CustomReportManager(self.env, self.log)
data = {}
data["statuses"] = get_statuses(self.env)
data["reports"] = mgr.get_reports_by_group(
CustomReportManager.TimingAndEstimationKey)
# Handle pulling in report_descriptions
# Could be added to custom report stuff, but that requires
# coordinating with too many people for me to care right now
report_descriptions = {}
for h in reports.all_reports:
report_descriptions[h["title"]] = h["description"]
for key in data["reports"]:
if report_descriptions.has_key(key):
data["reports"][key]["description"] = report_descriptions[key]
#self.log.debug("DEBUG got %s, %s" % (data["reports"], type(data["reports"])));
data["billing_info"] = {
"messages": messages,
"href": req.href.billing(),
"report_base_href": req.href.report(),
"usermanual_href": req.href.wiki(user_manual_wiki_title),
"usermanual_title": user_manual_title
}
self.set_request_billing_dates(data)
add_stylesheet(req, "billing/billingplugin.css")
add_script(req, "billing/date.js")
add_script(req, "billing/linkifyer.js")
return 'billing.html', data, None
def _diff_cr(self, req):
add_stylesheet(req, 'common/css/diff.css')
cs_id = req.args.get('id')
old_version = req.args.get('old_version', 1)
version = req.args.get('version', 1)
db = self.env.get_db_cnx()
cursor = db.cursor()
try:
version_author, version_status, newtext = self._get_version_record(
cursor, cs_id, version)
oldversion_author, oldversion_status, oldtext = self._get_version_record(
cursor, cs_id, old_version)
except ValueError:
return pretty_err(req, 'Version Error')
ctime = round(time.time(), 2)
diff_style, diff_options = get_diff_options(req)
context = 3
for option in diff_options:
if option.startswith('-U'):
context = int(option[2:])
break
if context < 0:
context = None
changes = hdf_diff(oldtext.splitlines(),
newtext.splitlines(),
context=context,
ignore_blank_lines='-B' in diff_options,
ignore_case='-i' in diff_options,
ignore_space_changes='-b' in diff_options)
req.hdf['version.diff'] = changes
req.hdf['version_author'] = version_author
req.hdf['oldversion_author'] = oldversion_author
req.hdf['version_status'] = status_str[version_status]
req.hdf['oldversion_status'] = status_str[oldversion_status]
req.hdf['ctime'] = time.ctime(ctime)
req.hdf['old_version'] = old_version
req.hdf['version'] = version
req.hdf['rev'] = cs_id
req.hdf['update.href'] = self.env.href.CodeReview(cs_id, action='diff')
return 'codereviewdiff.cs', None
def process_request(self, req):
ticket = model.Ticket(self.env, req.args.get('ticket'))
data = {
'ticket': ticket,
'version': None,
'split_string_error': None,
'split_string_error_line_count': 0,
'show_split_string_error': False,
'split_string': ""
}
add_stylesheet(req, 'common/css/ticket.css')
add_stylesheet(req, 'hw/css/addMultipleChildren.css')
if req.method == 'POST':
def _create_sub_tickets(self, string):
sub_tickets = parseSubTicketString(string)
for s in sub_tickets:
t = model.Ticket(self.env)
t['status'] = 'new'
t['summary'] = s.summary
t['description'] = s.description
t['parents'] = str(ticket.id)
t['reporter'] = get_reporter_id(req)
t['estimate'] = s.estimate
t['cl_product'] = ticket['cl_product']
t['type'] = 'task'
t.insert()
split_string = req.args['addMultipleChildren']
try:
_create_sub_tickets(self, split_string)
req.redirect(req.href.ticket(ticket.id))
except SubTicketsStringError as error:
data['split_string_error'] = error.message
data['split_string_error_line_count'] = error.message.count(
'\n') + 2
data['show_split_string_error'] = True
data['split_string'] = split_string
# This tuple is for Genshi (template_name, data, content_type)
# Without data the trac layout will not appear.
return 'addMultipleChildren.html', data, None
def process_request(self, req):
from tractags.macros import TagMacros
from tractags.parseargs import parseargs
from trac.web.chrome import add_stylesheet
add_stylesheet(req, 'tags/css/tractags.css')
req.hdf['trac.href.tags'] = self.env.href.tags()
def update_from_req(args):
for k in req.args.keys():
args[str(k)] = str(req.args.get(k))
if re.match('^/tags/?$', req.path_info):
index = self.env.config.get('tags', 'index', 'cloud')
index_kwargs = {'smallest': 10, 'biggest': 30}
_, config_kwargs = parseargs(self.env.config.get('tags', 'index.args', ''))
index_kwargs.update(config_kwargs)
update_from_req(index_kwargs)
if index == 'cloud':
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_tagcloud(req, **index_kwargs))
elif index == 'list':
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_listtagged(req, **index_kwargs))
else:
raise TracError("Invalid index style '%s'" % index)
else:
expression_space = self.env.config.getbool('tags', 'expression_space', 'false')
_, args = parseargs(self.env.config.get('tags', 'listing.args', ''))
if expression_space:
req.hdf['tag.title'] = Markup('Objects matching the expression <i>%s</i>' % req.path_info[6:])
args['expression'] = req.path_info[6:]
tags = []
else:
req.hdf['tag.title'] = Markup('Objects tagged <i>%s</i>' % req.path_info[6:])
tags = re.split('[,+]', req.path_info[6:])
update_from_req(args)
req.hdf['tag.body'] = Markup(
TagMacros(self.env).render_listtagged(req, *tags, **args))
return 'tags.cs', None
def process_request(self, req):
req.perm.assert_permission('ROADMAP_VIEW')
req.hdf['title'] = 'Roadmap'
showall = req.args.get('show') == 'all'
req.hdf['roadmap.showall'] = showall
db = self.env.get_db_cnx()
milestones = [
milestone_to_hdf(self.env, db, req, m)
for m in Milestone.select(self.env, showall, db)
]
req.hdf['roadmap.milestones'] = milestones
for idx, milestone in enumerate(milestones):
milestone_name = unescape(milestone['name']) # Kludge
prefix = 'roadmap.milestones.%d.' % idx
tickets = get_tickets_for_milestone(self.env, db, milestone_name,
'owner')
req.hdf[prefix + 'stats'] = calc_ticket_stats(tickets)
for k, v in get_query_links(req, milestone_name).items():
req.hdf[prefix + 'queries.' + k] = v
milestone['tickets'] = tickets # for the iCalendar view
if req.args.get('format') == 'ics':
self.render_ics(req, db, milestones)
return
add_stylesheet(req, 'common/css/roadmap.css')
# FIXME should use the 'webcal:' scheme, probably
username = None
if req.authname and req.authname != 'anonymous':
username = req.authname
icshref = req.href.roadmap(show=req.args.get('show'),
user=username,
format='ics')
add_link(req, 'alternate', icshref, 'iCalendar', 'text/calendar',
'ics')
return 'roadmap.cs', None
def expand_macro(self, formatter, name, content):
args, kw = parse_args(content)
poll_frequency = args and args[0] or 60
count = args and args[1] or 10
if not (0 == len(args) or 2 == len(args)):
return system_message(
'Incorrect arguments: '
'Must be of the format (poll frequency, lines to display)')
add_stylesheet(formatter.req, 'irclogs/style.css')
add_script(formatter.req, 'irclogs/jquery.timer.js')
data = Chrome(self.env).populate_data(
formatter.req, {
'poll_frequency': int(poll_frequency) * 1000,
'count': count
})
return Chrome(self.env).load_template('macro_live.html') \
.generate(**data)
def render_admin_panel(self, req, cat, page, component):
"""
Render the project properties Admin page
"""
req.perm.assert_permission('TRAC_ADMIN')
#Check if DB needs upgrading
check_upgrade(self.env)
if req.method == 'POST':
if req.args.has_key('make'):
data = self._do_createproject(req)
if req.args.has_key('back'):
req.redirect(req.href.admin(cat, page))
return
else:
data = self._render_view(req)
add_stylesheet(req, 'tracprojectmanager/css/projectproperties.css')
return 'newproject.html', data
def post_process_request(self, req, template, data, content_type):
"""Do any post-processing the request might need; typically adding
values to the template `data` dictionary, or changing template or
mime type.
`data` may be update in place.
Always returns a tuple of (template, data, content_type), even if
unchanged.
Note that `template`, `data`, `content_type` will be `None` if:
- called when processing an error page
- the default request handler did not return any result
(Since Trac 0.11)
"""
if self.is_active(req):
# add_script( req, 'http://code.jquery.com/ui/1.10.3/jquery-ui.js' ) # load from CDN
add_stylesheet( req, 'http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css')
add_script( req, 'projectplan/js/ticketdatepicker.js' )
return template, data, content_type
def render_admin_panel(self, req, cat, page, path_info):
req.perm.assert_permission('TRAC_ADMIN')
add_script(req, 'ticketext/ticketext.js')
add_stylesheet(req, 'ticketext/ticketext.css')
# localization
locale = LocaleUtil().get_locale(req)
if (locale == 'ja'):
add_script(req, 'ticketext/ticketext-locale-ja.js')
page_template = 'template_admin_ja.html'
else:
page_template = 'template_admin.html'
if req.method == 'POST':
self._process_update(req)
page_param = {}
self._process_read(req, page_param)
return page_template, {'template': page_param}
def post_process_request(self, req, template, data, content_type):
add_stylesheet(req, 'jqplotchart/jqplot/jquery.jqplot.min.css')
add_stylesheet(req, 'jqplotchart/jqchart.css')
add_script(req, 'jqplotchart/jqplot/excanvas.min.js')
add_script(req, 'jqplotchart/jqplot/jquery.jqplot.min.js')
plugin_base = 'jqplotchart/jqplot/plugins/jqplot.'
add_script(req, plugin_base + 'highlighter.min.js')
add_script(req, plugin_base + 'cursor.min.js')
add_script(req, plugin_base + 'dateAxisRenderer.min.js')
add_script(req, plugin_base + 'categoryAxisRenderer.min.js')
add_script(req, plugin_base + 'pointLabels.min.js')
add_script(req, plugin_base + 'pieRenderer.min.js')
add_script(req, plugin_base + 'donutRenderer.min.js')
add_script(req, plugin_base + 'barRenderer.min.js')
add_script(req, plugin_base + 'meterGaugeRenderer.min.js')
add_script(req, 'jqplotchart/jqchart.js')
return (template, data, content_type)
