| # 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. |
| |
| import logging |
| from urllib import basejoin |
| from cStringIO import StringIO |
| |
| from tg import expose, redirect, flash |
| from tg.decorators import without_trailing_slash |
| from pylons import request, app_globals as g, tmpl_context as c |
| from paste.deploy.converters import asbool, asint |
| from bson import ObjectId |
| |
| from ming.orm import session, state |
| from ming.utils import LazyProperty |
| |
| from allura.lib import helpers as h |
| from allura.lib.security import require, has_access, require_access |
| from allura import model |
| from allura.controllers import BaseController |
| from allura.lib.decorators import require_post, event_handler |
| from allura.lib.utils import permanent_redirect |
| |
| log = logging.getLogger(__name__) |
| |
| class ConfigOption(object): |
| |
| def __init__(self, name, ming_type, default, label=None): |
| self.name, self.ming_type, self._default, self.label = ( |
| name, ming_type, default, label or name) |
| |
| @property |
| def default(self): |
| if callable(self._default): |
| return self._default() |
| return self._default |
| |
| class SitemapEntry(object): |
| |
| def __init__(self, label, url=None, children=None, className=None, |
| ui_icon=None, small=None, tool_name=None): |
| self.label = label |
| self.className = className |
| if url is not None: |
| url = url.encode('utf-8') |
| self.url = url |
| self.small = small |
| self.ui_icon = ui_icon |
| if children is None: |
| children = [] |
| self.children = children |
| self.tool_name = tool_name |
| self.matching_urls = [] |
| |
| def __getitem__(self, x): |
| """ |
| Automatically expand the list of sitemap child entries with the given items. Example: |
| SitemapEntry('HelloForge')[ |
| SitemapEntry('foo')[ |
| SitemapEntry('Pages')[pages] |
| ] |
| ] |
| |
| TODO: deprecate this; use a more clear method of building a tree |
| """ |
| if isinstance(x, (list, tuple)): |
| self.children.extend(list(x)) |
| else: |
| self.children.append(x) |
| return self |
| |
| def __repr__(self): |
| l = ['<SitemapEntry '] |
| l.append(' label=%r' % self.label) |
| l.append(' url=%r' % self.url) |
| l.append(' children=%s' % repr(self.children).replace('\n', '\n ')) |
| l.append('>') |
| return '\n'.join(l) |
| |
| def bind_app(self, app): |
| lbl = self.label |
| url = self.url |
| if callable(lbl): |
| lbl = lbl(app) |
| if url is not None: |
| url = basejoin(app.url, url) |
| return SitemapEntry(lbl, url, [ |
| ch.bind_app(app) for ch in self.children], className=self.className) |
| |
| def extend(self, sitemap): |
| child_index = dict( |
| (ch.label, ch) for ch in self.children) |
| for e in sitemap: |
| lbl = e.label |
| match = child_index.get(e.label) |
| if match and match.url == e.url: |
| match.extend(e.children) |
| else: |
| self.children.append(e) |
| child_index[lbl] = e |
| |
| def matches_url(self, request): |
| """Return true if this SitemapEntry 'matches' the url of `request`.""" |
| return self.url in request.upath_info or any([ |
| url in request.upath_info for url in self.matching_urls]) |
| |
| |
| class Application(object): |
| """ |
| The base Allura pluggable application |
| |
| After extending this, expose the app by adding an entry point in your |
| setup.py: |
| |
| [allura] |
| myapp = foo.bar.baz:MyAppClass |
| |
| :cvar str status: One of 'production', 'beta', 'alpha', or 'user'. By |
| default, only 'production' apps are installable in projects. Default |
| is 'production'. |
| :cvar bool searchable: If True, show search box in the left menu of this |
| Application. Default is True. |
| :cvar list permissions: Named permissions used by instances of this |
| Application. Default is []. |
| :cvar list sitemap: :class:`SitemapEntries <allura.app.SitemapEntry>` |
| used to create the Application's navigation in the left side bar. |
| Default is []. |
| :cvar bool installable: Default is True, Application can be installed in |
| projects. |
| :cvar bool hidden: Default is False, Application is not hidden from the |
| list of a project's installed tools. |
| :cvar str tool_description: Text description of this Application. |
| :cvar bool relaxed_mount_points: Set to True to relax the default mount point |
| naming restrictions for this Application. Default is False. See |
| :attr:`default mount point naming rules <allura.lib.helpers.re_tool_mount_point>` and |
| :attr:`relaxed mount point naming rules <allura.lib.helpers.re_relaxed_tool_mount_point>`. |
| :cvar Controller root: Serves content at |
| /<neighborhood>/<project>/<app>/. Default is None - subclasses should |
| override. |
| :cvar Controller api_root: Serves API access at |
| /rest/<neighborhood>/<project>/<app>/. Default is None - subclasses |
| should override to expose API access to the Application. |
| :ivar Controller admin: Serves admin functions at |
| /<neighborhood>/<project>/<admin>/<app>/. Default is a |
| :class:`DefaultAdminController` instance. |
| :cvar dict icons: Mapping of icon sizes to application-specific icon paths. |
| """ |
| |
| __version__ = None |
| config_options = [ |
| ConfigOption('mount_point', str, 'app'), |
| ConfigOption('mount_label', str, 'app'), |
| ConfigOption('ordinal', int, '0')] |
| status_map = ['production', 'beta', 'alpha', 'user'] |
| status = 'production' |
| script_name = None |
| root = None # root controller |
| api_root = None |
| permissions = [] |
| sitemap = [] |
| installable = True |
| searchable = False |
| DiscussionClass = model.Discussion |
| PostClass = model.Post |
| AttachmentClass = model.DiscussionAttachment |
| tool_label='Tool' |
| tool_description="This is a tool for Allura forge." |
| default_mount_label='Tool Name' |
| default_mount_point='tool' |
| relaxed_mount_points=False |
| ordinal=0 |
| hidden = False |
| icons={ |
| 24:'images/admin_24.png', |
| 32:'images/admin_32.png', |
| 48:'images/admin_48.png' |
| } |
| |
| def __init__(self, project, app_config_object): |
| self.project = project |
| self.config = app_config_object |
| self.admin = DefaultAdminController(self) |
| |
| @LazyProperty |
| def url(self): |
| return self.config.url(project=self.project) |
| |
| @property |
| def acl(self): |
| return self.config.acl |
| |
| def parent_security_context(self): |
| return self.config.parent_security_context() |
| |
| @classmethod |
| def validate_mount_point(cls, mount_point): |
| """Check if ``mount_point`` is valid for this Application. |
| |
| In general, subclasses should not override this, but rather toggle |
| the strictness of allowed mount point names by toggling |
| :attr:`Application.relaxed_mount_points`. |
| |
| :param mount_point: the mount point to validate |
| :type mount_point: str |
| :rtype: A :class:`regex Match object <_sre.SRE_Match>` if the mount |
| point is valid, else None |
| |
| """ |
| re = (h.re_relaxed_tool_mount_point if cls.relaxed_mount_points |
| else h.re_tool_mount_point) |
| return re.match(mount_point) |
| |
| @classmethod |
| def status_int(self): |
| return self.status_map.index(self.status) |
| |
| @classmethod |
| def icon_url(self, size): |
| '''Subclasses (tools) provide their own icons (preferred) or in |
| extraordinary circumstances override this routine to provide |
| the URL to an icon of the requested size specific to that tool. |
| |
| Application.icons is simply a default if no more specific icon |
| is available. |
| ''' |
| resource = self.icons.get(size) |
| if resource: |
| return g.theme_href(resource) |
| return '' |
| |
| def has_access(self, user, topic): |
| """Return True if ``user`` can send email to ``topic``. |
| Default is False. |
| |
| :param user: :class:`allura.model.User` instance |
| :param topic: str |
| :rtype: bool |
| |
| """ |
| return False |
| |
| def is_visible_to(self, user): |
| """Return True if ``user`` can view this app. |
| |
| :type user: :class:`allura.model.User` instance |
| :rtype: bool |
| |
| """ |
| return has_access(self, 'read')(user=user) |
| |
| def subscribe_admins(self): |
| for uid in g.credentials.userids_with_named_role(self.project._id, 'Admin'): |
| model.Mailbox.subscribe( |
| type='direct', |
| user_id=uid, |
| project_id=self.project._id, |
| app_config_id=self.config._id) |
| |
| def subscribe(self, user): |
| if user and user != model.User.anonymous(): |
| model.Mailbox.subscribe( |
| type='direct', |
| user_id=user._id, |
| project_id=self.project._id, |
| app_config_id=self.config._id) |
| |
| @classmethod |
| def default_options(cls): |
| """Return a ``(name, default value)`` mapping of this Application's |
| :class:`config_options <ConfigOption>`. |
| |
| :rtype: dict |
| |
| """ |
| return dict( |
| (co.name, co.default) |
| for co in cls.config_options) |
| |
| def install(self, project): |
| 'Whatever logic is required to initially set up a tool' |
| # Create the discussion object |
| discussion = self.DiscussionClass( |
| shortname=self.config.options.mount_point, |
| name='%s Discussion' % self.config.options.mount_point, |
| description='Forum for %s comments' % self.config.options.mount_point) |
| session(discussion).flush() |
| self.config.discussion_id = discussion._id |
| self.subscribe_admins() |
| |
| def uninstall(self, project=None, project_id=None): |
| 'Whatever logic is required to tear down a tool' |
| if project_id is None: project_id = project._id |
| # De-index all the artifacts belonging to this tool in one fell swoop |
| g.solr.delete(q='project_id_s:"%s" AND mount_point_s:"%s"' % ( |
| project_id, self.config.options['mount_point'])) |
| for d in model.Discussion.query.find({ |
| 'project_id':project_id, |
| 'app_config_id':self.config._id}): |
| d.delete() |
| self.config.delete() |
| session(self.config).flush() |
| |
| @property |
| def uninstallable(self): |
| """Return True if this app can be uninstalled. Controls whether the |
| 'Delete' option appears on the admin menu for this app. |
| |
| By default, an app can be uninstalled iff it can be installed, although |
| some apps may want/need to override this (e.g. an app which can |
| not be installed directly by a user, but may be uninstalled). |
| """ |
| return self.installable |
| |
| def main_menu(self): |
| '''Apps should provide their entries to be added to the main nav |
| :return: a list of :class:`SitemapEntries <allura.app.SitemapEntry>` |
| ''' |
| return self.sitemap |
| |
| def sidebar_menu(self): |
| """ |
| Apps should override this to provide their menu |
| :return: a list of :class:`SitemapEntries <allura.app.SitemapEntry>` |
| """ |
| return [] |
| |
| def sidebar_menu_js(self): |
| """ |
| Apps can override this to provide Javascript needed by the sidebar_menu. |
| :return: a string of Javascript code |
| """ |
| return "" |
| |
| def admin_menu(self, force_options=False): |
| """Return the admin menu for this Application. |
| |
| Default implementation will return a menu with up to 3 links: |
| |
| - 'Permissions', if the current user has admin access to the |
| project in which this Application is installed |
| - 'Options', if this Application has custom options, or |
| ``force_options`` is True |
| - 'Label', for editing this Application's label |
| |
| Subclasses should override this method to provide additional admin |
| menu items. |
| |
| :param force_options: always include an 'Options' link in the menu, |
| even if this Application has no custom options |
| :return: a list of :class:`SitemapEntries <allura.app.SitemapEntry>` |
| |
| """ |
| admin_url = c.project.url()+'admin/'+self.config.options.mount_point+'/' |
| links = [] |
| if self.permissions and has_access(c.project, 'admin')(): |
| links.append(SitemapEntry('Permissions', admin_url + 'permissions')) |
| if force_options or len(self.config_options) > 3: |
| links.append(SitemapEntry('Options', admin_url + 'options', className='admin_modal')) |
| links.append(SitemapEntry('Label', admin_url + 'edit_label', className='admin_modal')) |
| return links |
| |
| def handle_message(self, topic, message): |
| """Handle incoming email msgs addressed to this tool. |
| Default is a no-op. |
| |
| :param topic: portion of destination email address preceeding the '@' |
| :type topic: str |
| :param message: parsed email message |
| :type message: dict - result of |
| :func:`allura.lib.mail_util.parse_message` |
| :rtype: None |
| |
| """ |
| pass |
| |
| def handle_artifact_message(self, artifact, message): |
| # Find ancestor comment and thread |
| thd, parent_id = artifact.get_discussion_thread(message) |
| # Handle attachments |
| message_id = message['message_id'] |
| if message.get('filename'): |
| # Special case - the actual post may not have been created yet |
| log.info('Saving attachment %s', message['filename']) |
| fp = StringIO(message['payload']) |
| self.AttachmentClass.save_attachment( |
| message['filename'], fp, |
| content_type=message.get('content_type', 'application/octet-stream'), |
| discussion_id=thd.discussion_id, |
| thread_id=thd._id, |
| post_id=message_id, |
| artifact_id=message_id) |
| return |
| # Handle duplicates |
| post = self.PostClass.query.get(_id=message_id) |
| if post: |
| log.info('Existing message_id %s found - saving this as text attachment' % message_id) |
| fp = StringIO(message['payload']) |
| post.attach( |
| 'alternate', fp, |
| content_type=message.get('content_type', 'application/octet-stream'), |
| discussion_id=thd.discussion_id, |
| thread_id=thd._id, |
| post_id=message_id) |
| else: |
| text=message['payload'] or '--no text body--' |
| post = thd.post( |
| message_id=message_id, |
| parent_id=parent_id, |
| text=text, |
| subject=message['headers'].get('Subject', 'no subject')) |
| |
| class DefaultAdminController(BaseController): |
| |
| def __init__(self, app): |
| self.app = app |
| |
| @expose() |
| def index(self, **kw): |
| permanent_redirect('permissions') |
| |
| @expose('jinja:allura:templates/app_admin_permissions.html') |
| @without_trailing_slash |
| def permissions(self): |
| from ext.admin.widgets import PermissionCard |
| c.card = PermissionCard() |
| permissions = dict((p, []) for p in self.app.permissions) |
| for ace in self.app.config.acl: |
| if ace.access == model.ACE.ALLOW: |
| try: |
| permissions[ace.permission].append(ace.role_id) |
| except KeyError: |
| # old, unknown permission |
| pass |
| return dict( |
| app=self.app, |
| allow_config=has_access(c.project, 'admin')(), |
| permissions=permissions) |
| |
| @expose('jinja:allura:templates/app_admin_edit_label.html') |
| def edit_label(self): |
| return dict( |
| app=self.app, |
| allow_config=has_access(self.app, 'configure')()) |
| |
| @expose() |
| @require_post() |
| def update_label(self, mount_label): |
| require_access(self.app, 'configure') |
| self.app.config.options['mount_label'] = mount_label |
| redirect(request.referer) |
| |
| @expose('jinja:allura:templates/app_admin_options.html') |
| def options(self): |
| return dict( |
| app=self.app, |
| allow_config=has_access(self.app, 'configure')()) |
| |
| @expose() |
| @require_post() |
| def configure(self, **kw): |
| with h.push_config(c, app=self.app): |
| require_access(self.app, 'configure') |
| is_admin = self.app.config.tool_name == 'admin' |
| if kw.pop('delete', False): |
| if is_admin: |
| flash('Cannot delete the admin tool, sorry....') |
| redirect('.') |
| c.project.uninstall_app(self.app.config.options.mount_point) |
| redirect('..') |
| for opt in self.app.config_options: |
| if opt in Application.config_options: |
| continue # skip base options (mount_point, mount_label, ordinal) |
| val = kw.get(opt.name, '') |
| if opt.ming_type == bool: |
| val = asbool(val or False) |
| elif opt.ming_type == int: |
| val = asint(val or 0) |
| self.app.config.options[opt.name] = val |
| if is_admin: |
| # possibly moving admin mount point |
| redirect('/' |
| + c.project._id |
| + self.app.config.options.mount_point |
| + '/' |
| + self.app.config.options.mount_point |
| + '/') |
| else: |
| redirect(request.referer) |
| |
| @without_trailing_slash |
| @expose() |
| @h.vardec |
| @require_post() |
| def update(self, card=None, **kw): |
| old_acl = self.app.config.acl |
| self.app.config.acl = [] |
| for args in card: |
| perm = args['id'] |
| new_group_ids = args.get('new', []) |
| del_group_ids = [] |
| group_ids = args.get('value', []) |
| if isinstance(new_group_ids, basestring): |
| new_group_ids = [ new_group_ids ] |
| if isinstance(group_ids, basestring): |
| group_ids = [ group_ids ] |
| |
| for acl in old_acl: |
| if (acl['permission']==perm) and (str(acl['role_id']) not in group_ids): |
| del_group_ids.append(str(acl['role_id'])) |
| |
| if new_group_ids or del_group_ids: |
| model.AuditLog.log('updated "%s" permission: "%s" => "%s" for %s' % ( |
| perm, |
| ', '.join(map(lambda id: model.ProjectRole.query.get(_id=ObjectId(id)).name, group_ids+del_group_ids)), |
| ', '.join(map(lambda id: model.ProjectRole.query.get(_id=ObjectId(id)).name, group_ids+new_group_ids)), |
| self.app.config.options['mount_point'])) |
| |
| role_ids = map(ObjectId, group_ids + new_group_ids) |
| self.app.config.acl += [ |
| model.ACE.allow(r, perm) for r in role_ids] |
| redirect(request.referer) |
