| #!/usr/bin/env python |
| # -*- coding: UTF-8 -*- |
| |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| |
| r"""Project dashboard for Apache(TM) Bloodhound |
| |
| Implementing dashboard user interface. |
| """ |
| |
| __metaclass__ = type |
| |
| import copy |
| import pkg_resources |
| import re |
| from uuid import uuid4 |
| |
| from genshi.builder import tag |
| from genshi.core import Stream |
| from trac.core import Component, implements |
| from trac.config import Option, IntOption |
| from trac.mimeview.api import Context |
| from trac.util.translation import _ |
| from trac.ticket.query import QueryModule |
| from trac.ticket.report import ReportModule |
| from trac.util.compat import groupby |
| from trac.util.translation import _ |
| from trac.web.api import IRequestHandler, IRequestFilter |
| from trac.web.chrome import add_ctxtnav, add_stylesheet, Chrome, \ |
| INavigationContributor, ITemplateProvider |
| |
| from bhdashboard.api import DashboardSystem, InvalidIdentifier |
| from bhdashboard import _json |
| from multiproduct.env import ProductEnvironment |
| |
| |
| class DashboardModule(Component): |
| """Web frontend for dashboard infrastructure. |
| """ |
| implements(IRequestHandler, IRequestFilter, INavigationContributor, |
| ITemplateProvider) |
| |
| mainnav_label = Option('mainnav', 'tickets.label', 'Tickets', |
| """Dashboard label in mainnav""") |
| default_widget_height = IntOption('widgets', 'default_height', 320, |
| """Default widget height in pixels""") |
| |
| # IRequestFilter methods |
| |
| def pre_process_request(self, req, handler): |
| """Always returns the request handler unchanged. |
| """ |
| return handler |
| |
| def post_process_request(self, req, template, data, content_type): |
| """Inject dashboard helpers in data. |
| """ |
| if data is not None: |
| data['bhdb'] = DashboardChrome(self.env) |
| if isinstance(req.perm.env, ProductEnvironment) \ |
| and not 'resourcepath_template' in data \ |
| and 'product_list' in data: |
| data['resourcepath_template'] = 'bh_path_general.html' |
| for item in req.chrome['nav'].get('mainnav', []): |
| self.log.debug('%s' % (item,)) |
| if item['name'] == 'tickets': |
| item['label'] = tag.a(_(self.mainnav_label), |
| href=req.href.dashboard()) |
| if item['active'] and \ |
| not ReportModule(self.env).match_request(req): |
| add_ctxtnav(req, _('Reports'), |
| href=req.href.report()) |
| break |
| return template, data, content_type |
| |
| # IRequestHandler methods |
| def match_request(self, req): |
| """Match dashboard prefix""" |
| return bool(re.match(r'^/dashboard(/.)?', req.path_info)) |
| |
| def process_request(self, req): |
| req.perm.require('PRODUCT_VIEW') |
| # Initially this will render static widgets. With time it will be |
| # more and more dynamic and flexible. |
| if self.env[QueryModule] is not None: |
| add_ctxtnav(req, _('Custom Query'), req.href.query()) |
| if self.env[ReportModule] is not None: |
| add_ctxtnav(req, _('Reports'), req.href.report()) |
| context = Context.from_request(req) |
| template, layout_data = self.expand_layout_data(context, |
| 'bootstrap_grid', |
| self.DASHBOARD_SCHEMA if isinstance(self.env, ProductEnvironment) |
| else self.DASHBOARD_GLOBAL_SCHEMA |
| ) |
| widgets = self.expand_widget_data(context, layout_data) |
| return template, { |
| 'context': Context.from_request(req), |
| 'layout': layout_data, |
| 'widgets': widgets, |
| 'title': _(self.mainnav_label), |
| 'default': {'height': self.default_widget_height or None} |
| }, None |
| |
| # INavigationContributor methods |
| def get_active_navigation_item(self, req): |
| """Highlight dashboard mainnav item. |
| """ |
| return 'tickets' |
| |
| def get_navigation_items(self, req): |
| """Skip silently |
| """ |
| return None |
| |
| # ITemplateProvider methods |
| def get_htdocs_dirs(self): |
| """List `htdocs` dirs for dashboard and widgets. |
| """ |
| resource_filename = pkg_resources.resource_filename |
| return [('dashboard', resource_filename('bhdashboard', 'htdocs')), |
| #('widgets', resource_filename('bhdashboard.widgets', 'htdocs')) |
| ('layouts', resource_filename('bhdashboard.layouts', 'htdocs'))] |
| |
| def get_templates_dirs(self): |
| """List `templates` folders for dashboard and widgets. |
| """ |
| resource_filename = pkg_resources.resource_filename |
| return [resource_filename('bhdashboard.layouts', 'templates'), |
| resource_filename('bhdashboard', 'templates'), |
| resource_filename('bhdashboard.widgets', 'templates')] |
| |
| # Temp vars |
| DASHBOARD_SCHEMA = { |
| 'div': [ |
| { |
| '_class': 'row', |
| 'div': [ |
| { |
| '_class': 'span8', |
| 'widgets': ['my tickets', 'active tickets', |
| 'products', 'versions', |
| 'milestones', 'components'] |
| }, |
| { |
| '_class': 'span4', |
| 'widgets': ['activity'] |
| } |
| ] |
| } |
| ], |
| 'widgets': { |
| 'components': { |
| 'args': [ |
| 'TicketFieldValues', |
| None, |
| {'args': { |
| 'field': 'component', |
| 'title': 'Components', |
| 'verbose': True}}] |
| }, |
| 'milestones': { |
| 'args': [ |
| 'TicketFieldValues', |
| None, |
| {'args': { |
| 'field': 'milestone', |
| 'title': 'Milestones', |
| 'verbose': True}}] |
| }, |
| 'versions': { |
| 'args': [ |
| 'TicketFieldValues', |
| None, |
| {'args' : { |
| 'field' : 'version', |
| 'title' : 'Versions', |
| 'verbose' : True}}] |
| }, |
| 'active tickets': { |
| 'args': [ |
| 'TicketQuery', |
| None, |
| {'args': { |
| 'max' : 10, |
| 'query': 'status=!closed&group=milestone' |
| '&col=id&col=summary&col=owner' |
| '&col=status&col=priority&' |
| 'order=priority', |
| 'title': 'Active Tickets'}}], |
| 'altlinks': False |
| }, |
| 'my tickets': { |
| 'args': [ |
| 'TicketQuery', |
| None, |
| {'args': { |
| 'max': 10, |
| 'query': 'status=!closed&group=milestone' |
| '&col=id&col=summary&col=owner' |
| '&col=status&col=priority&' |
| 'order=priority&' |
| 'owner=$USER', |
| 'title': 'My Tickets'} |
| }], |
| 'altlinks': False |
| }, |
| 'activity': { |
| 'args': ['Timeline', None, {'args': {}}] |
| }, |
| 'products': { |
| 'args': ['Product', None, {'args': {'max': 3, |
| 'cols': 2}}] |
| }, |
| } |
| } |
| |
| # global dashboard queries: add milestone column, group by product |
| DASHBOARD_GLOBAL_SCHEMA = copy.deepcopy(DASHBOARD_SCHEMA) |
| DASHBOARD_GLOBAL_SCHEMA['widgets']['active tickets']['args'][2]['args']['query'] = ( |
| 'status=!closed&group=product&col=id&col=summary&col=owner&col=status&' |
| 'col=priority&order=priority&col=milestone' |
| ) |
| DASHBOARD_GLOBAL_SCHEMA['widgets']['my tickets']['args'][2]['args']['query'] = ( |
| 'status=!closed&group=product&col=id&col=summary&col=owner&col=status&' |
| 'col=priority&order=priority&col=milestone&owner=$USER&' |
| ) |
| for widget in ('milestones', 'versions', 'components'): |
| DASHBOARD_GLOBAL_SCHEMA['div'][0]['div'][0]['widgets'].remove(widget) |
| |
| # Public API |
| def expand_layout_data(self, context, layout_name, schema, embed=False): |
| """Determine the template needed to render a specific layout |
| and the data needed to place the widgets at expected |
| location. |
| """ |
| layout = DashboardSystem(self.env).resolve_layout(layout_name) |
| |
| template = layout.expand_layout(layout_name, context, { |
| 'schema': schema, |
| 'embed': embed |
| })['template'] |
| return template, schema |
| |
| def _render_widget(self, wp, name, ctx, options): |
| """Render widget without failing. |
| """ |
| if wp is None: |
| data = {'msglabel': 'Warning', |
| 'msgbody': _('Unknown widget %(name)s', name=name)} |
| return 'widget_alert.html', {'title': '', 'data': data}, ctx |
| |
| try: |
| return wp.render_widget(name, ctx, options) |
| except Exception, exc: |
| log_entry = str(uuid4()) |
| exccls = exc.__class__ |
| self.log.exception( |
| "- %s - Error rendering widget %s with options %s", |
| log_entry, name, options) |
| data = { |
| 'msgtype': 'error', |
| 'msglabel': 'Error', |
| 'msgbody': _('Exception raised while rendering widget. ' |
| 'Contact your administrator for further details.'), |
| 'msgdetails': [ |
| ('Widget name', name), |
| ('Exception type', tag.code(exccls.__name__)), |
| ('Log entry ID', log_entry), |
| ], |
| } |
| return 'widget_alert.html', { |
| 'title': _('Widget error'), |
| 'data': data |
| }, ctx |
| |
| def expand_widget_data(self, context, schema): |
| """Expand raw widget data and format it for use in template |
| """ |
| # TODO: Implement dynamic dashboard specification |
| widgets_spec = schema.get('widgets', {}) |
| widgets_index = dict([wnm, wp] |
| for wp in DashboardSystem(self.env).widget_providers |
| for wnm in wp.get_widgets() |
| ) |
| self.log.debug("Bloodhound: Widget index %s" % (widgets_index,)) |
| for w in widgets_spec.itervalues(): |
| w['c'] = widgets_index.get(w['args'][0]) |
| w['args'][1] = context |
| self.log.debug("Bloodhound: Widget specs %s" % (widgets_spec,)) |
| chrome = Chrome(self.env) |
| render = chrome.render_template |
| data_strm = ((k, w, self._render_widget(w['c'], *w['args'])) |
| for k, w in widgets_spec.iteritems()) |
| return dict([k, {'title': data['title'], |
| 'content': render(wctx.req, template, data['data'], |
| fragment=True), |
| 'ctxtnav': w.get('ctxtnav', True) and |
| data.get('ctxtnav') or None, |
| 'altlinks': w.get('altlinks', True) and |
| data.get('altlinks') or None, |
| 'visible': w['c'] is not None or |
| not w.get('hide_disabled', False)} |
| ] for k, w, (template, data, wctx) in data_strm) |
| |
| def alert_disabled(self): |
| return tag.div(tag.span('Error', class_='label label-important'), |
| ' Could not load dashboard. Is ', |
| tag.code('bhdashboard.web_ui.DashboardModule'), |
| ' component disabled ?', |
| class_='alert alert-error') |
| |
| #------------------------------------------------------ |
| # Dashboard Helpers to be used in templates |
| #------------------------------------------------------ |
| |
| XMLNS_DASHBOARD_UI = 'http://issues.apache.org/bloodhound/wiki/Ui/Dashboard' |
| |
| |
| class DashboardChrome: |
| """Helper functions providing access to dashboard infrastructure |
| in Genshi templates. Useful to reuse layouts and widgets across |
| website. |
| """ |
| def __init__(self, env): |
| self.env = env |
| |
| def embed_layout(self, context, layout, **kwargs): |
| """Render layout and widgets |
| |
| :param context: Rendering context |
| :param layout: Identifier of target layout |
| :param schema: Data describing widget positioning |
| :param widgets: Widgets definition |
| """ |
| dbmod = DashboardModule(self.env) |
| schema = kwargs.get('schema', {}) |
| if isinstance(schema, basestring): |
| schema = _json.loads(schema) |
| widgets = kwargs.get('widgets') |
| if widgets is not None: |
| # TODO: Use this one once widgets markup parser will be ready |
| #widgets = parse_widgets_markup(widgets) |
| if isinstance(widgets, basestring): |
| widgets = _json.loads(widgets) |
| else: |
| widgets = {} |
| schema['widgets'] = widgets |
| template, layout_data = dbmod.expand_layout_data(context, layout, |
| schema, True) |
| widgets = dbmod.expand_widget_data(context, layout_data) |
| return Chrome(self.env).render_template( |
| context.req, template, |
| dict(context=context, layout=layout_data, widgets=widgets, title='', |
| default={'height': dbmod.default_widget_height or None}), |
| fragment=True) |
| |
| def expand_widget(self, context, widget): |
| """Render single widget |
| |
| :param context: Rendering context |
| :param widget: Widget definition |
| """ |
| dbmod = DashboardModule(self.env) |
| options = widget['args'][2] |
| argsdef = options.get('args') |
| if isinstance(argsdef, basestring): |
| options['args'] = _json.loads(argsdef) |
| elif isinstance(argsdef, Stream): |
| options['args'] = parse_args_tag(argsdef) |
| return dbmod.expand_widget_data(context, {'widgets': {0: widget}})[0] |
| |
| #------------------------------------------------------ |
| # Stream processors |
| #------------------------------------------------------ |
| |
| |
| def parse_args_tag(stream): |
| """Parse Genshi Markup for widget arguments |
| """ |
| args = {} |
| inside = False |
| argnm = '' |
| argvalue = '' |
| for kind, data, _ in stream: |
| if kind == Stream.START: |
| qname, attrs = data |
| if qname.namespace == XMLNS_DASHBOARD_UI \ |
| and qname.localname == 'arg': |
| if inside: |
| raise RuntimeError('Nested bh:arg tag') |
| else: |
| argnm = attrs.get('name') |
| argvalue = '' |
| inside = True |
| elif kind == Stream.TEXT: |
| argvalue += data |
| elif kind == Stream.END: |
| if qname.namespace == XMLNS_DASHBOARD_UI \ |
| and qname.localname == 'arg': |
| args[argnm] = argvalue |
| inside = False |
| return args |
