| # -*- 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. |
| |
| import copy |
| import os |
| import shutil |
| |
| from genshi.builder import tag, Element |
| from genshi.core import escape, Markup, unescape |
| |
| from pkg_resources import resource_filename |
| from trac.attachment import Attachment |
| from trac.config import Option, PathOption |
| from trac.core import Component, TracError, implements, Interface |
| from trac.db import Table, Column, DatabaseManager, Index |
| import trac.db_default |
| from trac.env import IEnvironmentSetupParticipant, Environment |
| from trac.perm import IPermissionRequestor, PermissionCache |
| from trac.resource import IExternalResourceConnector, IResourceChangeListener,\ |
| IResourceManager, ResourceNotFound |
| from trac.ticket.api import ITicketFieldProvider, ITicketManipulator |
| from trac.util.text import to_unicode, unquote_label, unicode_unquote |
| from trac.web.chrome import ITemplateProvider, add_warning |
| from trac.web.main import FakePerm, FakeSession |
| from trac.wiki.admin import WikiAdmin |
| from trac.wiki.api import IWikiSyntaxProvider |
| from trac.wiki.parser import WikiParser |
| |
| from multiproduct.dbcursor import GLOBAL_PRODUCT |
| from multiproduct.model import Product, ProductResourceMap, ProductSetting |
| from multiproduct.util import EmbeddedLinkFormatter, IDENTIFIER, \ |
| using_mysql_backend, using_sqlite_backend |
| from multiproduct.util.translation import _, N_, add_domain |
| |
| __all__ = ['MultiProductSystem', 'PRODUCT_SYNTAX_DELIMITER'] |
| |
| DB_VERSION = 5 |
| DB_SYSTEM_KEY = 'bloodhound_multi_product_version' |
| PLUGIN_NAME = 'Bloodhound multi product' |
| |
| class ISupportMultiProductEnvironment(Interface): |
| """Extension point interface for components that are aware of multi |
| product environment and its specifics. |
| |
| Component implementing this interface is handled in a special way in the |
| following scenarios: |
| |
| * if implementing `IEnvironmentSetupParticipant` interface, the component |
| will only be invoked once per global environment creation/upgrade. It is |
| up to the component to install/update it's environment specifics (schema, |
| possibly files, etc.) for all products. In contrast, components that don't |
| implement `ISupportMultiProductEnvironment` interface will be, during |
| install/update, invoked per product environment. |
| """ |
| pass |
| |
| class MultiProductSystem(Component): |
| """Creates the database tables and template directories""" |
| |
| implements(IEnvironmentSetupParticipant, IExternalResourceConnector, |
| IPermissionRequestor, IResourceChangeListener, IResourceManager, |
| ISupportMultiProductEnvironment, ITemplateProvider, |
| ITicketFieldProvider, IWikiSyntaxProvider, ITicketManipulator) |
| |
| default_product_prefix = Option( |
| 'multiproduct', |
| 'default_product_prefix', |
| default='@', |
| doc="""Prefix used for default product when migrating single-product |
| installations to multi-product.""", doc_domain='multiproduct') |
| |
| default_product = Option('ticket', 'default_product', '', |
| """Default product for newly created tickets.""") |
| |
| product_base_url = Option('multiproduct', 'product_base_url', '', |
| """A pattern used to generate the base URL of product environments, |
| e.g. the use cases listed in bh:wiki:/Proposals/BEP-0003#url-mapping . |
| Both absolute as well as relative URLs are supported. The later |
| will be resolved with respect to the base URL of the parent global |
| environment. The pattern may contain references to $(envname)s, |
| $(prefix)s and $(name)s placeholders representing the environment name, |
| product prefix and product name respectively . If nothing is set the |
| following will be used `products/$(prefix)s` |
| |
| Note the usage of `$(...)s` instead of `%(...)s` as the later form |
| would be interpreted by the ConfigParser itself. """, |
| doc_domain='multiproduct') |
| |
| product_config_parent = PathOption('inherit', 'multiproduct', '', |
| """The path to the configuration file containing the settings shared |
| by sibling product environments. By default will inherit |
| global environment configuration. |
| """, doc_domain='multiproduct') |
| |
| SCHEMA = [mcls._get_schema() |
| for mcls in (Product, ProductResourceMap)] |
| |
| # Tables which should be migrated (extended with 'product' column) |
| MIGRATE_TABLES = ['component', |
| 'milestone', |
| 'version', |
| 'enum', |
| 'permission', |
| 'wiki', |
| 'report', |
| ] |
| |
| PRODUCT_POPULATE_TABLES = list(set(MIGRATE_TABLES) - set(['wiki'])) |
| |
| def __init__(self, *args, **kwargs): |
| import pkg_resources |
| locale_dir = pkg_resources.resource_filename(__name__, 'locale') |
| add_domain(self.env.path, locale_dir) |
| super(MultiProductSystem, self).__init__(*args, **kwargs) |
| |
| def get_version(self): |
| """Finds the current version of the bloodhound database schema""" |
| rows = self.env.db_direct_query(""" |
| SELECT value FROM system WHERE name = %s |
| """, (DB_SYSTEM_KEY,)) |
| return int(rows[0][0]) if rows else -1 |
| |
| # IEnvironmentSetupParticipant methods |
| def environment_created(self): |
| """Insertion of any default data into the database.""" |
| self.log.debug("creating environment for %s plugin." % PLUGIN_NAME) |
| |
| def environment_needs_upgrade(self, db_dummy=None): |
| """Detects if the installed db version matches the running system""" |
| db_installed_version = self.get_version() |
| |
| if db_installed_version > DB_VERSION: |
| raise TracError('''Current db version (%d) newer than supported by |
| this version of the %s (%d).''' % (db_installed_version, |
| PLUGIN_NAME, |
| DB_VERSION)) |
| needs_upgrade = db_installed_version < DB_VERSION |
| if not needs_upgrade: |
| self.env.enable_multiproduct_schema(True) |
| return needs_upgrade |
| |
| def _update_db_version(self, db, version): |
| old_version = self.get_version() |
| if old_version != -1: |
| self.log.info("Updating multiproduct database schema from version %d" |
| " to %d" % (old_version, version)) |
| db("""UPDATE system SET value=%s |
| WHERE name=%s""", (version, DB_SYSTEM_KEY)) |
| else: |
| self.log.info("Initial multiproduct database schema set to version %d" % version) |
| db(""" |
| INSERT INTO system (name, value) VALUES ('%s','%s') |
| """ % (DB_SYSTEM_KEY, version)) |
| return version |
| |
| |
| _system_wiki_list = None |
| @property |
| def system_wiki_list(self): |
| if MultiProductSystem._system_wiki_list is None: |
| MultiProductSystem._system_wiki_list = self._get_system_wiki_list() |
| return MultiProductSystem._system_wiki_list |
| |
| def _get_system_wiki_list(self): |
| """Helper function that enumerates all 'system' wikis. The |
| list is combined of default wiki pages and pages that are |
| bundled with Bloodhound dashboard and search plugins""" |
| from bhdashboard import wiki |
| |
| paths = [resource_filename('trac.wiki', |
| 'default-pages')] + \ |
| [resource_filename('bhdashboard', |
| 'default-pages')] + \ |
| [resource_filename('bhsearch', |
| 'default-pages')] |
| pages = [] |
| original_pages = [] |
| for path in paths: |
| for page in os.listdir(path): |
| filename = os.path.join(path, page) |
| page = unicode_unquote(page.encode('utf-8')) |
| if os.path.isfile(filename): |
| original_pages.append(page) |
| for original_name in original_pages: |
| if original_name.startswith('Trac'): |
| new_name = wiki.new_name(original_name) |
| if not new_name: |
| continue |
| if new_name in original_pages: |
| continue |
| name = new_name |
| # original trac wikis should also be included in the list |
| pages.append(original_name) |
| else: |
| name = original_name |
| pages.append(name) |
| return pages |
| |
| def upgrade_environment(self, db_dummy=None): |
| """Installs or updates tables to current version""" |
| self.log.debug("upgrading existing environment for %s plugin." % |
| PLUGIN_NAME) |
| db_installed_version = self.get_version() |
| with self.env.db_direct_transaction as db: |
| if db_installed_version < 1: |
| self._add_column_product_to_ticket(db) |
| self._create_multiproduct_tables(db) |
| db_installed_version = self._update_db_version(db, 1) |
| |
| if db_installed_version < 2: |
| self._replace_product_on_ticket_with_product_prefix(db) |
| db_installed_version = self._update_db_version(db, 2) |
| |
| if db_installed_version < 3: |
| SYSTEM_TABLES = ['system'] |
| TICKET_TABLES = [ |
| 'ticket_change', 'ticket_custom', 'attachment', |
| ] |
| table_defs = self._add_product_column_to_tables( |
| self.MIGRATE_TABLES + TICKET_TABLES + SYSTEM_TABLES, |
| db_installed_version) |
| table_columns = self._get_table_columns(table_defs) |
| create_temp_table = lambda table: self._create_temp_table( |
| db, table, table_columns, table_defs) |
| |
| self._insert_default_product(db) |
| self._upgrade_tickets(db, TICKET_TABLES, create_temp_table) |
| self._upgrade_wikis(db, create_temp_table) |
| self._upgrade_system_tables(db, create_temp_table) |
| self._soft_link_repositories_to_default_product(db) |
| self._upgrade_table_system(SYSTEM_TABLES, create_temp_table, db) |
| self._enable_multiproduct_hooks() |
| |
| db_installed_version = self._update_db_version(db, 3) |
| |
| if db_installed_version < 4: |
| self._create_product_tables_for_plugins(db) |
| db_installed_version = self._update_db_version(db, 4) |
| |
| if db_installed_version < 5: |
| table_defs = self._add_product_column_to_tables( |
| ['ticket'], db_installed_version) |
| self._modify_ticket_pk(db, table_defs) |
| db_installed_version = self._update_db_version(db, 5) |
| |
| self.env.enable_multiproduct_schema(True) |
| |
| def _add_column_product_to_ticket(self, db): |
| self.log.debug("Adding field product to ticket table") |
| db("ALTER TABLE ticket ADD COLUMN product TEXT") |
| |
| def _create_multiproduct_tables(self, db): |
| self.log.debug("Creating initial db tables for %s plugin." % |
| PLUGIN_NAME) |
| db_connector, dummy = DatabaseManager(self.env)._get_connector() |
| for table in self.SCHEMA: |
| for statement in db_connector.to_sql(table): |
| db(statement) |
| |
| def _replace_product_on_ticket_with_product_prefix(self, db): |
| for prod in Product.select(self.env): |
| db("""UPDATE ticket SET product=%s |
| WHERE product=%s""", (prod.prefix, prod.name)) |
| |
| def _create_temp_table(self, db, table, table_columns, table_defs): |
| """creates temporary table with the new schema and |
| drops original table""" |
| table_temp_name = '%s_temp' % table |
| if table == 'report': |
| cols = ','.join([c for c in table_columns[table] if c != 'id']) |
| else: |
| cols = ','.join(table_columns[table]) |
| self.log.info("Migrating table '%s' to a new schema", table) |
| db("""CREATE TABLE %s AS SELECT %s FROM %s""" % |
| (table_temp_name, cols, table)) |
| db("""DROP TABLE %s""" % table) |
| db_connector, _ = DatabaseManager(self.env)._get_connector() |
| table_schema = [t for t in table_defs if t.name == table][0] |
| for sql in db_connector.to_sql(table_schema): |
| db(sql) |
| return table_temp_name, cols |
| |
| def _drop_temp_table(self, db, table): |
| db("""DROP TABLE %s""" % table) |
| |
| def _add_product_column_to_tables(self, tables, current_version): |
| """Extend trac default schema by adding product column |
| and extending key with product. |
| """ |
| table_defs = [copy.deepcopy(t) for t in trac.db_default.schema |
| if |
| t.name in tables] |
| for t in table_defs: |
| t.columns.append(Column('product')) |
| if isinstance(t.key, list): |
| t.key = tuple(t.key) + tuple(['product']) |
| elif isinstance(t.key, tuple): |
| t.key = t.key + tuple(['product']) |
| else: |
| raise TracError( |
| "Invalid table '%s' schema key '%s' while upgrading " |
| "plugin '%s' from version %d to %d'" % |
| (t.name, t.key, PLUGIN_NAME, current_version, 3)) |
| return table_defs |
| |
| def _get_table_columns(self, table_defs, all_columns=False): |
| table_columns = dict() |
| for table in table_defs: |
| table_definition = \ |
| [t for t in table_defs if t.name == table.name][0] |
| column_names = \ |
| [column.name for column in table_definition.columns] |
| table_columns[table.name] = \ |
| [c for c in column_names if all_columns or c != 'product'] |
| return table_columns |
| |
| def _insert_default_product(self, db): |
| self.log.info("Creating default product") |
| db("""INSERT INTO bloodhound_product (prefix, name, description, owner) |
| VALUES ('%s', '%s', '%s', '') |
| """ % (self.default_product_prefix, 'Default', 'Default product')) |
| |
| def _upgrade_tickets(self, db, TICKET_TABLES, create_temp_table): |
| # migrate tickets that don't have product assigned to default product |
| # - update ticket table product column |
| # - update ticket related tables by: |
| # - upgrading schema |
| # - update product column to match ticket's product |
| self.log.info("Migrating tickets w/o product to default product") |
| db("""UPDATE ticket SET product='%s' |
| WHERE (product IS NULL OR product='') |
| """ % self.default_product_prefix) |
| self._migrate_attachments( |
| db("""SELECT a.type, a.id, a.filename |
| FROM attachment a |
| INNER JOIN ticket t ON a.id = %(t.id)s |
| WHERE a.type='ticket' |
| """ % {'t.id': db.cast('t.id', 'text')}), |
| to_product=self.default_product_prefix |
| ) |
| self.log.info("Migrating ticket tables to a new schema") |
| for table in TICKET_TABLES: |
| temp_table_name, cols = create_temp_table(table) |
| db("""INSERT INTO %s (%s, product) |
| SELECT %s, '' FROM %s""" % |
| (table, cols, cols, temp_table_name)) |
| self._drop_temp_table(db, temp_table_name) |
| if table == 'attachment': |
| db("""UPDATE attachment |
| SET product=(SELECT ticket.product |
| FROM ticket |
| WHERE %(ticket.id)s=attachment.id |
| LIMIT 1) |
| WHERE attachment.type='ticket' |
| AND EXISTS(SELECT ticket.product |
| FROM ticket |
| WHERE %(ticket.id)s=attachment.id) |
| """ % {'ticket.id': db.cast('ticket.id', 'text')}) |
| else: |
| db("""UPDATE %(table)s |
| SET product=(SELECT ticket.product |
| FROM ticket |
| WHERE ticket.id=%(table)s.ticket) |
| """ % {'table': table}) |
| |
| def _upgrade_system_tables(self, db, create_temp_table): |
| # migrate system table (except wiki which is handled separately) |
| # to a new schema |
| # - create tables with the new schema |
| # - populate system tables with global configuration for each product |
| # - exception is permission table where permissions |
| # are also populated in global scope |
| # |
| # permission table specifics: 'anonymous' and 'authenticated' users |
| # should by default have a PRODUCT_VIEW permission for all products |
| self.log.info("Migrating system tables to a new schema") |
| for table in self.MIGRATE_TABLES: |
| if table == 'wiki': |
| continue |
| temp_table_name, cols = create_temp_table(table) |
| for product in Product.select(self.env): |
| self.log.info("Populating table '%s' for product '%s' ('%s')", |
| table, product.name, product.prefix) |
| db("""INSERT INTO %s (%s, product) SELECT %s,'%s' FROM %s""" % |
| (table, cols, cols, product.prefix, temp_table_name)) |
| if table == 'permission': |
| db.executemany( |
| """INSERT INTO permission (username, action, product) |
| VALUES (%s, %s, %s)""", |
| [('anonymous', 'PRODUCT_VIEW', product.prefix), |
| ('authenticated', 'PRODUCT_VIEW', product.prefix)]) |
| |
| if table == 'permission': |
| self.log.info("Populating table '%s' for global scope", table) |
| db("""INSERT INTO %s (%s, product) SELECT %s,'%s' FROM %s""" % |
| (table, cols, cols, '', temp_table_name)) |
| self._drop_temp_table(db, temp_table_name) |
| db.executemany( |
| """INSERT INTO permission (username, action, product) |
| VALUES (%s, %s, %s)""", |
| [('anonymous', 'PRODUCT_VIEW', ''), |
| ('authenticated', 'PRODUCT_VIEW', '')]) |
| |
| |
| def _upgrade_wikis(self, db, create_temp_table): |
| # migrate wiki table |
| # - populate system wikis to all products + global scope |
| # - update wiki attachment product to match wiki product |
| table = 'wiki' |
| temp_table_name, cols = create_temp_table(table) |
| self.log.info("Migrating wikis to default product") |
| db("""INSERT INTO %(table)s (%(cols)s, product) |
| SELECT %(cols)s, '%(default_product)s' FROM %(temp_table)s |
| """ % dict(table=table, |
| temp_table=temp_table_name, |
| cols=cols, |
| default_product=self.default_product_prefix,)) |
| db("""UPDATE attachment |
| SET product='%s' |
| WHERE attachment.type='wiki' |
| """ % self.default_product_prefix) |
| self._migrate_attachments( |
| db("""SELECT type, id, filename |
| FROM attachment |
| WHERE type='wiki' |
| AND product='%s' |
| """ % (self.default_product_prefix)), |
| to_product=self.default_product_prefix, |
| ) |
| self._drop_temp_table(db, temp_table_name) |
| |
| def _migrate_attachments(self, attachments, to_product=None, copy=False): |
| for type, id, filename in attachments: |
| old_path = Attachment._get_path(self.env.path, type, id, filename) |
| new_path = self.env.path |
| if to_product: |
| new_path = os.path.join(new_path, 'products', to_product) |
| new_path = Attachment._get_path(new_path, type, id, filename) |
| dirname = os.path.dirname(new_path) |
| if not os.path.exists(old_path): |
| self.log.warning( |
| "Missing attachment files for %s:%s/%s", |
| type, id, filename) |
| continue |
| if os.path.exists(new_path): |
| # TODO: Do we want to overwrite? |
| continue |
| try: |
| if not os.path.exists(dirname): |
| os.makedirs(dirname) |
| if copy: |
| if hasattr(os, 'link'): |
| # TODO: It this safe? |
| os.link(old_path, new_path) |
| else: |
| shutil.copy(old_path, new_path) |
| else: |
| os.rename(old_path, new_path) |
| except OSError as err: |
| self.log.warning( |
| "Could not move attachment %s from %s %s to" |
| "product @ (%s)", |
| filename, type, id, str(err) |
| ) |
| |
| def _soft_link_repositories_to_default_product(self, db): |
| # soft link existing repositories to default product |
| repositories_linked = [] |
| for id, name in db("""SELECT id, value FROM repository |
| WHERE name='name'"""): |
| if id in repositories_linked: |
| continue |
| db("""INSERT INTO repository (id, name, value) |
| VALUES (%s, 'product', '%s')""" % |
| (id, self.default_product_prefix)) |
| repositories_linked.append(id) |
| self.log.info("Repository '%s' (%s) soft linked to default product", |
| name, id) |
| |
| def _upgrade_table_system(self, SYSTEM_TABLES, create_temp_table, db): |
| # Update system tables |
| # Upgrade schema |
| self.log.info("Migrating system tables to a new schema") |
| for table in SYSTEM_TABLES: |
| temp_table_name, cols = create_temp_table(table) |
| db("""INSERT INTO %s (%s, product) |
| SELECT %s,'' FROM %s""" % |
| (table, cols, cols, temp_table_name)) |
| self._drop_temp_table(db, temp_table_name) |
| |
| def _enable_multiproduct_hooks(self): |
| # enable multi product hooks in environment configuration |
| |
| config_update = False |
| if not 'environment_factory' in self.env.config['trac']: |
| self.env.config['trac'].set('environment_factory', |
| 'multiproduct.hooks.MultiProductEnvironmentFactory') |
| config_update = True |
| if not 'request_factory' in self.env.config['trac']: |
| self.env.config['trac'].set('request_factory', |
| 'multiproduct.hooks.ProductRequestFactory') |
| config_update = True |
| if config_update: |
| self.log.info( |
| "Enabling multi product hooks in environment configuration") |
| self.env.config.save() |
| |
| def _create_product_tables_for_plugins(self, db): |
| self.log.debug("creating additional db tables for %s plugin." % |
| PLUGIN_NAME) |
| db_connector, dummy = DatabaseManager(self.env)._get_connector() |
| for statement in db_connector.to_sql(ProductSetting._get_schema()): |
| db(statement) |
| |
| def _modify_ticket_pk(self, db, table_defs): |
| self.log.debug("Modifying ticket primary key: id -> uid") |
| table_columns = self._get_table_columns(table_defs, True) |
| db_connector, _ = DatabaseManager(self.env)._get_connector() |
| |
| def rename_id_to_uid(table): |
| for c in table.columns: |
| if c.name == 'id': |
| c.name = 'uid' |
| break |
| table.key = ['uid'] |
| |
| def add_new_id_column(table): |
| id_column = Column('id', type='int', auto_increment=True) |
| if using_sqlite_backend(self.env) or using_mysql_backend(self.env): |
| # sqlite and mysql don't support multiple auto increment columns |
| id_column.auto_increment = False |
| table.columns.append(id_column) |
| table.indices.append(Index(['product', 'id'], unique=True)) |
| |
| |
| for t in table_defs: |
| rename_id_to_uid(t) |
| add_new_id_column(t) |
| |
| temp_table_name, cols = self._create_temp_table( |
| db, t.name, table_columns, table_defs) |
| db("""INSERT INTO ticket (%s, uid) |
| SELECT %s, id FROM ticket_temp""" % |
| (cols, cols)) |
| self._drop_temp_table(db, temp_table_name) |
| db.update_sequence(db.cursor(), 'ticket', 'id') |
| db.update_sequence(db.cursor(), 'ticket', 'uid') |
| |
| # IResourceChangeListener methods |
| def match_resource(self, resource): |
| return isinstance(resource, Product) |
| |
| def resource_created(self, resource, context): |
| import trac.db_default |
| from multiproduct.env import EnvironmentStub |
| |
| # Don't populate product database when running from within test |
| # environment stub as test cases really don't expect that ... |
| if isinstance(self.env, EnvironmentStub): |
| return |
| |
| product = resource |
| self.log.debug("Adding product info (%s) to tables:" % product.prefix) |
| with self.env.db_direct_transaction as db: |
| # create the default entries for this Product from defaults |
| for table in trac.db_default.get_data(db): |
| if not table[0] in self.PRODUCT_POPULATE_TABLES: |
| continue |
| |
| self.log.debug(" -> %s" % table[0]) |
| cols = table[1] + ('product', ) |
| rows = [p + (product.prefix, ) for p in table[2]] |
| db.executemany( |
| "INSERT INTO %s (%s) VALUES (%s)" % |
| (table[0], ','.join(cols), ','.join(['%s' for c in cols])), |
| rows) |
| |
| # Import default pages in product wiki |
| wikiadmin = WikiAdmin(ProductEnvironment(self.env, product.prefix)) |
| pages = ('TitleIndex', 'RecentChanges', 'InterTrac', 'InterWiki') |
| for page in pages: |
| filename = resource_filename('trac.wiki', 'default-pages/' + page) |
| wikiadmin.import_page(filename, page) |
| |
| def resource_changed(self, resource, old_values, context): |
| return |
| |
| def resource_deleted(self, resource, context): |
| return |
| |
| def resource_version_deleted(self, resource, context): |
| return |
| |
| # ITemplateProvider methods |
| def get_templates_dirs(self): |
| """provide the plugin templates""" |
| return [resource_filename(__name__, 'templates')] |
| |
| def get_htdocs_dirs(self): |
| """proved the plugin htdocs""" |
| return [] |
| |
| # IPermissionRequestor methods |
| def get_permission_actions(self): |
| acts = ['PRODUCT_CREATE', 'PRODUCT_DELETE', 'PRODUCT_MODIFY', |
| 'PRODUCT_VIEW'] |
| if not isinstance(self.env, ProductEnvironment): |
| return acts + [('PRODUCT_ADMIN', acts)] + [('ROADMAP_ADMIN', acts)] |
| else: |
| # In product context PRODUCT_ADMIN will be provided by product env |
| # to ensure it will always be handy |
| return acts |
| |
| # ITicketFieldProvider methods |
| def get_select_fields(self): |
| """Product select fields""" |
| return [(35, {'name': 'product', 'label': _('Product'), |
| 'cls': Product, 'pk': 'prefix', 'optional': False, |
| 'value': self.default_product})] |
| |
| def get_radio_fields(self): |
| """Product radio fields""" |
| return [] |
| |
| # IResourceManager methods |
| def get_resource_realms(self): |
| """Manage 'product' realm. |
| """ |
| yield 'product' |
| |
| def get_resource_description(self, resource, format='default', context=None, |
| **kwargs): |
| """Describe product resource. |
| """ |
| desc = resource.id |
| if format != 'compact': |
| desc = _('Product %(name)s', name=resource.id) |
| if context: |
| return self._render_link(context, resource.id, desc) |
| else: |
| return desc |
| |
| def resource_exists(self, resource): |
| """Check whether product exists physically. |
| """ |
| products = Product.select(self.env, where={'name' : resource.id}) |
| return bool(products) |
| |
| # IExternalResourceConnector methods |
| def get_supported_neighborhoods(self): |
| """Neighborhoods for `product` and `global` environments. |
| """ |
| yield 'product' |
| yield 'global' |
| |
| def load_manager(self, neighborhood): |
| """Load global environment or product environment given its prefix |
| """ |
| if neighborhood._realm == 'global': |
| # FIXME: ResourceNotFound if neighborhood ID != None ? |
| prefix = GLOBAL_PRODUCT |
| elif neighborhood._realm == 'product': |
| prefix = neighborhood._id |
| else: |
| raise ResourceNotFound(_(u'Unsupported neighborhood %(realm)s', |
| realm=neighborhood._realm)) |
| try: |
| return lookup_product_env(self.env, prefix) |
| except LookupError: |
| raise ResourceNotFound(_(u'Unknown product prefix %(prefix)s', |
| prefix=prefix)) |
| |
| def manager_exists(self, neighborhood): |
| """Check whether the target environment exists physically. |
| """ |
| if neighborhood._realm == 'global': |
| # Global environment |
| return isinstance(self.env, (Environment, ProductEnvironment)) |
| elif neighborhood._realm == 'product': |
| prefix = neighborhood._id |
| if not prefix: |
| # Global environment |
| return True |
| return Product(lookup_product_env(self.env, GLOBAL_PRODUCT), |
| {'prefix' : prefix})._exists |
| |
| # IWikiSyntaxProvider methods |
| |
| short_syntax_delimiter = u'->' |
| |
| def get_wiki_syntax(self): |
| yield (r'(?<!\S)!?(?P<pid>%s)%s(?P<ptarget>%s:(?:%s)|%s|%s(?:%s*%s)?)' % |
| (IDENTIFIER, |
| PRODUCT_SYNTAX_DELIMITER_RE, |
| WikiParser.LINK_SCHEME, WikiParser.QUOTED_STRING, |
| WikiParser.QUOTED_STRING, WikiParser.SHREF_TARGET_FIRST, |
| WikiParser.SHREF_TARGET_MIDDLE, WikiParser.SHREF_TARGET_LAST), |
| lambda f, m, fm : |
| self._format_link(f, 'product', |
| '%s:%s' % (fm.group('pid'), |
| unquote_label(fm.group('ptarget'))), |
| fm.group(0), fm)) |
| if self.env[ProductTicketModule] is not None: |
| yield (r"(?<!\S)!?(?P<jtp>%s)-(?P<jtt>\d+)(?P<jtf>[?#]\S+)?" % |
| (IDENTIFIER,), |
| lambda f, m, fm : |
| self._format_link(f, 'product', |
| '%s:ticket:%s' % |
| (fm.group('jtp'), |
| fm.group('jtt') + |
| (fm.group('jtf') or '')), |
| m, fm)) |
| |
| def get_link_resolvers(self): |
| yield ('global', self._format_link) |
| yield ('product', self._format_link) |
| |
| # ITicketManipulator methods |
| def validate_ticket(self, req, ticket): |
| # check whether the owner exists in db, add a warning if not |
| if req.args.get('action') == 'reassign' and \ |
| ticket['owner'] != self.env.config.get('ticket', 'default_owner'): |
| owner = self.env.db_direct_query( |
| "SELECT sid FROM session WHERE sid=%s", |
| (ticket['owner'], )) |
| if not owner: |
| # Note: add_warning() is used intead of returning a list of |
| # error tuples, since the latter results in trac rendering |
| # errors (ticket's change.date is not populated) |
| add_warning(req, _('The user "%s" does not exist.') % |
| ticket['owner']) |
| return [] |
| |
| |
| # Internal methods |
| |
| def _render_link(self, context, name, label, extra='', prefix=None): |
| """Render link to product page. |
| """ |
| product_env = product = None |
| env = self.env |
| if isinstance(env, ProductEnvironment): |
| if (prefix is not None and env.product.prefix == prefix) \ |
| or (prefix is None and env.name == name): |
| product_env = env |
| env = env.parent |
| try: |
| if product_env is None: |
| if prefix is not None: |
| product_env = ProductEnvironment(env, to_unicode(prefix)) |
| else: |
| product = Product.select(env, |
| where={'name' : to_unicode(name)}) |
| if not product: |
| raise LookupError("Missing product") |
| product_env = ProductEnvironment(env, |
| to_unicode(product[0])) |
| except LookupError: |
| pass |
| |
| if product_env is not None: |
| product = product_env.product |
| href = resolve_product_href(to_env=product_env, at_env=self.env) |
| if 'PRODUCT_VIEW' in context.perm(product.resource): |
| return tag.a(label, class_='product', href=href() + extra, |
| title=product.name) |
| if 'PRODUCT_CREATE' in context.perm('product', name): |
| params = [('action', 'new')] |
| if prefix: |
| params.append( ('prefix', prefix) ) |
| if name: |
| params.append( ('name', name) ) |
| return tag.a(label, class_='missing product', |
| href=env.href('products', params), |
| rel='nofollow') |
| return tag.a(label, class_='missing product') |
| |
| def _format_link(self, formatter, ns, target, label, fullmatch): |
| link, params, fragment = formatter.split_link(target) |
| expr = link.split(':', 1) |
| if ns == 'product' and len(expr) == 1: |
| # product:prefix form |
| return self._render_link(formatter.context, None, label, |
| params + fragment, expr[0]) |
| elif ns == 'global' or (ns == 'product' and expr[0] == ''): |
| # global scope |
| sublink = link if ns == 'global' else expr[1] |
| target_env = self.env.parent \ |
| if isinstance(self.env, ProductEnvironment) \ |
| else self.env |
| return self._make_sublink(target_env, sublink, formatter, ns, |
| target, label, fullmatch, |
| extra=params + fragment) |
| else: |
| # product:prefix:realm:id:... |
| prefix, sublink = expr |
| try: |
| target_env = lookup_product_env(self.env, prefix) |
| except LookupError: |
| return tag.a(label, class_='missing product') |
| # TODO: Check for nested product links |
| # e.g. product:p1:product:p2:ticket:1 |
| return self._make_sublink(target_env, sublink, formatter, ns, |
| target, label, fullmatch, |
| extra=params + fragment) |
| |
| FakePermClass = FakePerm |
| |
| def _make_sublink(self, env, sublink, formatter, ns, target, label, |
| fullmatch, extra=''): |
| parent_match = {'ns' : ns, |
| 'target' : target, |
| 'label': Markup(escape(unescape(label) |
| if isinstance(label, Markup) |
| else label)), |
| 'fullmatch' : fullmatch, |
| } |
| |
| # Tweak nested context to work in target product/global scope |
| subctx = formatter.context.child() |
| subctx.href = resolve_product_href(to_env=env, at_env=self.env) |
| try: |
| req = formatter.context.req |
| except AttributeError: |
| pass |
| else: |
| # Authenticate in local context but use foreign permissions |
| subctx.perm = self.FakePermClass() \ |
| if isinstance(req.session, FakeSession) \ |
| else PermissionCache(env, req.authname) |
| subctx.req = req |
| |
| subformatter = EmbeddedLinkFormatter(env, subctx, parent_match) |
| subformatter.auto_quote = True |
| ctxtag = '[%s] ' % (env.product.prefix,) \ |
| if isinstance(env, ProductEnvironment) \ |
| else '<global> ' |
| subformatter.enhance_link = lambda link : ( |
| link(title=ctxtag + link.attrib.get('title')) |
| if isinstance(link, Element) |
| and 'title' in link.attrib |
| else link) |
| link = subformatter.match(sublink + extra) |
| if link: |
| return link |
| else: |
| # Return outermost match unchanged like if it was !-escaped |
| for itype, match in fullmatch.groupdict().items(): |
| if match and not itype in formatter.wikiparser.helper_patterns: |
| return escape(match) |
| |
| |
| PRODUCT_SYNTAX_DELIMITER = MultiProductSystem.short_syntax_delimiter |
| PRODUCT_SYNTAX_DELIMITER_RE = ''.join('[%s]' % c |
| for c in PRODUCT_SYNTAX_DELIMITER) |
| |
| from multiproduct.env import ProductEnvironment, lookup_product_env, \ |
| resolve_product_href |
| from multiproduct.ticket.web_ui import ProductTicketModule |
