admin: ported settings controller to pyramid.

- NavList dropped pyramid flag as it's pure pyramid now

rhodecode/apps/admin/views/settings.py

@@ -0,0 +1,754 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2017 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+import logging
+import collections
+
+import datetime
+import formencode
+import formencode.htmlfill
+
+import rhodecode
+from pyramid.view import view_config
+from pyramid.httpexceptions import HTTPFound, HTTPNotFound
+from pyramid.renderers import render
+from pyramid.response import Response
+
+from rhodecode.apps._base import BaseAppView
+from rhodecode.apps.admin.navigation import navigation_list
+from rhodecode.apps.svn_support.config_keys import generate_config
+from rhodecode.lib import helpers as h
+from rhodecode.lib.auth import (
+    LoginRequired, HasPermissionAllDecorator, CSRFRequired)
+from rhodecode.lib.celerylib import tasks, run_task
+from rhodecode.lib.utils import repo2db_mapper
+from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict
+from rhodecode.lib.index import searcher_from_config
+
+from rhodecode.model.db import RhodeCodeUi, Repository
+from rhodecode.model.forms import (ApplicationSettingsForm,
+    ApplicationUiSettingsForm, ApplicationVisualisationForm,
+    LabsSettingsForm, IssueTrackerPatternsForm)
+from rhodecode.model.repo_group import RepoGroupModel
+
+from rhodecode.model.scm import ScmModel
+from rhodecode.model.notification import EmailNotificationModel
+from rhodecode.model.meta import Session
+from rhodecode.model.settings import (
+    IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound,
+    SettingsModel)
+
+
+log = logging.getLogger(__name__)
+
+
+class AdminSettingsView(BaseAppView):
+
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        c.labs_active = str2bool(
+            rhodecode.CONFIG.get('labs_settings_active', 'true'))
+        c.navlist = navigation_list(self.request)
+        self._register_global_c(c)
+        return c
+
+    @classmethod
+    def _get_ui_settings(cls):
+        ret = RhodeCodeUi.query().all()
+
+        if not ret:
+            raise Exception('Could not get application ui settings !')
+        settings = {}
+        for each in ret:
+            k = each.ui_key
+            v = each.ui_value
+            if k == '/':
+                k = 'root_path'
+
+            if k in ['push_ssl', 'publish', 'enabled']:
+                v = str2bool(v)
+
+            if k.find('.') != -1:
+                k = k.replace('.', '_')
+
+            if each.ui_section in ['hooks', 'extensions']:
+                v = each.ui_active
+
+            settings[each.ui_section + '_' + k] = v
+        return settings
+
+    @classmethod
+    def _form_defaults(cls):
+        defaults = SettingsModel().get_all_settings()
+        defaults.update(cls._get_ui_settings())
+
+        defaults.update({
+            'new_svn_branch': '',
+            'new_svn_tag': '',
+        })
+        return defaults
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_vcs', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_vcs(self):
+        c = self.load_default_context()
+        c.active = 'vcs'
+        model = VcsSettingsModel()
+        c.svn_branch_patterns = model.get_global_svn_branch_patterns()
+        c.svn_tag_patterns = model.get_global_svn_tag_patterns()
+
+        settings = self.request.registry.settings
+        c.svn_proxy_generate_config = settings[generate_config]
+
+        defaults = self._form_defaults()
+
+        model.create_largeobjects_dirs_if_needed(defaults['paths_root_path'])
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=defaults,
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_vcs_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_vcs_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'vcs'
+
+        model = VcsSettingsModel()
+        c.svn_branch_patterns = model.get_global_svn_branch_patterns()
+        c.svn_tag_patterns = model.get_global_svn_tag_patterns()
+
+        settings = self.request.registry.settings
+        c.svn_proxy_generate_config = settings[generate_config]
+
+        application_form = ApplicationUiSettingsForm()()
+
+        try:
+            form_result = application_form.to_python(dict(self.request.POST))
+        except formencode.Invalid as errors:
+            h.flash(
+                _("Some form inputs contain invalid data."),
+                category='error')
+            data = render('rhodecode:templates/admin/settings/settings.mako',
+                          self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+
+        try:
+            if c.visual.allow_repo_location_change:
+                model.update_global_path_setting(
+                    form_result['paths_root_path'])
+
+            model.update_global_ssl_setting(form_result['web_push_ssl'])
+            model.update_global_hook_settings(form_result)
+
+            model.create_or_update_global_svn_settings(form_result)
+            model.create_or_update_global_hg_settings(form_result)
+            model.create_or_update_global_git_settings(form_result)
+            model.create_or_update_global_pr_settings(form_result)
+        except Exception:
+            log.exception("Exception while updating settings")
+            h.flash(_('Error occurred during updating '
+                      'application settings'), category='error')
+        else:
+            Session().commit()
+            h.flash(_('Updated VCS settings'), category='success')
+            raise HTTPFound(h.route_path('admin_settings_vcs'))
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_vcs_svn_pattern_delete', request_method='POST',
+        renderer='json_ext', xhr=True)
+    def settings_vcs_delete_svn_pattern(self):
+        delete_pattern_id = self.request.POST.get('delete_svn_pattern')
+        model = VcsSettingsModel()
+        try:
+            model.delete_global_svn_pattern(delete_pattern_id)
+        except SettingNotFound:
+            log.exception(
+                'Failed to delete svn_pattern with id %s', delete_pattern_id)
+            raise HTTPNotFound()
+
+        Session().commit()
+        return True
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_mapping', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_mapping(self):
+        c = self.load_default_context()
+        c.active = 'mapping'
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_mapping_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_mapping_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'mapping'
+        rm_obsolete = self.request.POST.get('destroy', False)
+        invalidate_cache = self.request.POST.get('invalidate', False)
+        log.debug(
+            'rescanning repo location with destroy obsolete=%s', rm_obsolete)
+
+        if invalidate_cache:
+            log.debug('invalidating all repositories cache')
+            for repo in Repository.get_all():
+                ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
+
+        filesystem_repos = ScmModel().repo_scan()
+        added, removed = repo2db_mapper(filesystem_repos, rm_obsolete)
+        _repr = lambda l: ', '.join(map(safe_unicode, l)) or '-'
+        h.flash(_('Repositories successfully '
+                  'rescanned added: %s ; removed: %s') %
+                (_repr(added), _repr(removed)),
+                category='success')
+        raise HTTPFound(h.route_path('admin_settings_mapping'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    @view_config(
+        route_name='admin_settings_global', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_global(self):
+        c = self.load_default_context()
+        c.active = 'global'
+        c.personal_repo_group_default_pattern = RepoGroupModel()\
+            .get_personal_group_name_pattern()
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    @view_config(
+        route_name='admin_settings_global_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_global_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'global'
+        c.personal_repo_group_default_pattern = RepoGroupModel()\
+            .get_personal_group_name_pattern()
+        application_form = ApplicationSettingsForm()()
+        try:
+            form_result = application_form.to_python(dict(self.request.POST))
+        except formencode.Invalid as errors:
+            data = render('rhodecode:templates/admin/settings/settings.mako',
+                          self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+
+        settings = [
+            ('title', 'rhodecode_title', 'unicode'),
+            ('realm', 'rhodecode_realm', 'unicode'),
+            ('pre_code', 'rhodecode_pre_code', 'unicode'),
+            ('post_code', 'rhodecode_post_code', 'unicode'),
+            ('captcha_public_key', 'rhodecode_captcha_public_key', 'unicode'),
+            ('captcha_private_key', 'rhodecode_captcha_private_key', 'unicode'),
+            ('create_personal_repo_group', 'rhodecode_create_personal_repo_group', 'bool'),
+            ('personal_repo_group_pattern', 'rhodecode_personal_repo_group_pattern', 'unicode'),
+        ]
+        try:
+            for setting, form_key, type_ in settings:
+                sett = SettingsModel().create_or_update_setting(
+                    setting, form_result[form_key], type_)
+                Session().add(sett)
+
+            Session().commit()
+            SettingsModel().invalidate_settings_cache()
+            h.flash(_('Updated application settings'), category='success')
+        except Exception:
+            log.exception("Exception while updating application settings")
+            h.flash(
+                _('Error occurred during updating application settings'),
+                category='error')
+
+        raise HTTPFound(h.route_path('admin_settings_global'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_visual', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_visual(self):
+        c = self.load_default_context()
+        c.active = 'visual'
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_visual_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_visual_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'visual'
+        application_form = ApplicationVisualisationForm()()
+        try:
+            form_result = application_form.to_python(dict(self.request.POST))
+        except formencode.Invalid as errors:
+            data = render('rhodecode:templates/admin/settings/settings.mako',
+                          self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+
+        try:
+            settings = [
+                ('show_public_icon', 'rhodecode_show_public_icon', 'bool'),
+                ('show_private_icon', 'rhodecode_show_private_icon', 'bool'),
+                ('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'),
+                ('repository_fields', 'rhodecode_repository_fields', 'bool'),
+                ('dashboard_items', 'rhodecode_dashboard_items', 'int'),
+                ('admin_grid_items', 'rhodecode_admin_grid_items', 'int'),
+                ('show_version', 'rhodecode_show_version', 'bool'),
+                ('use_gravatar', 'rhodecode_use_gravatar', 'bool'),
+                ('markup_renderer', 'rhodecode_markup_renderer', 'unicode'),
+                ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),
+                ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),
+                ('support_url', 'rhodecode_support_url', 'unicode'),
+                ('show_revision_number', 'rhodecode_show_revision_number', 'bool'),
+                ('show_sha_length', 'rhodecode_show_sha_length', 'int'),
+            ]
+            for setting, form_key, type_ in settings:
+                sett = SettingsModel().create_or_update_setting(
+                    setting, form_result[form_key], type_)
+                Session().add(sett)
+
+            Session().commit()
+            SettingsModel().invalidate_settings_cache()
+            h.flash(_('Updated visualisation settings'), category='success')
+        except Exception:
+            log.exception("Exception updating visualization settings")
+            h.flash(_('Error occurred during updating '
+                      'visualisation settings'),
+                    category='error')
+
+        raise HTTPFound(h.route_path('admin_settings_visual'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_issuetracker', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_issuetracker(self):
+        c = self.load_default_context()
+        c.active = 'issuetracker'
+        defaults = SettingsModel().get_all_settings()
+
+        entry_key = 'rhodecode_issuetracker_pat_'
+
+        c.issuetracker_entries = {}
+        for k, v in defaults.items():
+            if k.startswith(entry_key):
+                uid = k[len(entry_key):]
+                c.issuetracker_entries[uid] = None
+
+        for uid in c.issuetracker_entries:
+            c.issuetracker_entries[uid] = AttributeDict({
+                'pat': defaults.get('rhodecode_issuetracker_pat_' + uid),
+                'url': defaults.get('rhodecode_issuetracker_url_' + uid),
+                'pref': defaults.get('rhodecode_issuetracker_pref_' + uid),
+                'desc': defaults.get('rhodecode_issuetracker_desc_' + uid),
+            })
+
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_issuetracker_test', request_method='POST',
+        renderer='string', xhr=True)
+    def settings_issuetracker_test(self):
+        return h.urlify_commit_message(
+            self.request.POST.get('test_text', ''),
+            'repo_group/test_repo1')
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_issuetracker_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_issuetracker_update(self):
+        _ = self.request.translate
+        self.load_default_context()
+        settings_model = IssueTrackerSettingsModel()
+
+        form = IssueTrackerPatternsForm()().to_python(self.request.POST)
+        if form:
+            for uid in form.get('delete_patterns', []):
+                settings_model.delete_entries(uid)
+
+            for pattern in form.get('patterns', []):
+                for setting, value, type_ in pattern:
+                    sett = settings_model.create_or_update_setting(
+                        setting, value, type_)
+                    Session().add(sett)
+
+                Session().commit()
+
+            SettingsModel().invalidate_settings_cache()
+            h.flash(_('Updated issue tracker entries'), category='success')
+        raise HTTPFound(h.route_path('admin_settings_issuetracker'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_issuetracker_delete', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_issuetracker_delete(self):
+        _ = self.request.translate
+        self.load_default_context()
+        uid = self.request.POST.get('uid')
+        try:
+            IssueTrackerSettingsModel().delete_entries(uid)
+        except Exception:
+            log.exception('Failed to delete issue tracker setting %s', uid)
+            raise HTTPNotFound()
+        h.flash(_('Removed issue tracker entry'), category='success')
+        raise HTTPFound(h.route_path('admin_settings_issuetracker'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_email', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_email(self):
+        c = self.load_default_context()
+        c.active = 'email'
+        c.rhodecode_ini = rhodecode.CONFIG
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_email_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_email_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'email'
+
+        test_email = self.request.POST.get('test_email')
+
+        if not test_email:
+            h.flash(_('Please enter email address'), category='error')
+            raise HTTPFound(h.route_path('admin_settings_email'))
+
+        email_kwargs = {
+            'date': datetime.datetime.now(),
+            'user': c.rhodecode_user,
+            'rhodecode_version': c.rhodecode_version
+        }
+
+        (subject, headers, email_body,
+         email_body_plaintext) = EmailNotificationModel().render_email(
+            EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs)
+
+        recipients = [test_email] if test_email else None
+
+        run_task(tasks.send_email, recipients, subject,
+                 email_body_plaintext, email_body)
+
+        h.flash(_('Send email task created'), category='success')
+        raise HTTPFound(h.route_path('admin_settings_email'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_hooks', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_hooks(self):
+        c = self.load_default_context()
+        c.active = 'hooks'
+
+        model = SettingsModel()
+        c.hooks = model.get_builtin_hooks()
+        c.custom_hooks = model.get_custom_hooks()
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_hooks_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    @view_config(
+        route_name='admin_settings_hooks_delete', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_hooks_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'hooks'
+        if c.visual.allow_custom_hooks_settings:
+            ui_key = self.request.POST.get('new_hook_ui_key')
+            ui_value = self.request.POST.get('new_hook_ui_value')
+
+            hook_id = self.request.POST.get('hook_id')
+            new_hook = False
+
+            model = SettingsModel()
+            try:
+                if ui_value and ui_key:
+                    model.create_or_update_hook(ui_key, ui_value)
+                    h.flash(_('Added new hook'), category='success')
+                    new_hook = True
+                elif hook_id:
+                    RhodeCodeUi.delete(hook_id)
+                    Session().commit()
+
+                # check for edits
+                update = False
+                _d = self.request.POST.dict_of_lists()
+                for k, v in zip(_d.get('hook_ui_key', []),
+                                _d.get('hook_ui_value_new', [])):
+                    model.create_or_update_hook(k, v)
+                    update = True
+
+                if update and not new_hook:
+                    h.flash(_('Updated hooks'), category='success')
+                Session().commit()
+            except Exception:
+                log.exception("Exception during hook creation")
+                h.flash(_('Error occurred during hook creation'),
+                        category='error')
+
+        raise HTTPFound(h.route_path('admin_settings_hooks'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_search', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_search(self):
+        c = self.load_default_context()
+        c.active = 'search'
+
+        searcher = searcher_from_config(self.request.registry.settings)
+        c.statistics = searcher.statistics()
+
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_labs', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_labs(self):
+        c = self.load_default_context()
+        if not c.labs_active:
+            raise HTTPFound(h.route_path('admin_settings'))
+
+        c.active = 'labs'
+        c.lab_settings = _LAB_SETTINGS
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_labs_update', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def settings_labs_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'labs'
+
+        application_form = LabsSettingsForm()()
+        try:
+            form_result = application_form.to_python(dict(self.request.POST))
+        except formencode.Invalid as errors:
+            h.flash(
+                _('Some form inputs contain invalid data.'),
+                category='error')
+            data = render('rhodecode:templates/admin/settings/settings.mako',
+                          self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+
+        try:
+            session = Session()
+            for setting in _LAB_SETTINGS:
+                setting_name = setting.key[len('rhodecode_'):]
+                sett = SettingsModel().create_or_update_setting(
+                    setting_name, form_result[setting.key], setting.type)
+                session.add(sett)
+
+        except Exception:
+            log.exception('Exception while updating lab settings')
+            h.flash(_('Error occurred during updating labs settings'),
+                    category='error')
+        else:
+            Session().commit()
+            SettingsModel().invalidate_settings_cache()
+            h.flash(_('Updated Labs settings'), category='success')
+            raise HTTPFound(h.route_path('admin_settings_labs'))
+
+        data = render('rhodecode:templates/admin/settings/settings.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=self._form_defaults(),
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+
+# :param key: name of the setting including the 'rhodecode_' prefix
+# :param type: the RhodeCodeSetting type to use.
+# :param group: the i18ned group in which we should dispaly this setting
+# :param label: the i18ned label we should display for this setting
+# :param help: the i18ned help we should dispaly for this setting
+LabSetting = collections.namedtuple(
+    'LabSetting', ('key', 'type', 'group', 'label', 'help'))
+
+
+# This list has to be kept in sync with the form
+# rhodecode.model.forms.LabsSettingsForm.
+_LAB_SETTINGS = [
+
+]

rhodecode/apps/admin/__init__.py

@@ -1,322 +1,403 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 from rhodecode.apps._base import ADMIN_PREFIX
-from rhodecode.lib.utils2 import str2bool
 
 
 def admin_routes(config):
     """
     Admin prefixed routes
     """
 
     config.add_route(
         name='admin_audit_logs',
         pattern='/audit_logs')
 
     config.add_route(
         name='admin_audit_log_entry',
         pattern='/audit_logs/{audit_log_id}')
 
     config.add_route(
         name='pull_requests_global_0',  # backward compat
         pattern='/pull_requests/{pull_request_id:\d+}')
     config.add_route(
         name='pull_requests_global_1',  # backward compat
         pattern='/pull-requests/{pull_request_id:\d+}')
     config.add_route(
         name='pull_requests_global',
         pattern='/pull-request/{pull_request_id:\d+}')
 
     config.add_route(
         name='admin_settings_open_source',
         pattern='/settings/open_source')
     config.add_route(
         name='admin_settings_vcs_svn_generate_cfg',
         pattern='/settings/vcs/svn_generate_cfg')
 
     config.add_route(
         name='admin_settings_system',
         pattern='/settings/system')
     config.add_route(
         name='admin_settings_system_update',
         pattern='/settings/system/updates')
 
     config.add_route(
         name='admin_settings_sessions',
         pattern='/settings/sessions')
     config.add_route(
         name='admin_settings_sessions_cleanup',
         pattern='/settings/sessions/cleanup')
 
     config.add_route(
         name='admin_settings_process_management',
         pattern='/settings/process_management')
     config.add_route(
         name='admin_settings_process_management_signal',
         pattern='/settings/process_management/signal')
 
     # default settings
     config.add_route(
         name='admin_defaults_repositories',
         pattern='/defaults/repositories')
     config.add_route(
         name='admin_defaults_repositories_update',
         pattern='/defaults/repositories/update')
 
+    # admin settings
+
+    config.add_route(
+        name='admin_settings',
+        pattern='/settings')
+    config.add_route(
+        name='admin_settings_update',
+        pattern='/settings/update')
+
+    config.add_route(
+        name='admin_settings_global',
+        pattern='/settings/global')
+    config.add_route(
+        name='admin_settings_global_update',
+        pattern='/settings/global/update')
+
+    config.add_route(
+        name='admin_settings_vcs',
+        pattern='/settings/vcs')
+    config.add_route(
+        name='admin_settings_vcs_update',
+        pattern='/settings/vcs/update')
+    config.add_route(
+        name='admin_settings_vcs_svn_pattern_delete',
+        pattern='/settings/vcs/svn_pattern_delete')
+
+    config.add_route(
+        name='admin_settings_mapping',
+        pattern='/settings/mapping')
+    config.add_route(
+        name='admin_settings_mapping_update',
+        pattern='/settings/mapping/update')
+
+    config.add_route(
+        name='admin_settings_visual',
+        pattern='/settings/visual')
+    config.add_route(
+        name='admin_settings_visual_update',
+        pattern='/settings/visual/update')
+
+
+    config.add_route(
+        name='admin_settings_issuetracker',
+        pattern='/settings/issue-tracker')
+    config.add_route(
+        name='admin_settings_issuetracker_update',
+        pattern='/settings/issue-tracker/update')
+    config.add_route(
+        name='admin_settings_issuetracker_test',
+        pattern='/settings/issue-tracker/test')
+    config.add_route(
+        name='admin_settings_issuetracker_delete',
+        pattern='/settings/issue-tracker/delete')
+
+    config.add_route(
+        name='admin_settings_email',
+        pattern='/settings/email')
+    config.add_route(
+        name='admin_settings_email_update',
+        pattern='/settings/email/update')
+
+    config.add_route(
+        name='admin_settings_hooks',
+        pattern='/settings/hooks')
+    config.add_route(
+        name='admin_settings_hooks_update',
+        pattern='/settings/hooks/update')
+    config.add_route(
+        name='admin_settings_hooks_delete',
+        pattern='/settings/hooks/delete')
+
+    config.add_route(
+        name='admin_settings_search',
+        pattern='/settings/search')
+
+    config.add_route(
+        name='admin_settings_labs',
+        pattern='/settings/labs')
+    config.add_route(
+        name='admin_settings_labs_update',
+        pattern='/settings/labs/update')
+
     # global permissions
 
     config.add_route(
         name='admin_permissions_application',
         pattern='/permissions/application')
     config.add_route(
         name='admin_permissions_application_update',
         pattern='/permissions/application/update')
 
     config.add_route(
         name='admin_permissions_global',
         pattern='/permissions/global')
     config.add_route(
         name='admin_permissions_global_update',
         pattern='/permissions/global/update')
 
     config.add_route(
         name='admin_permissions_object',
         pattern='/permissions/object')
     config.add_route(
         name='admin_permissions_object_update',
         pattern='/permissions/object/update')
 
     config.add_route(
         name='admin_permissions_ips',
         pattern='/permissions/ips')
 
     config.add_route(
         name='admin_permissions_overview',
         pattern='/permissions/overview')
 
     config.add_route(
         name='admin_permissions_auth_token_access',
         pattern='/permissions/auth_token_access')
 
     config.add_route(
         name='admin_permissions_ssh_keys',
         pattern='/permissions/ssh_keys')
     config.add_route(
         name='admin_permissions_ssh_keys_data',
         pattern='/permissions/ssh_keys/data')
     config.add_route(
         name='admin_permissions_ssh_keys_update',
         pattern='/permissions/ssh_keys/update')
 
     # users admin
     config.add_route(
         name='users',
         pattern='/users')
 
     config.add_route(
         name='users_data',
         pattern='/users_data')
 
     config.add_route(
         name='users_create',
         pattern='/users/create')
 
     config.add_route(
         name='users_new',
         pattern='/users/new')
 
     # user management
     config.add_route(
         name='user_edit',
         pattern='/users/{user_id:\d+}/edit',
         user_route=True)
     config.add_route(
         name='user_edit_advanced',
         pattern='/users/{user_id:\d+}/edit/advanced',
         user_route=True)
     config.add_route(
         name='user_edit_global_perms',
         pattern='/users/{user_id:\d+}/edit/global_permissions',
         user_route=True)
     config.add_route(
         name='user_edit_global_perms_update',
         pattern='/users/{user_id:\d+}/edit/global_permissions/update',
         user_route=True)
     config.add_route(
         name='user_update',
         pattern='/users/{user_id:\d+}/update',
         user_route=True)
     config.add_route(
         name='user_delete',
         pattern='/users/{user_id:\d+}/delete',
         user_route=True)
     config.add_route(
         name='user_force_password_reset',
         pattern='/users/{user_id:\d+}/password_reset',
         user_route=True)
     config.add_route(
         name='user_create_personal_repo_group',
         pattern='/users/{user_id:\d+}/create_repo_group',
         user_route=True)
 
     # user auth tokens
     config.add_route(
         name='edit_user_auth_tokens',
         pattern='/users/{user_id:\d+}/edit/auth_tokens',
         user_route=True)
     config.add_route(
         name='edit_user_auth_tokens_add',
         pattern='/users/{user_id:\d+}/edit/auth_tokens/new',
         user_route=True)
     config.add_route(
         name='edit_user_auth_tokens_delete',
         pattern='/users/{user_id:\d+}/edit/auth_tokens/delete',
         user_route=True)
 
     # user ssh keys
     config.add_route(
         name='edit_user_ssh_keys',
         pattern='/users/{user_id:\d+}/edit/ssh_keys',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_generate_keypair',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/generate',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_add',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/new',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_delete',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/delete',
         user_route=True)
 
     # user emails
     config.add_route(
         name='edit_user_emails',
         pattern='/users/{user_id:\d+}/edit/emails',
         user_route=True)
     config.add_route(
         name='edit_user_emails_add',
         pattern='/users/{user_id:\d+}/edit/emails/new',
         user_route=True)
     config.add_route(
         name='edit_user_emails_delete',
         pattern='/users/{user_id:\d+}/edit/emails/delete',
         user_route=True)
 
     # user IPs
     config.add_route(
         name='edit_user_ips',
         pattern='/users/{user_id:\d+}/edit/ips',
         user_route=True)
     config.add_route(
         name='edit_user_ips_add',
         pattern='/users/{user_id:\d+}/edit/ips/new',
         user_route_with_default=True)  # enabled for default user too
     config.add_route(
         name='edit_user_ips_delete',
         pattern='/users/{user_id:\d+}/edit/ips/delete',
         user_route_with_default=True) # enabled for default user too
 
     # user perms
     config.add_route(
         name='edit_user_perms_summary',
         pattern='/users/{user_id:\d+}/edit/permissions_summary',
         user_route=True)
     config.add_route(
         name='edit_user_perms_summary_json',
         pattern='/users/{user_id:\d+}/edit/permissions_summary/json',
         user_route=True)
 
     # user user groups management
     config.add_route(
         name='edit_user_groups_management',
         pattern='/users/{user_id:\d+}/edit/groups_management',
         user_route=True)
 
     config.add_route(
         name='edit_user_groups_management_updates',
         pattern='/users/{user_id:\d+}/edit/edit_user_groups_management/updates',
         user_route=True)
 
     # user audit logs
     config.add_route(
         name='edit_user_audit_logs',
         pattern='/users/{user_id:\d+}/edit/audit', user_route=True)
 
     # user-groups admin
     config.add_route(
         name='user_groups',
         pattern='/user_groups')
 
     config.add_route(
         name='user_groups_data',
         pattern='/user_groups_data')
 
     config.add_route(
         name='user_groups_new',
         pattern='/user_groups/new')
 
     config.add_route(
         name='user_groups_create',
         pattern='/user_groups/create')
 
     # repos admin
     config.add_route(
         name='repos',
         pattern='/repos')
 
     config.add_route(
         name='repo_new',
         pattern='/repos/new')
 
     config.add_route(
         name='repo_create',
         pattern='/repos/create')
 
     # repo groups admin
     config.add_route(
         name='repo_groups',
         pattern='/repo_groups')
 
     config.add_route(
         name='repo_group_new',
         pattern='/repo_group/new')
 
     config.add_route(
         name='repo_group_create',
         pattern='/repo_group/create')
 
 
 def includeme(config):
     from rhodecode.apps.admin.navigation import includeme as nav_includeme
 
     # Create admin navigation registry and add it to the pyramid registry.
     nav_includeme(config)
 
     # main admin routes
     config.add_route(name='admin_home', pattern=ADMIN_PREFIX)
     config.include(admin_routes, route_prefix=ADMIN_PREFIX)
 
     # Scan module for configuration decorators.
     config.scan('.views', ignore='.tests')

rhodecode/apps/admin/navigation.py

@@ -1,148 +1,136 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import logging
 import collections
 
 from zope.interface import implementer
 
 from rhodecode.apps.admin.interfaces import IAdminNavigationRegistry
 from rhodecode.lib.utils import get_registry
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 NavListEntry = collections.namedtuple('NavListEntry', ['key', 'name', 'url'])
 
 
 class NavEntry(object):
     """
     Represents an entry in the admin navigation.
 
     :param key: Unique identifier used to store reference in an OrderedDict.
     :param name: Display name, usually a translation string.
     :param view_name: Name of the view, used generate the URL.
     :param pyramid: Indicator to use pyramid for URL generation. This should
         be removed as soon as we are fully migrated to pyramid.
     """
 
-    def __init__(self, key, name, view_name, pyramid=False):
+    def __init__(self, key, name, view_name):
         self.key = key
         self.name = name
         self.view_name = view_name
-        self.pyramid = pyramid
 
     def generate_url(self, request):
-        if self.pyramid:
-            if hasattr(request, 'route_path'):
                 return request.route_path(self.view_name)
-            else:
-                # TODO: johbo: Remove this after migrating to pyramid.
-                # We need the pyramid request here to generate URLs to pyramid
-                # views from within pylons views.
-                from pyramid.threadlocal import get_current_request
-                pyramid_request = get_current_request()
-                return pyramid_request.route_path(self.view_name)
-        else:
-            from pylons import url
-            return url(self.view_name)
 
     def get_localized_name(self, request):
-        if hasattr(request, 'translate'):
             return request.translate(self.name)
-        else:
-            # TODO(marcink): Remove this after migrating to pyramid
-            from pyramid.threadlocal import get_current_request
-            pyramid_request = get_current_request()
-            return pyramid_request.translate(self.name)
 
 
 @implementer(IAdminNavigationRegistry)
 class NavigationRegistry(object):
 
     _base_entries = [
-        NavEntry('global', _('Global'), 'admin_settings_global'),
-        NavEntry('vcs', _('VCS'), 'admin_settings_vcs'),
-        NavEntry('visual', _('Visual'), 'admin_settings_visual'),
-        NavEntry('mapping', _('Remap and Rescan'), 'admin_settings_mapping'),
+        NavEntry('global', _('Global'),
+                 'admin_settings_global'),
+        NavEntry('vcs', _('VCS'),
+                 'admin_settings_vcs'),
+        NavEntry('visual', _('Visual'),
+                 'admin_settings_visual'),
+        NavEntry('mapping', _('Remap and Rescan'),
+                 'admin_settings_mapping'),
         NavEntry('issuetracker', _('Issue Tracker'),
                  'admin_settings_issuetracker'),
-        NavEntry('email', _('Email'), 'admin_settings_email'),
-        NavEntry('hooks', _('Hooks'), 'admin_settings_hooks'),
-        NavEntry('search', _('Full Text Search'), 'admin_settings_search'),
-
+        NavEntry('email', _('Email'),
+                 'admin_settings_email'),
+        NavEntry('hooks', _('Hooks'),
+                 'admin_settings_hooks'),
+        NavEntry('search', _('Full Text Search'),
+                 'admin_settings_search'),
         NavEntry('integrations', _('Integrations'),
-                 'global_integrations_home', pyramid=True),
+                 'global_integrations_home'),
         NavEntry('system', _('System Info'),
-                 'admin_settings_system', pyramid=True),
+                 'admin_settings_system'),
         NavEntry('process_management', _('Processes'),
-                 'admin_settings_process_management', pyramid=True),
+                 'admin_settings_process_management'),
         NavEntry('sessions', _('User Sessions'),
-                 'admin_settings_sessions', pyramid=True),
+                 'admin_settings_sessions'),
         NavEntry('open_source', _('Open Source Licenses'),
-                 'admin_settings_open_source', pyramid=True),
+                 'admin_settings_open_source'),
 
     ]
 
-    _labs_entry = NavEntry('labs', _('Labs'), 'admin_settings_labs')
+    _labs_entry = NavEntry('labs', _('Labs'),
+                           'admin_settings_labs')
 
     def __init__(self, labs_active=False):
         self._registered_entries = collections.OrderedDict()
         for item in self.__class__._base_entries:
             self._registered_entries[item.key] = item
 
         if labs_active:
             self.add_entry(self._labs_entry)
 
     def add_entry(self, entry):
         self._registered_entries[entry.key] = entry
 
     def get_navlist(self, request):
         navlist = [NavListEntry(i.key, i.get_localized_name(request),
                                 i.generate_url(request))
                    for i in self._registered_entries.values()]
         return navlist
 
 
 def navigation_registry(request, registry=None):
     """
     Helper that returns the admin navigation registry.
     """
     pyramid_registry = registry or get_registry(request)
     nav_registry = pyramid_registry.queryUtility(IAdminNavigationRegistry)
     return nav_registry
 
 
 def navigation_list(request):
     """
     Helper that returns the admin navigation as list of NavListEntry objects.
     """
     return navigation_registry(request).get_navlist(request)
 
 
 def includeme(config):
     # Create admin navigation registry and add it to the pyramid registry.
     settings = config.get_settings()
     labs_active = str2bool(settings.get('labs_settings_active', False))
     navigation_registry = NavigationRegistry(labs_active=labs_active)
     config.registry.registerUtility(navigation_registry)
  No newline at end of file

rhodecode/apps/admin/tests/test_admin_settings.py

@@ -1,670 +1,730 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 import rhodecode
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib.utils2 import md5
 from rhodecode.model.db import RhodeCodeUi
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
-from rhodecode.tests import url, assert_session_flash
+from rhodecode.tests import assert_session_flash
 from rhodecode.tests.utils import AssertResponse
 
 
 UPDATE_DATA_QUALNAME = (
     'rhodecode.apps.admin.views.system_info.AdminSystemInfoSettingsView.get_update_data')
 
 
+def route_path(name, params=None, **kwargs):
+    import urllib
+    from rhodecode.apps._base import ADMIN_PREFIX
+
+    base_url = {
+
+        'admin_settings':
+            ADMIN_PREFIX +'/settings',
+        'admin_settings_update':
+            ADMIN_PREFIX + '/settings/update',
+        'admin_settings_global':
+            ADMIN_PREFIX + '/settings/global',
+        'admin_settings_global_update':
+            ADMIN_PREFIX + '/settings/global/update',
+        'admin_settings_vcs':
+            ADMIN_PREFIX + '/settings/vcs',
+        'admin_settings_vcs_update':
+            ADMIN_PREFIX + '/settings/vcs/update',
+        'admin_settings_vcs_svn_pattern_delete':
+            ADMIN_PREFIX + '/settings/vcs/svn_pattern_delete',
+        'admin_settings_mapping':
+            ADMIN_PREFIX + '/settings/mapping',
+        'admin_settings_mapping_update':
+            ADMIN_PREFIX + '/settings/mapping/update',
+        'admin_settings_visual':
+            ADMIN_PREFIX + '/settings/visual',
+        'admin_settings_visual_update':
+            ADMIN_PREFIX + '/settings/visual/update',
+        'admin_settings_issuetracker':
+            ADMIN_PREFIX + '/settings/issue-tracker',
+        'admin_settings_issuetracker_update':
+            ADMIN_PREFIX + '/settings/issue-tracker/update',
+        'admin_settings_issuetracker_test':
+            ADMIN_PREFIX + '/settings/issue-tracker/test',
+        'admin_settings_issuetracker_delete':
+            ADMIN_PREFIX + '/settings/issue-tracker/delete',
+        'admin_settings_email':
+            ADMIN_PREFIX + '/settings/email',
+        'admin_settings_email_update':
+            ADMIN_PREFIX + '/settings/email/update',
+        'admin_settings_hooks':
+            ADMIN_PREFIX + '/settings/hooks',
+        'admin_settings_hooks_update':
+            ADMIN_PREFIX + '/settings/hooks/update',
+        'admin_settings_hooks_delete':
+            ADMIN_PREFIX + '/settings/hooks/delete',
+        'admin_settings_search':
+            ADMIN_PREFIX + '/settings/search',
+        'admin_settings_labs':
+            ADMIN_PREFIX + '/settings/labs',
+        'admin_settings_labs_update':
+            ADMIN_PREFIX + '/settings/labs/update',
+
+        'admin_settings_sessions':
+            ADMIN_PREFIX + '/settings/sessions',
+        'admin_settings_sessions_cleanup':
+            ADMIN_PREFIX + '/settings/sessions/cleanup',
+        'admin_settings_system':
+            ADMIN_PREFIX + '/settings/system',
+        'admin_settings_system_update':
+            ADMIN_PREFIX + '/settings/system/updates',
+        'admin_settings_open_source':
+            ADMIN_PREFIX + '/settings/open_source',
+
+
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsController(object):
 
     @pytest.mark.parametrize('urlname', [
         'admin_settings_vcs',
         'admin_settings_mapping',
         'admin_settings_global',
         'admin_settings_visual',
         'admin_settings_email',
         'admin_settings_hooks',
         'admin_settings_search',
     ])
-    def test_simple_get(self, urlname, app):
-        app.get(url(urlname))
+    def test_simple_get(self, urlname):
+        self.app.get(route_path(urlname))
 
     def test_create_custom_hook(self, csrf_token):
         response = self.app.post(
-            url('admin_settings_hooks'),
+            route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_1',
                 'new_hook_ui_value': 'cd /tmp',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_1')
         response.mustcontain('cd /tmp')
 
     def test_create_custom_hook_delete(self, csrf_token):
         response = self.app.post(
-            url('admin_settings_hooks'),
+            route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_2',
                 'new_hook_ui_value': 'cd /tmp2',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_2')
         response.mustcontain('cd /tmp2')
 
         hook_id = SettingsModel().get_ui_by_key('test_hooks_2').ui_id
 
         # delete
         self.app.post(
-            url('admin_settings_hooks'),
+            route_path('admin_settings_hooks_delete'),
             params={'hook_id': hook_id, 'csrf_token': csrf_token})
-        response = self.app.get(url('admin_settings_hooks'))
+        response = self.app.get(route_path('admin_settings_hooks'))
         response.mustcontain(no=['test_hooks_2'])
         response.mustcontain(no=['cd /tmp2'])
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsGlobal(object):
 
     def test_pre_post_code_code_active(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
 
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': pre_code,
             'rhodecode_post_code': post_code,
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(pre_code, post_code)
 
     def test_pre_post_code_code_inactive(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(no=[pre_code, post_code])
 
     def test_captcha_activate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '1234567890',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain('captcha')
 
     def test_captcha_deactivate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain(no=['captcha'])
 
     def test_title_change(self, csrf_token):
         old_title = 'RhodeCode'
-        new_title = old_title + '_changed'
 
         for new_title in ['Changed', 'Żółwik', old_title]:
             response = self.post_and_verify_settings({
                 'rhodecode_title': new_title,
                 'csrf_token': csrf_token,
             })
 
             response = response.follow()
             response.mustcontain(
                 """<div class="branding">- %s</div>""" % new_title)
 
     def post_and_verify_settings(self, settings):
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         params = {
             'rhodecode_title': old_title,
             'rhodecode_realm': old_realm,
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '',
             'rhodecode_create_personal_repo_group': False,
             'rhodecode_personal_repo_group_pattern': '${username}',
         }
         params.update(settings)
-        response = self.app.post(url('admin_settings_global'), params=params)
+        response = self.app.post(
+            route_path('admin_settings_global_update'), params=params)
 
         assert_session_flash(response, 'Updated application settings')
         app_settings = SettingsModel().get_all_settings()
         del settings['csrf_token']
         for key, value in settings.iteritems():
             assert app_settings[key] == value.decode('utf-8')
 
         return response
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsVcs(object):
 
-    def test_contains_svn_default_patterns(self, app):
-        response = app.get(url('admin_settings_vcs'))
+    def test_contains_svn_default_patterns(self):
+        response = self.app.get(route_path('admin_settings_vcs'))
         expected_patterns = [
             '/trunk',
             '/branches/*',
             '/tags/*',
         ]
         for pattern in expected_patterns:
             response.mustcontain(pattern)
 
     def test_add_new_svn_branch_and_tag_pattern(
-            self, app, backend_svn, form_defaults, disable_sql_cache,
+            self, backend_svn, form_defaults, disable_sql_cache,
             csrf_token):
         form_defaults.update({
             'new_svn_branch': '/exp/branches/*',
             'new_svn_tag': '/important_tags/*',
             'csrf_token': csrf_token,
         })
 
-        response = app.post(
-            url('admin_settings_vcs'), params=form_defaults, status=302)
+        response = self.app.post(
+            route_path('admin_settings_vcs_update'),
+            params=form_defaults, status=302)
         response = response.follow()
 
         # Expect to find the new values on the page
         response.mustcontain('/exp/branches/*')
         response.mustcontain('/important_tags/*')
 
         # Expect that those patterns are used to match branches and tags now
         repo = backend_svn['svn-simple-layout'].scm_instance()
         assert 'exp/branches/exp-sphinx-docs' in repo.branches
         assert 'important_tags/v0.5' in repo.tags
 
     def test_add_same_svn_value_twice_shows_an_error_message(
-            self, app, form_defaults, csrf_token, settings_util):
+            self, form_defaults, csrf_token, settings_util):
         settings_util.create_rhodecode_ui('vcs_svn_branch', '/test')
         settings_util.create_rhodecode_ui('vcs_svn_tag', '/test')
 
-        response = app.post(
-            url('admin_settings_vcs'),
+        response = self.app.post(
+            route_path('admin_settings_vcs_update'),
             params={
                 'paths_root_path': form_defaults['paths_root_path'],
                 'new_svn_branch': '/test',
                 'new_svn_tag': '/test',
                 'csrf_token': csrf_token,
             },
             status=200)
 
         response.mustcontain("Pattern already exists")
         response.mustcontain("Some form inputs contain invalid data.")
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns(
-            self, section, app, csrf_token, settings_util):
+            self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(
             section, '/test_delete', cleanup=False)
 
-        app.post(
-            url('admin_settings_vcs'),
+        self.app.post(
+            route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
-                '_method': 'delete',
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest'})
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
-    def test_delete_svn_patterns_raises_400_when_no_xhr(
-            self, section, app, csrf_token, settings_util):
+    def test_delete_svn_patterns_raises_404_when_no_xhr(
+            self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(section, '/test_delete')
 
-        app.post(
-            url('admin_settings_vcs'),
+        self.app.post(
+            route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
-                '_method': 'delete',
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
-            status=400)
+            status=404)
 
-    def test_extensions_hgsubversion(self, app, form_defaults, csrf_token):
+    def test_extensions_hgsubversion(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_hgsubversion': 'True',
         })
-        response = app.post(
-            url('admin_settings_vcs'),
+        response = self.app.post(
+            route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_hgsubversion" '
             'name="extensions_hgsubversion" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
-    def test_extensions_hgevolve(self, app, form_defaults, csrf_token):
+    def test_extensions_hgevolve(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_evolve': 'True',
         })
-        response = app.post(
-            url('admin_settings_vcs'),
+        response = self.app.post(
+            route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_evolve" '
             'name="extensions_evolve" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
-    def test_has_a_section_for_pull_request_settings(self, app):
-        response = app.get(url('admin_settings_vcs'))
+    def test_has_a_section_for_pull_request_settings(self):
+        response = self.app.get(route_path('admin_settings_vcs'))
         response.mustcontain('Pull Request Settings')
 
-    def test_has_an_input_for_invalidation_of_inline_comments(
-            self, app):
-        response = app.get(url('admin_settings_vcs'))
+    def test_has_an_input_for_invalidation_of_inline_comments(self):
+        response = self.app.get(route_path('admin_settings_vcs'))
         assert_response = AssertResponse(response)
         assert_response.one_element_exists(
             '[name=rhodecode_use_outdated_comments]')
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_invalidation_of_inline_comments(
-            self, app, form_defaults, csrf_token, new_value):
+            self, form_defaults, csrf_token, new_value):
         setting_key = 'use_outdated_comments'
         setting = SettingsModel().create_or_update_setting(
             setting_key, not new_value, 'bool')
         Session().add(setting)
         Session().commit()
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_use_outdated_comments': str(new_value),
         })
-        response = app.post(
-            url('admin_settings_vcs'),
+        response = self.app.post(
+            route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
         response = response.follow()
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_hg_rebase_merge_strategy(
-            self, app, form_defaults, csrf_token, new_value):
+            self, form_defaults, csrf_token, new_value):
         setting_key = 'hg_use_rebase_for_merging'
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_' + setting_key: str(new_value),
         })
 
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'true'}):
-            app.post(
-                url('admin_settings_vcs'),
+            self.app.post(
+                route_path('admin_settings_vcs_update'),
                 params=form_defaults,
                 status=302)
 
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.fixture
     def disable_sql_cache(self, request):
         patcher = mock.patch(
             'rhodecode.lib.caching_query.FromCache.process_query')
         request.addfinalizer(patcher.stop)
         patcher.start()
 
     @pytest.fixture
     def form_defaults(self):
-        from rhodecode.controllers.admin.settings import SettingsController
-        controller = SettingsController()
-        return controller._form_defaults()
+        from rhodecode.apps.admin.views.settings import AdminSettingsView
+        return AdminSettingsView._form_defaults()
 
     # TODO: johbo: What we really want is to checkpoint before a test run and
     # reset the session afterwards.
     @pytest.fixture(scope='class', autouse=True)
     def cleanup_settings(self, request, pylonsapp):
         ui_id = RhodeCodeUi.ui_id
         original_ids = list(
             r.ui_id for r in RhodeCodeUi.query().values(ui_id))
 
         @request.addfinalizer
         def cleanup():
             RhodeCodeUi.query().filter(
                 ui_id.notin_(original_ids)).delete(False)
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestLabsSettings(object):
     def test_get_settings_page_disabled(self):
-        with mock.patch.dict(rhodecode.CONFIG,
-                             {'labs_settings_active': 'false'}):
-            response = self.app.get(url('admin_settings_labs'), status=302)
+        with mock.patch.dict(
+                rhodecode.CONFIG, {'labs_settings_active': 'false'}):
 
-        assert response.location.endswith(url('admin_settings'))
+            response = self.app.get(
+                route_path('admin_settings_labs'), status=302)
+
+        assert response.location.endswith(route_path('admin_settings'))
 
     def test_get_settings_page_enabled(self):
-        from rhodecode.controllers.admin import settings
+        from rhodecode.apps.admin.views import settings
         lab_settings = [
             settings.LabSetting(
                 key='rhodecode_bool',
                 type='bool',
                 group='bool group',
                 label='bool label',
                 help='bool help'
             ),
             settings.LabSetting(
                 key='rhodecode_text',
                 type='unicode',
                 group='text group',
                 label='text label',
                 help='text help'
             ),
         ]
         with mock.patch.dict(rhodecode.CONFIG,
                              {'labs_settings_active': 'true'}):
             with mock.patch.object(settings, '_LAB_SETTINGS', lab_settings):
-                response = self.app.get(url('admin_settings_labs'))
+                response = self.app.get(route_path('admin_settings_labs'))
 
         assert '<label>bool group:</label>' in response
         assert '<label for="rhodecode_bool">bool label</label>' in response
         assert '<p class="help-block">bool help</p>' in response
         assert 'name="rhodecode_bool" type="checkbox"' in response
 
         assert '<label>text group:</label>' in response
         assert '<label for="rhodecode_text">text label</label>' in response
         assert '<p class="help-block">text help</p>' in response
         assert 'name="rhodecode_text" size="60" type="text"' in response
 
 
 @pytest.mark.usefixtures('app')
 class TestOpenSourceLicenses(object):
 
-    def _get_url(self):
-        return ADMIN_PREFIX + '/settings/open_source'
-
     def test_records_are_displayed(self, autologin_user):
         sample_licenses = {
             "python2.7-pytest-2.7.1": {
                 "UNKNOWN": None
             },
             "python2.7-Markdown-2.6.2": {
                 "BSD-3-Clause": "http://spdx.org/licenses/BSD-3-Clause"
             }
         }
         read_licenses_patch = mock.patch(
             'rhodecode.apps.admin.views.open_source_licenses.read_opensource_licenses',
             return_value=sample_licenses)
         with read_licenses_patch:
-            response = self.app.get(self._get_url(), status=200)
+            response = self.app.get(
+                route_path('admin_settings_open_source'), status=200)
 
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
         for name in sample_licenses:
             response.mustcontain(name)
             for license in sample_licenses[name]:
                 assert_response.element_contains('.panel-body', license)
 
     def test_records_can_be_read(self, autologin_user):
-        response = self.app.get(self._get_url(), status=200)
+        response = self.app.get(
+            route_path('admin_settings_open_source'), status=200)
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
-        self.app.get(self._get_url(), status=404)
+        self.app.get(
+            route_path('admin_settings_open_source'), status=404)
 
 
 @pytest.mark.usefixtures('app')
 class TestUserSessions(object):
 
-    def _get_url(self, name='admin_settings_sessions'):
-        return {
-            'admin_settings_sessions': ADMIN_PREFIX + '/settings/sessions',
-            'admin_settings_sessions_cleanup': ADMIN_PREFIX + '/settings/sessions/cleanup'
-        }[name]
-
     def test_forbidden_when_normal_user(self, autologin_regular_user):
-        self.app.get(self._get_url(), status=404)
+        self.app.get(route_path('admin_settings_sessions'), status=404)
 
     def test_show_sessions_page(self, autologin_user):
-        response = self.app.get(self._get_url(), status=200)
+        response = self.app.get(route_path('admin_settings_sessions'), status=200)
         response.mustcontain('file')
 
     def test_cleanup_old_sessions(self, autologin_user, csrf_token):
 
         post_data = {
             'csrf_token': csrf_token,
             'expire_days': '60'
         }
         response = self.app.post(
-            self._get_url('admin_settings_sessions_cleanup'), params=post_data,
+            route_path('admin_settings_sessions_cleanup'), params=post_data,
             status=302)
         assert_session_flash(response, 'Cleaned up old sessions')
 
 
 @pytest.mark.usefixtures('app')
 class TestAdminSystemInfo(object):
-    def _get_url(self, name='admin_settings_system'):
-        return {
-            'admin_settings_system': ADMIN_PREFIX + '/settings/system',
-            'admin_settings_system_update': ADMIN_PREFIX + '/settings/system/updates',
-        }[name]
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
-        self.app.get(self._get_url(), status=404)
+        self.app.get(route_path('admin_settings_system'), status=404)
 
     def test_system_info_page(self, autologin_user):
-        response = self.app.get(self._get_url())
+        response = self.app.get(route_path('admin_settings_system'))
         response.mustcontain('RhodeCode Community Edition, version {}'.format(
             rhodecode.__version__))
 
     def test_system_update_new_version(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '100.3.1415926535',
                     'general': 'The latest version we are ever going to ship'
                 },
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
-            response = self.app.get(self._get_url('admin_settings_system_update'))
+            response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain('A <b>new version</b> is available')
 
     def test_system_update_nothing_new(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
-            response = self.app.get(self._get_url('admin_settings_system_update'))
+            response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'You already have the <b>latest</b> stable version.')
 
     def test_system_update_bad_response(self, autologin_user):
         with mock.patch(UPDATE_DATA_QUALNAME, side_effect=ValueError('foo')):
-            response = self.app.get(self._get_url('admin_settings_system_update'))
+            response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'Bad data sent from update server')
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminSettingsIssueTracker(object):
     RC_PREFIX = 'rhodecode_'
     SHORT_PATTERN_KEY = 'issuetracker_pat_'
     PATTERN_KEY = RC_PREFIX + SHORT_PATTERN_KEY
 
     def test_issuetracker_index(self, autologin_user):
-        response = self.app.get(url('admin_settings_issuetracker'))
+        response = self.app.get(route_path('admin_settings_issuetracker'))
         assert response.status_code == 200
 
     def test_add_empty_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
-        post_url = url('admin_settings_issuetracker_save')
+        post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
     def test_add_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
-        post_url = url('admin_settings_issuetracker_save')
+        post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': 'url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         self.uid = md5(pattern)
         assert settings[self.PATTERN_KEY+self.uid] == pattern
         self.another_uid = md5(another_pattern)
         assert settings[self.PATTERN_KEY+self.another_uid] == another_pattern
 
         @request.addfinalizer
         def cleanup():
             defaults = SettingsModel().get_all_settings()
 
             entries = [name for name in defaults if (
                 (self.uid in name) or (self.another_uid) in name)]
             start = len(self.RC_PREFIX)
             for del_key in entries:
                 # TODO: anderson: get_by_name needs name without prefix
                 entry = SettingsModel().get_setting_by_name(del_key[start:])
                 Session().delete(entry)
 
             Session().commit()
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         old_pattern = 'issuetracker_pat'
         old_uid = md5(old_pattern)
         pattern = 'issuetracker_pat_new'
         self.new_uid = md5(pattern)
 
         SettingsModel().create_or_update_setting(
             self.SHORT_PATTERN_KEY+old_uid, old_pattern, 'unicode')
 
-        post_url = url('admin_settings_issuetracker_save')
+        post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[self.PATTERN_KEY+self.new_uid] == pattern
         assert self.PATTERN_KEY+old_uid not in settings
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.new_uid)
 
     def test_replace_issuetracker_pattern_description(
             self, autologin_user, csrf_token, request, settings_util):
         prefix = 'issuetracker'
         pattern = 'issuetracker_pat'
         self.uid = md5(pattern)
         pattern_key = '_'.join([prefix, 'pat', self.uid])
         rc_pattern_key = '_'.join(['rhodecode', pattern_key])
         desc_key = '_'.join([prefix, 'desc', self.uid])
         rc_desc_key = '_'.join(['rhodecode', desc_key])
         new_description = 'new_description'
 
         settings_util.create_rhodecode_setting(
             pattern_key, pattern, 'unicode', cleanup=False)
         settings_util.create_rhodecode_setting(
             desc_key, 'old description', 'unicode', cleanup=False)
 
-        post_url = url('admin_settings_issuetracker_save')
+        post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': new_description,
             'uid': self.uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[rc_pattern_key] == pattern
         assert settings[rc_desc_key] == new_description
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, settings_util):
         pattern = 'issuetracker_pat'
         uid = md5(pattern)
         settings_util.create_rhodecode_setting(
             self.SHORT_PATTERN_KEY+uid, pattern, 'unicode', cleanup=False)
 
-        post_url = url('admin_issuetracker_delete')
+        post_url = route_path('admin_settings_issuetracker_delete')
         post_data = {
             '_method': 'delete',
             'uid': uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert 'rhodecode_%s%s' % (self.SHORT_PATTERN_KEY, uid) not in settings

rhodecode/config/routing.py

@@ -1,259 +1,184 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Routes configuration
 
 The more specific and detailed routes should be defined first so they
 may take precedent over the more generic routes. For more information
 refer to the routes manual at http://routes.groovie.org/docs/
 
 IMPORTANT: if you change any routing here, make sure to take a look at lib/base.py
 and _route_name variable which uses some of stored naming here to do redirects.
 """
 import os
 import re
 from routes import Mapper
 
 # prefix for non repository related links needs to be prefixed with `/`
 ADMIN_PREFIX = '/_admin'
 STATIC_FILE_PREFIX = '/_static'
 
 # Default requirements for URL parts
 URL_NAME_REQUIREMENTS = {
     # group name can have a slash in them, but they must not end with a slash
     'group_name': r'.*?[^/]',
     'repo_group_name': r'.*?[^/]',
     # repo names can have a slash in them, but they must not end with a slash
     'repo_name': r'.*?[^/]',
     # file path eats up everything at the end
     'f_path': r'.*',
     # reference types
     'source_ref_type': '(branch|book|tag|rev|\%\(source_ref_type\)s)',
     'target_ref_type': '(branch|book|tag|rev|\%\(target_ref_type\)s)',
 }
 
 
 class JSRoutesMapper(Mapper):
     """
     Wrapper for routes.Mapper to make pyroutes compatible url definitions
     """
     _named_route_regex = re.compile(r'^[a-z-_0-9A-Z]+$')
     _argument_prog = re.compile('\{(.*?)\}|:\((.*)\)')
     def __init__(self, *args, **kw):
         super(JSRoutesMapper, self).__init__(*args, **kw)
         self._jsroutes = []
 
     def connect(self, *args, **kw):
         """
         Wrapper for connect to take an extra argument jsroute=True
 
         :param jsroute: boolean, if True will add the route to the pyroutes list
         """
         if kw.pop('jsroute', False):
             if not self._named_route_regex.match(args[0]):
                 raise Exception('only named routes can be added to pyroutes')
             self._jsroutes.append(args[0])
 
         super(JSRoutesMapper, self).connect(*args, **kw)
 
     def _extract_route_information(self, route):
         """
         Convert a route into tuple(name, path, args), eg:
             ('show_user', '/profile/%(username)s', ['username'])
         """
         routepath = route.routepath
         def replace(matchobj):
             if matchobj.group(1):
                 return "%%(%s)s" % matchobj.group(1).split(':')[0]
             else:
                 return "%%(%s)s" % matchobj.group(2)
 
         routepath = self._argument_prog.sub(replace, routepath)
         return (
             route.name,
             routepath,
             [(arg[0].split(':')[0] if arg[0] != '' else arg[1])
               for arg in self._argument_prog.findall(route.routepath)]
         )
 
     def jsroutes(self):
         """
         Return a list of pyroutes.js compatible routes
         """
         for route_name in self._jsroutes:
             yield self._extract_route_information(self._routenames[route_name])
 
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
     rmap = JSRoutesMapper(
         directory=config['pylons.paths']['controllers'],
         always_scan=config['debug'])
     rmap.minimization = False
     rmap.explicit = False
 
     from rhodecode.lib.utils2 import str2bool
     from rhodecode.model import repo, repo_group
 
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         repo_name = match_dict.get('repo_name')
 
         if match_dict.get('f_path'):
             # fix for multiple initial slashes that causes errors
             match_dict['f_path'] = match_dict['f_path'].lstrip('/')
         repo_model = repo.RepoModel()
         by_name_match = repo_model.get_by_repo_name(repo_name)
         # if we match quickly from database, short circuit the operation,
         # and validate repo based on the type.
         if by_name_match:
             return True
 
         by_id_match = repo_model.get_repo_by_id(repo_name)
         if by_id_match:
             repo_name = by_id_match.repo_name
             match_dict['repo_name'] = repo_name
             return True
 
         return False
 
     def check_group(environ, match_dict):
         """
         check for valid repository group path for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         repo_group_name = match_dict.get('group_name')
         repo_group_model = repo_group.RepoGroupModel()
         by_name_match = repo_group_model.get_by_group_name(repo_group_name)
         if by_name_match:
             return True
 
         return False
 
     def check_user_group(environ, match_dict):
         """
         check for valid user group for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         return True
 
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
 
 
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
 
-    # ADMIN SETTINGS ROUTES
-    with rmap.submapper(path_prefix=ADMIN_PREFIX,
-                        controller='admin/settings') as m:
-
-        # default
-        m.connect('admin_settings', '/settings',
-                  action='settings_global_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings', '/settings',
-                  action='settings_global', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_vcs', '/settings/vcs',
-                  action='settings_vcs_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_vcs', '/settings/vcs',
-                  action='settings_vcs',
-                  conditions={'method': ['GET']})
-        m.connect('admin_settings_vcs', '/settings/vcs',
-                  action='delete_svn_pattern',
-                  conditions={'method': ['DELETE']})
-
-        m.connect('admin_settings_mapping', '/settings/mapping',
-                  action='settings_mapping_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_mapping', '/settings/mapping',
-                  action='settings_mapping', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_global', '/settings/global',
-                  action='settings_global_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_global', '/settings/global',
-                  action='settings_global', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_visual', '/settings/visual',
-                  action='settings_visual_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_visual', '/settings/visual',
-                  action='settings_visual', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_issuetracker',
-                  '/settings/issue-tracker', action='settings_issuetracker',
-                  conditions={'method': ['GET']})
-        m.connect('admin_settings_issuetracker_save',
-                  '/settings/issue-tracker/save',
-                  action='settings_issuetracker_save',
-                  conditions={'method': ['POST']})
-        m.connect('admin_issuetracker_test', '/settings/issue-tracker/test',
-                  action='settings_issuetracker_test',
-                  conditions={'method': ['POST']})
-        m.connect('admin_issuetracker_delete',
-                  '/settings/issue-tracker/delete',
-                  action='settings_issuetracker_delete',
-                  conditions={'method': ['DELETE']})
-
-        m.connect('admin_settings_email', '/settings/email',
-                  action='settings_email_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_email', '/settings/email',
-                  action='settings_email', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_hooks', '/settings/hooks',
-                  action='settings_hooks_update',
-                  conditions={'method': ['POST', 'DELETE']})
-        m.connect('admin_settings_hooks', '/settings/hooks',
-                  action='settings_hooks', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_search', '/settings/search',
-                  action='settings_search', conditions={'method': ['GET']})
-
-        m.connect('admin_settings_labs', '/settings/labs',
-                  action='settings_labs_update',
-                  conditions={'method': ['POST']})
-        m.connect('admin_settings_labs', '/settings/labs',
-                  action='settings_labs', conditions={'method': ['GET']})
-
     # ADMIN MY ACCOUNT
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/my_account') as m:
 
         # NOTE(marcink): this needs to be kept for password force flag to be
         # handled in pylons controllers, remove after full migration to pyramid
         m.connect('my_account_password', '/my_account/password',
                   action='my_account_password', conditions={'method': ['GET']})
 
     return rmap

rhodecode/public/js/rhodecode/routes.js

@@ -1,293 +1,316 b''
 
 /******************************************************************************
  *                                                                            *
  *                      DO NOT CHANGE THIS FILE MANUALLY                      *
  *                                                                            *
  *                                                                            *
  *        This file is automatically generated when the app starts up with    *
  *                         generate_js_files = true                           *
  *                                                                            *
  *  To add a route here pass jsroute=True to the route definition in the app  *
  *                                                                            *
  ******************************************************************************/
 function registerRCRoutes() {
     // routes registration
     pyroutes.register('favicon', '/favicon.ico', []);
     pyroutes.register('robots', '/robots.txt', []);
     pyroutes.register('auth_home', '/_admin/auth*traverse', []);
     pyroutes.register('global_integrations_new', '/_admin/integrations/new', []);
     pyroutes.register('global_integrations_home', '/_admin/integrations', []);
     pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']);
     pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']);
     pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']);
     pyroutes.register('repo_group_integrations_home', '/%(repo_group_name)s/_settings/integrations', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_new', '/%(repo_group_name)s/_settings/integrations/new', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_list', '/%(repo_group_name)s/_settings/integrations/%(integration)s', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_create', '/%(repo_group_name)s/_settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_edit', '/%(repo_group_name)s/_settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']);
     pyroutes.register('repo_integrations_home', '/%(repo_name)s/settings/integrations', ['repo_name']);
     pyroutes.register('repo_integrations_new', '/%(repo_name)s/settings/integrations/new', ['repo_name']);
     pyroutes.register('repo_integrations_list', '/%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_create', '/%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_edit', '/%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']);
     pyroutes.register('ops_ping', '/_admin/ops/ping', []);
     pyroutes.register('ops_error_test', '/_admin/ops/error', []);
     pyroutes.register('ops_redirect_test', '/_admin/ops/redirect', []);
     pyroutes.register('ops_ping_legacy', '/_admin/ping', []);
     pyroutes.register('ops_error_test_legacy', '/_admin/error_test', []);
     pyroutes.register('admin_home', '/_admin', []);
     pyroutes.register('admin_audit_logs', '/_admin/audit_logs', []);
     pyroutes.register('admin_audit_log_entry', '/_admin/audit_logs/%(audit_log_id)s', ['audit_log_id']);
     pyroutes.register('pull_requests_global_0', '/_admin/pull_requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global_1', '/_admin/pull-requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global', '/_admin/pull-request/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('admin_settings_open_source', '/_admin/settings/open_source', []);
     pyroutes.register('admin_settings_vcs_svn_generate_cfg', '/_admin/settings/vcs/svn_generate_cfg', []);
     pyroutes.register('admin_settings_system', '/_admin/settings/system', []);
     pyroutes.register('admin_settings_system_update', '/_admin/settings/system/updates', []);
     pyroutes.register('admin_settings_sessions', '/_admin/settings/sessions', []);
     pyroutes.register('admin_settings_sessions_cleanup', '/_admin/settings/sessions/cleanup', []);
     pyroutes.register('admin_settings_process_management', '/_admin/settings/process_management', []);
     pyroutes.register('admin_settings_process_management_signal', '/_admin/settings/process_management/signal', []);
     pyroutes.register('admin_defaults_repositories', '/_admin/defaults/repositories', []);
     pyroutes.register('admin_defaults_repositories_update', '/_admin/defaults/repositories/update', []);
+    pyroutes.register('admin_settings', '/_admin/settings', []);
+    pyroutes.register('admin_settings_update', '/_admin/settings/update', []);
+    pyroutes.register('admin_settings_global', '/_admin/settings/global', []);
+    pyroutes.register('admin_settings_global_update', '/_admin/settings/global/update', []);
+    pyroutes.register('admin_settings_vcs', '/_admin/settings/vcs', []);
+    pyroutes.register('admin_settings_vcs_update', '/_admin/settings/vcs/update', []);
+    pyroutes.register('admin_settings_vcs_svn_pattern_delete', '/_admin/settings/vcs/svn_pattern_delete', []);
+    pyroutes.register('admin_settings_mapping', '/_admin/settings/mapping', []);
+    pyroutes.register('admin_settings_mapping_update', '/_admin/settings/mapping/update', []);
+    pyroutes.register('admin_settings_visual', '/_admin/settings/visual', []);
+    pyroutes.register('admin_settings_visual_update', '/_admin/settings/visual/update', []);
+    pyroutes.register('admin_settings_issuetracker', '/_admin/settings/issue-tracker', []);
+    pyroutes.register('admin_settings_issuetracker_update', '/_admin/settings/issue-tracker/update', []);
+    pyroutes.register('admin_settings_issuetracker_test', '/_admin/settings/issue-tracker/test', []);
+    pyroutes.register('admin_settings_issuetracker_delete', '/_admin/settings/issue-tracker/delete', []);
+    pyroutes.register('admin_settings_email', '/_admin/settings/email', []);
+    pyroutes.register('admin_settings_email_update', '/_admin/settings/email/update', []);
+    pyroutes.register('admin_settings_hooks', '/_admin/settings/hooks', []);
+    pyroutes.register('admin_settings_hooks_update', '/_admin/settings/hooks/update', []);
+    pyroutes.register('admin_settings_hooks_delete', '/_admin/settings/hooks/delete', []);
+    pyroutes.register('admin_settings_search', '/_admin/settings/search', []);
+    pyroutes.register('admin_settings_labs', '/_admin/settings/labs', []);
+    pyroutes.register('admin_settings_labs_update', '/_admin/settings/labs/update', []);
     pyroutes.register('admin_permissions_application', '/_admin/permissions/application', []);
     pyroutes.register('admin_permissions_application_update', '/_admin/permissions/application/update', []);
     pyroutes.register('admin_permissions_global', '/_admin/permissions/global', []);
     pyroutes.register('admin_permissions_global_update', '/_admin/permissions/global/update', []);
     pyroutes.register('admin_permissions_object', '/_admin/permissions/object', []);
     pyroutes.register('admin_permissions_object_update', '/_admin/permissions/object/update', []);
     pyroutes.register('admin_permissions_ips', '/_admin/permissions/ips', []);
     pyroutes.register('admin_permissions_overview', '/_admin/permissions/overview', []);
     pyroutes.register('admin_permissions_auth_token_access', '/_admin/permissions/auth_token_access', []);
     pyroutes.register('admin_permissions_ssh_keys', '/_admin/permissions/ssh_keys', []);
     pyroutes.register('admin_permissions_ssh_keys_data', '/_admin/permissions/ssh_keys/data', []);
     pyroutes.register('admin_permissions_ssh_keys_update', '/_admin/permissions/ssh_keys/update', []);
     pyroutes.register('users', '/_admin/users', []);
     pyroutes.register('users_data', '/_admin/users_data', []);
     pyroutes.register('users_create', '/_admin/users/create', []);
     pyroutes.register('users_new', '/_admin/users/new', []);
     pyroutes.register('user_edit', '/_admin/users/%(user_id)s/edit', ['user_id']);
     pyroutes.register('user_edit_advanced', '/_admin/users/%(user_id)s/edit/advanced', ['user_id']);
     pyroutes.register('user_edit_global_perms', '/_admin/users/%(user_id)s/edit/global_permissions', ['user_id']);
     pyroutes.register('user_edit_global_perms_update', '/_admin/users/%(user_id)s/edit/global_permissions/update', ['user_id']);
     pyroutes.register('user_update', '/_admin/users/%(user_id)s/update', ['user_id']);
     pyroutes.register('user_delete', '/_admin/users/%(user_id)s/delete', ['user_id']);
     pyroutes.register('user_force_password_reset', '/_admin/users/%(user_id)s/password_reset', ['user_id']);
     pyroutes.register('user_create_personal_repo_group', '/_admin/users/%(user_id)s/create_repo_group', ['user_id']);
     pyroutes.register('edit_user_auth_tokens', '/_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_add', '/_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_delete', '/_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']);
     pyroutes.register('edit_user_ssh_keys', '/_admin/users/%(user_id)s/edit/ssh_keys', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_generate_keypair', '/_admin/users/%(user_id)s/edit/ssh_keys/generate', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_add', '/_admin/users/%(user_id)s/edit/ssh_keys/new', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_delete', '/_admin/users/%(user_id)s/edit/ssh_keys/delete', ['user_id']);
     pyroutes.register('edit_user_emails', '/_admin/users/%(user_id)s/edit/emails', ['user_id']);
     pyroutes.register('edit_user_emails_add', '/_admin/users/%(user_id)s/edit/emails/new', ['user_id']);
     pyroutes.register('edit_user_emails_delete', '/_admin/users/%(user_id)s/edit/emails/delete', ['user_id']);
     pyroutes.register('edit_user_ips', '/_admin/users/%(user_id)s/edit/ips', ['user_id']);
     pyroutes.register('edit_user_ips_add', '/_admin/users/%(user_id)s/edit/ips/new', ['user_id']);
     pyroutes.register('edit_user_ips_delete', '/_admin/users/%(user_id)s/edit/ips/delete', ['user_id']);
     pyroutes.register('edit_user_perms_summary', '/_admin/users/%(user_id)s/edit/permissions_summary', ['user_id']);
     pyroutes.register('edit_user_perms_summary_json', '/_admin/users/%(user_id)s/edit/permissions_summary/json', ['user_id']);
     pyroutes.register('edit_user_groups_management', '/_admin/users/%(user_id)s/edit/groups_management', ['user_id']);
     pyroutes.register('edit_user_groups_management_updates', '/_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']);
     pyroutes.register('edit_user_audit_logs', '/_admin/users/%(user_id)s/edit/audit', ['user_id']);
     pyroutes.register('user_groups', '/_admin/user_groups', []);
     pyroutes.register('user_groups_data', '/_admin/user_groups_data', []);
     pyroutes.register('user_groups_new', '/_admin/user_groups/new', []);
     pyroutes.register('user_groups_create', '/_admin/user_groups/create', []);
     pyroutes.register('repos', '/_admin/repos', []);
     pyroutes.register('repo_new', '/_admin/repos/new', []);
     pyroutes.register('repo_create', '/_admin/repos/create', []);
     pyroutes.register('repo_groups', '/_admin/repo_groups', []);
     pyroutes.register('repo_group_new', '/_admin/repo_group/new', []);
     pyroutes.register('repo_group_create', '/_admin/repo_group/create', []);
     pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []);
     pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []);
     pyroutes.register('channelstream_proxy', '/_channelstream', []);
     pyroutes.register('login', '/_admin/login', []);
     pyroutes.register('logout', '/_admin/logout', []);
     pyroutes.register('register', '/_admin/register', []);
     pyroutes.register('reset_password', '/_admin/password_reset', []);
     pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []);
     pyroutes.register('home', '/', []);
     pyroutes.register('user_autocomplete_data', '/_users', []);
     pyroutes.register('user_group_autocomplete_data', '/_user_groups', []);
     pyroutes.register('repo_list_data', '/_repos', []);
     pyroutes.register('goto_switcher_data', '/_goto_data', []);
     pyroutes.register('journal', '/_admin/journal', []);
     pyroutes.register('journal_rss', '/_admin/journal/rss', []);
     pyroutes.register('journal_atom', '/_admin/journal/atom', []);
     pyroutes.register('journal_public', '/_admin/public_journal', []);
     pyroutes.register('journal_public_atom', '/_admin/public_journal/atom', []);
     pyroutes.register('journal_public_atom_old', '/_admin/public_journal_atom', []);
     pyroutes.register('journal_public_rss', '/_admin/public_journal/rss', []);
     pyroutes.register('journal_public_rss_old', '/_admin/public_journal_rss', []);
     pyroutes.register('toggle_following', '/_admin/toggle_following', []);
     pyroutes.register('repo_creating', '/%(repo_name)s/repo_creating', ['repo_name']);
     pyroutes.register('repo_creating_check', '/%(repo_name)s/repo_creating_check', ['repo_name']);
     pyroutes.register('repo_summary_explicit', '/%(repo_name)s/summary', ['repo_name']);
     pyroutes.register('repo_summary_commits', '/%(repo_name)s/summary-commits', ['repo_name']);
     pyroutes.register('repo_commit', '/%(repo_name)s/changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_children', '/%(repo_name)s/changeset_children/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_parents', '/%(repo_name)s/changeset_parents/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_raw', '/%(repo_name)s/changeset-diff/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_patch', '/%(repo_name)s/changeset-patch/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_download', '/%(repo_name)s/changeset-download/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_data', '/%(repo_name)s/changeset-data/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_create', '/%(repo_name)s/changeset/%(commit_id)s/comment/create', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_preview', '/%(repo_name)s/changeset/%(commit_id)s/comment/preview', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_delete', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/delete', ['repo_name', 'commit_id', 'comment_id']);
     pyroutes.register('repo_commit_raw_deprecated', '/%(repo_name)s/raw-changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_archivefile', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']);
     pyroutes.register('repo_files_diff', '/%(repo_name)s/diff/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files_diff_2way_redirect', '/%(repo_name)s/diff-2way/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files', '/%(repo_name)s/files/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:default_path', '/%(repo_name)s/files/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_files:default_commit', '/%(repo_name)s/files', ['repo_name']);
     pyroutes.register('repo_files:rendered', '/%(repo_name)s/render/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated', '/%(repo_name)s/annotate/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated_previous', '/%(repo_name)s/annotate-previous/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_nodetree_full:default_path', '/%(repo_name)s/nodetree_full/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_files_nodelist', '/%(repo_name)s/nodelist/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_raw', '/%(repo_name)s/raw/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download', '/%(repo_name)s/download/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download:legacy', '/%(repo_name)s/rawfile/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_history', '/%(repo_name)s/history/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_authors', '/%(repo_name)s/authors/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_remove_file', '/%(repo_name)s/remove_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_delete_file', '/%(repo_name)s/delete_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_edit_file', '/%(repo_name)s/edit_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_update_file', '/%(repo_name)s/update_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_add_file', '/%(repo_name)s/add_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_create_file', '/%(repo_name)s/create_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']);
     pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']);
     pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_changelog', '/%(repo_name)s/changelog', ['repo_name']);
     pyroutes.register('repo_changelog_file', '/%(repo_name)s/changelog/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_changelog_elements', '/%(repo_name)s/changelog_elements', ['repo_name']);
     pyroutes.register('repo_changelog_elements_file', '/%(repo_name)s/changelog_elements/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_compare_select', '/%(repo_name)s/compare', ['repo_name']);
     pyroutes.register('repo_compare', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']);
     pyroutes.register('tags_home', '/%(repo_name)s/tags', ['repo_name']);
     pyroutes.register('branches_home', '/%(repo_name)s/branches', ['repo_name']);
     pyroutes.register('bookmarks_home', '/%(repo_name)s/bookmarks', ['repo_name']);
     pyroutes.register('repo_fork_new', '/%(repo_name)s/fork', ['repo_name']);
     pyroutes.register('repo_fork_create', '/%(repo_name)s/fork/create', ['repo_name']);
     pyroutes.register('repo_forks_show_all', '/%(repo_name)s/forks', ['repo_name']);
     pyroutes.register('repo_forks_data', '/%(repo_name)s/forks/data', ['repo_name']);
     pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']);
     pyroutes.register('pullrequest_show_all_data', '/%(repo_name)s/pull-request-data', ['repo_name']);
     pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']);
     pyroutes.register('pullrequest_repo_destinations', '/%(repo_name)s/pull-request/repo-destinations', ['repo_name']);
     pyroutes.register('pullrequest_new', '/%(repo_name)s/pull-request/new', ['repo_name']);
     pyroutes.register('pullrequest_create', '/%(repo_name)s/pull-request/create', ['repo_name']);
     pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s/update', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_merge', '/%(repo_name)s/pull-request/%(pull_request_id)s/merge', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/delete', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/delete', ['repo_name', 'pull_request_id', 'comment_id']);
     pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
     pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']);
     pyroutes.register('edit_repo_advanced_delete', '/%(repo_name)s/settings/advanced/delete', ['repo_name']);
     pyroutes.register('edit_repo_advanced_locking', '/%(repo_name)s/settings/advanced/locking', ['repo_name']);
     pyroutes.register('edit_repo_advanced_journal', '/%(repo_name)s/settings/advanced/journal', ['repo_name']);
     pyroutes.register('edit_repo_advanced_fork', '/%(repo_name)s/settings/advanced/fork', ['repo_name']);
     pyroutes.register('edit_repo_caches', '/%(repo_name)s/settings/caches', ['repo_name']);
     pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']);
     pyroutes.register('edit_repo_maintenance', '/%(repo_name)s/settings/maintenance', ['repo_name']);
     pyroutes.register('edit_repo_maintenance_execute', '/%(repo_name)s/settings/maintenance/execute', ['repo_name']);
     pyroutes.register('edit_repo_fields', '/%(repo_name)s/settings/fields', ['repo_name']);
     pyroutes.register('edit_repo_fields_create', '/%(repo_name)s/settings/fields/create', ['repo_name']);
     pyroutes.register('edit_repo_fields_delete', '/%(repo_name)s/settings/fields/%(field_id)s/delete', ['repo_name', 'field_id']);
     pyroutes.register('repo_edit_toggle_locking', '/%(repo_name)s/settings/toggle_locking', ['repo_name']);
     pyroutes.register('edit_repo_remote', '/%(repo_name)s/settings/remote', ['repo_name']);
     pyroutes.register('edit_repo_remote_pull', '/%(repo_name)s/settings/remote/pull', ['repo_name']);
     pyroutes.register('edit_repo_statistics', '/%(repo_name)s/settings/statistics', ['repo_name']);
     pyroutes.register('edit_repo_statistics_reset', '/%(repo_name)s/settings/statistics/update', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker', '/%(repo_name)s/settings/issue_trackers', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_test', '/%(repo_name)s/settings/issue_trackers/test', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_delete', '/%(repo_name)s/settings/issue_trackers/delete', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_update', '/%(repo_name)s/settings/issue_trackers/update', ['repo_name']);
     pyroutes.register('edit_repo_vcs', '/%(repo_name)s/settings/vcs', ['repo_name']);
     pyroutes.register('edit_repo_vcs_update', '/%(repo_name)s/settings/vcs/update', ['repo_name']);
     pyroutes.register('edit_repo_vcs_svn_pattern_delete', '/%(repo_name)s/settings/vcs/svn_pattern/delete', ['repo_name']);
     pyroutes.register('repo_reviewers', '/%(repo_name)s/settings/review/rules', ['repo_name']);
     pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/settings/review/default-reviewers', ['repo_name']);
     pyroutes.register('edit_repo_strip', '/%(repo_name)s/settings/strip', ['repo_name']);
     pyroutes.register('strip_check', '/%(repo_name)s/settings/strip_check', ['repo_name']);
     pyroutes.register('strip_execute', '/%(repo_name)s/settings/strip_execute', ['repo_name']);
     pyroutes.register('edit_repo_audit_logs', '/%(repo_name)s/settings/audit_logs', ['repo_name']);
     pyroutes.register('rss_feed_home', '/%(repo_name)s/feed/rss', ['repo_name']);
     pyroutes.register('atom_feed_home', '/%(repo_name)s/feed/atom', ['repo_name']);
     pyroutes.register('repo_summary', '/%(repo_name)s', ['repo_name']);
     pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_name']);
     pyroutes.register('edit_repo_group', '/%(repo_group_name)s/_edit', ['repo_group_name']);
     pyroutes.register('edit_repo_group_advanced', '/%(repo_group_name)s/_settings/advanced', ['repo_group_name']);
     pyroutes.register('edit_repo_group_advanced_delete', '/%(repo_group_name)s/_settings/advanced/delete', ['repo_group_name']);
     pyroutes.register('edit_repo_group_perms', '/%(repo_group_name)s/_settings/permissions', ['repo_group_name']);
     pyroutes.register('edit_repo_group_perms_update', '/%(repo_group_name)s/_settings/permissions/update', ['repo_group_name']);
     pyroutes.register('repo_group_home', '/%(repo_group_name)s', ['repo_group_name']);
     pyroutes.register('repo_group_home_slash', '/%(repo_group_name)s/', ['repo_group_name']);
     pyroutes.register('user_group_members_data', '/_admin/user_groups/%(user_group_id)s/members', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_summary', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_summary_json', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary/json', ['user_group_id']);
     pyroutes.register('edit_user_group', '/_admin/user_groups/%(user_group_id)s/edit', ['user_group_id']);
     pyroutes.register('user_groups_update', '/_admin/user_groups/%(user_group_id)s/update', ['user_group_id']);
     pyroutes.register('edit_user_group_global_perms', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions', ['user_group_id']);
     pyroutes.register('edit_user_group_global_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions/update', ['user_group_id']);
     pyroutes.register('edit_user_group_perms', '/_admin/user_groups/%(user_group_id)s/edit/permissions', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/permissions/update', ['user_group_id']);
     pyroutes.register('edit_user_group_advanced', '/_admin/user_groups/%(user_group_id)s/edit/advanced', ['user_group_id']);
     pyroutes.register('edit_user_group_advanced_sync', '/_admin/user_groups/%(user_group_id)s/edit/advanced/sync', ['user_group_id']);
     pyroutes.register('user_groups_delete', '/_admin/user_groups/%(user_group_id)s/delete', ['user_group_id']);
     pyroutes.register('search', '/_admin/search', []);
     pyroutes.register('search_repo', '/%(repo_name)s/search', ['repo_name']);
     pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']);
     pyroutes.register('my_account_profile', '/_admin/my_account/profile', []);
     pyroutes.register('my_account_edit', '/_admin/my_account/edit', []);
     pyroutes.register('my_account_update', '/_admin/my_account/update', []);
     pyroutes.register('my_account_password', '/_admin/my_account/password', []);
     pyroutes.register('my_account_password_update', '/_admin/my_account/password/update', []);
     pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []);
     pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []);
     pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []);
     pyroutes.register('my_account_ssh_keys', '/_admin/my_account/ssh_keys', []);
     pyroutes.register('my_account_ssh_keys_generate', '/_admin/my_account/ssh_keys/generate', []);
     pyroutes.register('my_account_ssh_keys_add', '/_admin/my_account/ssh_keys/new', []);
     pyroutes.register('my_account_ssh_keys_delete', '/_admin/my_account/ssh_keys/delete', []);
     pyroutes.register('my_account_emails', '/_admin/my_account/emails', []);
     pyroutes.register('my_account_emails_add', '/_admin/my_account/emails/new', []);
     pyroutes.register('my_account_emails_delete', '/_admin/my_account/emails/delete', []);
     pyroutes.register('my_account_repos', '/_admin/my_account/repos', []);
     pyroutes.register('my_account_watched', '/_admin/my_account/watched', []);
     pyroutes.register('my_account_perms', '/_admin/my_account/perms', []);
     pyroutes.register('my_account_notifications', '/_admin/my_account/notifications', []);
     pyroutes.register('my_account_notifications_toggle_visibility', '/_admin/my_account/toggle_visibility', []);
     pyroutes.register('my_account_pullrequests', '/_admin/my_account/pull_requests', []);
     pyroutes.register('my_account_pullrequests_data', '/_admin/my_account/pull_requests/data', []);
     pyroutes.register('notifications_show_all', '/_admin/notifications', []);
     pyroutes.register('notifications_mark_all_read', '/_admin/notifications/mark_all_read', []);
     pyroutes.register('notifications_show', '/_admin/notifications/%(notification_id)s', ['notification_id']);
     pyroutes.register('notifications_update', '/_admin/notifications/%(notification_id)s/update', ['notification_id']);
     pyroutes.register('notifications_delete', '/_admin/notifications/%(notification_id)s/delete', ['notification_id']);
     pyroutes.register('my_account_notifications_test_channelstream', '/_admin/my_account/test_channelstream', []);
     pyroutes.register('gists_show', '/_admin/gists', []);
     pyroutes.register('gists_new', '/_admin/gists/new', []);
     pyroutes.register('gists_create', '/_admin/gists/create', []);
     pyroutes.register('gist_show', '/_admin/gists/%(gist_id)s', ['gist_id']);
     pyroutes.register('gist_delete', '/_admin/gists/%(gist_id)s/delete', ['gist_id']);
     pyroutes.register('gist_edit', '/_admin/gists/%(gist_id)s/edit', ['gist_id']);
     pyroutes.register('gist_edit_check_revision', '/_admin/gists/%(gist_id)s/edit/check_revision', ['gist_id']);
     pyroutes.register('gist_update', '/_admin/gists/%(gist_id)s/update', ['gist_id']);
     pyroutes.register('gist_show_rev', '/_admin/gists/%(gist_id)s/%(revision)s', ['gist_id', 'revision']);
     pyroutes.register('gist_show_formatted', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s', ['gist_id', 'revision', 'format']);
     pyroutes.register('gist_show_formatted_path', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s/%(f_path)s', ['gist_id', 'revision', 'format', 'f_path']);
     pyroutes.register('debug_style_home', '/_admin/debug_style', []);
     pyroutes.register('debug_style_template', '/_admin/debug_style/t/%(t_path)s', ['t_path']);
     pyroutes.register('apiv2', '/_admin/api', []);
 }

rhodecode/templates/admin/integrations/form.mako

@@ -1,69 +1,69 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base.mako"/>
 
 <%def name="breadcrumbs_links()">
   %if c.repo:
     ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='repo_integrations_home', repo_name=c.repo.repo_name))}
     &raquo;
     ${h.link_to(c.current_IntegrationType.display_name,
       request.route_url(route_name='repo_integrations_list',
                         repo_name=c.repo.repo_name,
                         integration=c.current_IntegrationType.key))}
   %elif c.repo_group:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
     ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
     ${h.link_to(c.repo_group.group_name,h.route_path('edit_repo_group', repo_group_name=c.repo_group.group_name))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='repo_group_integrations_home', repo_group_name=c.repo_group.group_name))}
     &raquo;
     ${h.link_to(c.current_IntegrationType.display_name,
       request.route_url(route_name='repo_group_integrations_list',
                         repo_group_name=c.repo_group.group_name,
                         integration=c.current_IntegrationType.key))}
   %else:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('Settings'),h.url('admin_settings'))}
+    ${h.link_to(_('Settings'),h.route_path('admin_settings'))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='global_integrations_home'))}
     &raquo;
     ${h.link_to(c.current_IntegrationType.display_name,
       request.route_url(route_name='global_integrations_list',
                         integration=c.current_IntegrationType.key))}
   %endif
 
   %if c.integration:
     &raquo;
     ${c.integration.name}
   %elif c.current_IntegrationType:
     &raquo;
     ${c.current_IntegrationType.display_name}
   %endif
 </%def>
 
 <style>
 .control-inputs.item-options, .control-inputs.item-settings {
   float: left;
   width: 100%;
 }
 </style>
 <div class="panel panel-default">
   <div class="panel-heading">
     <h2 class="panel-title">
       %if c.integration:
         ${c.current_IntegrationType.display_name} - ${c.integration.name}
       %else:
         ${_('Create New %(integration_type)s Integration') % {
           'integration_type': c.current_IntegrationType.display_name
         }}
       %endif
     </h2>
   </div>
   <div class="panel-body">
     ${c.form.render() | n}
   </div>
 </div>

rhodecode/templates/admin/integrations/list.mako

@@ -1,256 +1,256 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base.mako"/>
 
 <%def name="breadcrumbs_links()">
   %if c.repo:
     ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
   %elif c.repo_group:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
     ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
     ${h.link_to(c.repo_group.group_name,h.route_path('edit_repo_group', repo_group_name=c.repo_group.group_name))}
   %else:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('Settings'),h.url('admin_settings'))}
+    ${h.link_to(_('Settings'),h.route_path('admin_settings'))}
   %endif
   %if c.current_IntegrationType:
     &raquo;
     %if c.repo:
     ${h.link_to(_('Integrations'),
       request.route_path(route_name='repo_integrations_home',
                          repo_name=c.repo.repo_name))}
     %elif c.repo_group:
     ${h.link_to(_('Integrations'),
       request.route_path(route_name='repo_group_integrations_home',
                          repo_group_name=c.repo_group.group_name))}
     %else:
     ${h.link_to(_('Integrations'),
       request.route_path(route_name='global_integrations_home'))}
     %endif
     &raquo;
     ${c.current_IntegrationType.display_name}
   %else:
     &raquo;
     ${_('Integrations')}
   %endif
 </%def>
 
 <div class="panel panel-default">
   <div class="panel-heading">
     <h3 class="panel-title">
       %if c.repo:
         ${_('Current Integrations for Repository: {repo_name}').format(repo_name=c.repo.repo_name)}
       %elif c.repo_group:
         ${_('Current Integrations for repository group: {repo_group_name}').format(repo_group_name=c.repo_group.group_name)}
       %else:
           ${_('Current Integrations')}
       %endif
       </h3>
   </div>
   <div class="panel-body">
     <%
     if c.repo:
       home_url = request.route_path('repo_integrations_home',
                                     repo_name=c.repo.repo_name)
     elif c.repo_group:
       home_url = request.route_path('repo_group_integrations_home',
                                     repo_group_name=c.repo_group.group_name)
     else:
       home_url = request.route_path('global_integrations_home')
     %>
 
     <a href="${home_url}" class="btn ${not c.current_IntegrationType and 'btn-primary' or ''}">${_('All')}</a>
 
     %for integration_key, IntegrationType in c.available_integrations.items():
         % if not IntegrationType.is_dummy:
             <%
             if c.repo:
               list_url = request.route_path('repo_integrations_list',
                                             repo_name=c.repo.repo_name,
                                             integration=integration_key)
             elif c.repo_group:
               list_url = request.route_path('repo_group_integrations_list',
                                             repo_group_name=c.repo_group.group_name,
                                             integration=integration_key)
             else:
               list_url = request.route_path('global_integrations_list',
                                            integration=integration_key)
             %>
             <a href="${list_url}"
              class="btn ${c.current_IntegrationType and integration_key == c.current_IntegrationType.key and 'btn-primary' or ''}">
             ${IntegrationType.display_name}
             </a>
         % endif
     %endfor
 
     <%
     integration_type = c.current_IntegrationType and c.current_IntegrationType.display_name or ''
 
     if c.repo:
       create_url = h.route_path('repo_integrations_new', repo_name=c.repo.repo_name)
     elif c.repo_group:
       create_url = h.route_path('repo_group_integrations_new', repo_group_name=c.repo_group.group_name)
     else:
       create_url = h.route_path('global_integrations_new')
     %>
     <p class="pull-right">
       <a href="${create_url}" class="btn btn-small btn-success">${_(u'Create new integration')}</a>
     </p>
 
     <table class="rctable integrations">
       <thead>
         <tr>
             <th><a href="?sort=enabled:${c.rev_sort_dir}">${_('Enabled')}</a></th>
             <th><a href="?sort=name:${c.rev_sort_dir}">${_('Name')}</a></th>
             <th colspan="2"><a href="?sort=integration_type:${c.rev_sort_dir}">${_('Type')}</a></th>
             <th><a href="?sort=scope:${c.rev_sort_dir}">${_('Scope')}</a></th>
             <th>${_('Actions')}</th>
             <th></th>
         </tr>
       </thead>
       <tbody>
   %if not c.integrations_list:
         <tr>
           <td colspan="7">
 
             %if c.repo:
               ${_('No {type} integrations for repo {repo} exist yet.').format(type=integration_type, repo=c.repo.repo_name)}
             %elif c.repo_group:
               ${_('No {type} integrations for repogroup {repogroup} exist yet.').format(type=integration_type, repogroup=c.repo_group.group_name)}
             %else:
               ${_('No {type} integrations exist yet.').format(type=integration_type)}
             %endif
 
             %if c.current_IntegrationType:
             <%
             if c.repo:
               create_url = h.route_path('repo_integrations_create', repo_name=c.repo.repo_name, integration=c.current_IntegrationType.key)
             elif c.repo_group:
               create_url = h.route_path('repo_group_integrations_create', repo_group_name=c.repo_group.group_name, integration=c.current_IntegrationType.key)
             else:
               create_url = h.route_path('global_integrations_create', integration=c.current_IntegrationType.key)
             %>
             %endif
 
             <a href="${create_url}">${_(u'Create one')}</a>
           </td>
         </tr>
   %endif
   %for IntegrationType, integration in c.integrations_list:
         <tr id="integration_${integration.integration_id}">
           <td class="td-enabled">
             %if integration.enabled:
             <div class="flag_status approved pull-left"></div>
             %else:
             <div class="flag_status rejected pull-left"></div>
             %endif
           </td>
           <td class="td-description">
             ${integration.name}
           </td>
           <td class="td-icon">
             %if integration.integration_type in c.available_integrations:
             <div class="integration-icon">
               ${c.available_integrations[integration.integration_type].icon|n}
             </div>
             %else:
               ?
             %endif
           </td>
           <td class="td-type">
             ${integration.integration_type}
           </td>
           <td class="td-scope">
             %if integration.repo:
             <a href="${h.route_path('repo_summary', repo_name=integration.repo.repo_name)}">
               ${_('repo')}:${integration.repo.repo_name}
             </a>
             %elif integration.repo_group:
             <a href="${h.route_path('repo_group_home', repo_group_name=integration.repo_group.group_name)}">
               ${_('repogroup')}:${integration.repo_group.group_name}
               %if integration.child_repos_only:
               ${_('child repos only')}
               %else:
               ${_('cascade to all')}
               %endif
             </a>
             %else:
               %if integration.child_repos_only:
               ${_('top level repos only')}
               %else:
               ${_('global')}
               %endif
           </td>
           %endif
           <td class="td-action">
           %if not IntegrationType:
           ${_('unknown integration')}
           %else:
             <%
             if c.repo:
               edit_url = request.route_path('repo_integrations_edit',
                                             repo_name=c.repo.repo_name,
                                             integration=integration.integration_type,
                                             integration_id=integration.integration_id)
             elif c.repo_group:
               edit_url = request.route_path('repo_group_integrations_edit',
                                             repo_group_name=c.repo_group.group_name,
                                             integration=integration.integration_type,
                                             integration_id=integration.integration_id)
             else:
               edit_url = request.route_path('global_integrations_edit',
                                            integration=integration.integration_type,
                                            integration_id=integration.integration_id)
             %>
             <div class="grid_edit">
               <a href="${edit_url}">${_('Edit')}</a>
             </div>
             <div class="grid_delete">
               <a href="${edit_url}"
                  class="btn btn-link btn-danger delete_integration_entry"
                  data-desc="${integration.name}"
                  data-uid="${integration.integration_id}">
                   ${_('Delete')}
               </a>
             </div>
           %endif
           </td>
         </tr>
     %endfor
       <tr id="last-row"></tr>
       </tbody>
     </table>
     <div class="integrations-paginator">
       <div class="pagination-wh pagination-left">
       ${c.integrations_list.pager('$link_previous ~2~ $link_next')}
       </div>
     </div>
   </div>
 </div>
 <script type="text/javascript">
   var delete_integration = function(entry) {
     if (confirm("Confirm to remove this integration: "+$(entry).data('desc'))) {
       var request = $.ajax({
         type: "POST",
         url: $(entry).attr('href'),
         data: {
           'delete': 'delete',
           'csrf_token': CSRF_TOKEN
         },
         success: function(){
           location.reload();
         },
         error: function(data, textStatus, errorThrown){
           alert("Error while deleting entry.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(entry)[0].url));
         }
       });
     };
   };
 
   $('.delete_integration_entry').on('click', function(e){
     e.preventDefault();
     delete_integration(this);
   });
 </script>
  No newline at end of file

rhodecode/templates/admin/integrations/new.mako

@@ -1,68 +1,68 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base.mako"/>
 <%namespace name="widgets" file="/widgets.mako"/>
 
 <%def name="breadcrumbs_links()">
   %if c.repo:
     ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='repo_integrations_home', repo_name=c.repo.repo_name))}
   %elif c.repo_group:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
     ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
     ${h.link_to(c.repo_group.group_name,h.route_path('edit_repo_group', repo_group_name=c.repo_group.group_name))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='repo_group_integrations_home', repo_group_name=c.repo_group.group_name))}
   %else:
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('Settings'),h.url('admin_settings'))}
+    ${h.link_to(_('Settings'),h.route_path('admin_settings'))}
     &raquo;
     ${h.link_to(_('Integrations'),request.route_url(route_name='global_integrations_home'))}
   %endif
     &raquo;
     ${_('Create new integration')}
 </%def>
 <%widgets:panel class_='integrations'>
     <%def name="title()">
         %if c.repo:
             ${_('Create New Integration for repository: {repo_name}').format(repo_name=c.repo.repo_name)}
         %elif c.repo_group:
             ${_('Create New Integration for repository group: {repo_group_name}').format(repo_group_name=c.repo_group.group_name)}
         %else:
             ${_('Create New Global Integration')}
         %endif
     </%def>
 
     %for integration, IntegrationObject in c.available_integrations.items():
       <%
       if c.repo:
         create_url = request.route_path('repo_integrations_create',
                                         repo_name=c.repo.repo_name,
                                         integration=integration)
       elif c.repo_group:
         create_url = request.route_path('repo_group_integrations_create',
                                         repo_group_name=c.repo_group.group_name,
                                         integration=integration)
       else:
         create_url = request.route_path('global_integrations_create',
                                         integration=integration)
       if IntegrationObject.is_dummy:
         create_url = request.current_route_path()
       %>
         <a href="${create_url}" class="integration-box ${'dummy-integration' if IntegrationObject.is_dummy else ''}">
           <%widgets:panel>
             <h2>
               <div class="integration-icon">
                   ${IntegrationObject.icon|n}
               </div>
               ${IntegrationObject.display_name}
             </h2>
             ${IntegrationObject.description or _('No description available')}
           </%widgets:panel>
         </a>
     %endfor
       <div style="clear:both"></div>
 </%widgets:panel>

rhodecode/templates/admin/repos/repo_add_base.mako

@@ -1,164 +1,164 b''
 ## -*- coding: utf-8 -*-
 
 ${h.secure_form(h.route_path('repo_create'), request=request)}
 <div class="form">
     <!-- fields -->
     <div class="fields">
         <div class="field">
             <div class="label">
                 <label for="repo_name">${_('Name')}:</label>
             </div>
             <div class="input">
                 ${h.text('repo_name', class_="medium")}
                 <div class="info-block">
                     <a id="remote_clone_toggle" href="#"><i class="icon-download-alt"></i> ${_('Import Existing Repository ?')}</a>
                 </div>
                 %if not c.rhodecode_user.is_admin:
                     ${h.hidden('user_created',True)}
                 %endif
             </div>
          </div>
         <div id="remote_clone" class="field" style="display: none;">
             <div class="label">
                 <label for="clone_uri">${_('Clone from')}:</label>
             </div>
             <div class="input">
                 ${h.text('clone_uri', class_="medium")}
                 <span class="help-block">
                     <pre>
 - The repository must be accessible over http:// or https://
 - For Git projects it's recommended appending .git to the end of clone url.
 - Make sure to select proper repository type from the below selector before importing it.
 - If your HTTP[S] repository is not publicly accessible,
   add authentication information to the URL: https://username:[e-mail]/repo-name.
 - The Git LFS/Mercurial Largefiles objects will not be imported.
 - For very large repositories, it's recommended to manually copy them into the
-  RhodeCode <a href="${h.url('admin_settings_vcs', anchor='vcs-storage-options')}">storage location</a> and run <a href="${h.url('admin_settings_mapping')}">Remap and Rescan</a>.
+  RhodeCode <a href="${h.route_path('admin_settings_vcs', _anchor='vcs-storage-options')}">storage location</a> and run <a href="${h.route_path('admin_settings_mapping')}">Remap and Rescan</a>.
                     </pre>
                 </span>
             </div>
         </div>
         <div class="field">
             <div class="label">
                 <label for="repo_description">${_('Description')}:</label>
             </div>
             <div class="textarea editor">
                 ${h.textarea('repo_description')}
                 <% metatags_url = h.literal('''<a href="#metatagsShow" onclick="$('#meta-tags-desc').toggle();return false">meta-tags</a>''') %>
                 <span class="help-block">${_('Plain text format with support of {metatags}. Add a README file for longer descriptions').format(metatags=metatags_url)|n}</span>
                 <span id="meta-tags-desc" style="display: none">
                     <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
                     ${dt.metatags_help()}
                 </span>
             </div>
         </div>
         <div class="field">
              <div class="label">
                  <label for="repo_group">${_('Repository Group')}:</label>
              </div>
              <div class="select">
                  ${h.select('repo_group',request.GET.get('parent_group'),c.repo_groups,class_="medium")}
                  % if c.personal_repo_group:
                      <a class="btn" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">
                          ${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}
                      </a>
                  % endif
                  <span class="help-block">${_('Optionally select a group to put this repository into.')}</span>
              </div>
         </div>
         <div id="copy_perms" class="field">
             <div class="label label-checkbox">
                 <label for="repo_copy_permissions">${_('Copy Parent Group Permissions')}:</label>
             </div>
             <div class="checkboxes">
                 ${h.checkbox('repo_copy_permissions', value="True", checked="checked")}
                 <span class="help-block">${_('Copy permission set from the parent repository group.')}</span>
             </div>
         </div>
         <div class="field">
             <div class="label">
                 <label for="repo_type">${_('Type')}:</label>
             </div>
             <div class="select">
                 ${h.select('repo_type','hg',c.backends)}
                 <span class="help-block">${_('Set the type of repository to create.')}</span>
             </div>
         </div>
         <div class="field">
             <div class="label">
                 <label for="repo_landing_rev">${_('Landing commit')}:</label>
             </div>
             <div class="select">
                 ${h.select('repo_landing_rev','',c.landing_revs,class_="medium")}
                 <span class="help-block">${_('The default commit for file pages, downloads, full text search index, and README generation.')}</span>
             </div>
         </div>
         <div class="field">
             <div class="label label-checkbox">
                 <label for="repo_private">${_('Private Repository')}:</label>
             </div>
             <div class="checkboxes">
                 ${h.checkbox('repo_private',value="True")}
                 <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>
             </div>
         </div>
         <div class="buttons">
           ${h.submit('save',_('Save'),class_="btn")}
         </div>
     </div>
 </div>
 <script>
     $(document).ready(function(){
         var setCopyPermsOption = function(group_val){
             if(group_val != "-1"){
                 $('#copy_perms').show()
             }
             else{
                 $('#copy_perms').hide();
             }
         };
 
         $('#remote_clone_toggle').on('click', function(e){
             $('#remote_clone').show();
             e.preventDefault();
         });
 
         if($('#remote_clone input').hasClass('error')){
             $('#remote_clone').show();
         }
         if($('#remote_clone input').val()){
             $('#remote_clone').show();
         }
 
         $("#repo_group").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'dropdownAutoWidth': true,
             'width': "resolve"
         });
 
         setCopyPermsOption($('#repo_group').val());
         $("#repo_group").on("change", function(e) {
             setCopyPermsOption(e.val)
         });
 
         $("#repo_type").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'minimumResultsForSearch': -1,
         });
         $("#repo_landing_rev").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'minimumResultsForSearch': -1,
         });
         $('#repo_name').focus();
 
         $('#select_my_group').on('click', function(e){
             e.preventDefault();
             $("#repo_group").val($(this).data('personalGroupId')).trigger("change");
         })
 
     })
 </script>
 ${h.end_form()}

rhodecode/templates/admin/settings/settings_email.mako

@@ -1,56 +1,56 b''
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Email Configuration')}</h3>
     </div>
     <div class="panel-body">
         <%
          elems = [
             (_('Email prefix'), c.rhodecode_ini.get('email_prefix'), ''),
             (_('RhodeCode email from'), c.rhodecode_ini.get('app_email_from'), ''),
             (_('Error email from'), c.rhodecode_ini.get('error_email_from'), ''),
             (_('Error email recipients'), c.rhodecode_ini.get('email_to'), ''),
 
             (_('SMTP server'), c.rhodecode_ini.get('smtp_server'), ''),
             (_('SMTP username'), c.rhodecode_ini.get('smtp_username'), ''),
             (_('SMTP password'), '%s chars' % len(c.rhodecode_ini.get('smtp_password', '')), ''),
             (_('SMTP port'), c.rhodecode_ini.get('smtp_port'), ''),
 
             (_('SMTP use TLS'), c.rhodecode_ini.get('smtp_use_tls'), ''),
             (_('SMTP use SSL'), c.rhodecode_ini.get('smtp_use_ssl'), ''),
             (_('SMTP auth'), c.rhodecode_ini.get('smtp_auth'), ''),
          ]
         %>
         <dl class="dl-horizontal settings">
         %for dt, dd, tt in elems:
           <dt >${dt}:</dt>
           <dd  title="${h.tooltip(tt)}">${dd}</dd>
         %endfor
         </dl>
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Test Email')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('admin_settings_email'), request=request)}
+        ${h.secure_form(h.route_path('admin_settings_email_update'), request=request)}
 
             <div class="field input">
                 ${h.text('test_email', size=60, placeholder=_('enter valid email'))}
             </div>
             <div class="field">
                 <span class="help-block">
                     ${_('Send an auto-generated email from this server to above email...')}
                 </span>
             </div>
             <div class="buttons">
                 ${h.submit('send',_('Send'),class_="btn")}
             </div>
         ${h.end_form()}
     </div>
 </div>
 
 
 
 

rhodecode/templates/admin/settings/settings_global.mako

@@ -1,295 +1,295 b''
-${h.secure_form(h.url('admin_settings_global'), request=request)}
+${h.secure_form(h.route_path('admin_settings_global_update'), request=request)}
 
 <div class="panel panel-default">
     <div class="panel-heading" id="branding-options">
         <h3 class="panel-title">${_('Branding')} <a class="permalink" href="#branding-options"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <div class="label">
             <label for="rhodecode_title">${_('Title')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_title',size=60)}
         </div>
         <div class="field">
             <span class="help-block">
                 ${_('Set a custom title for your RhodeCode instance (limited to 40 characters).')}
             </span>
         </div>
         <div class="label">
             <label for="rhodecode_realm">${_('HTTP[S] authentication realm')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_realm',size=60)}
         </div>
         <div class="field">
             <span class="help-block">
                 ${_('Set a custom text that is shown as authentication message to clients trying to connect.')}
             </span>
         </div>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="personal-group-options">
         <h3 class="panel-title">${_('Personal Repository Group')} <a class="permalink" href="#personal-group-options"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('rhodecode_create_personal_repo_group','True')}
             <label for="rhodecode_create_personal_repo_group">${_('Create Personal Repository Group')}</label>
         </div>
         <span class="help-block">
             ${_('Always create Personal Repository Groups for new users.')} <br/>
             ${_('When creating new users from add user form or API you can still turn this off via a checkbox or flag')}
         </span>
 
         <div class="label">
             <label for="rhodecode_personal_repo_group_pattern">${_('Personal Repo Group Pattern')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_personal_repo_group_pattern',size=60, placeholder=c.personal_repo_group_default_pattern)}
         </div>
         <span class="help-block">
             ${_('Pattern used to create Personal Repository Groups. Prefix can be other existing repository group path[s], eg. /u/${username}')} <br/>
             ${_('Available variables are currently ${username} and ${user_id}')}
         </span>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="captcha-options">
         <h3 class="panel-title">${_('Registration Captcha')} <a class="permalink" href="#captcha-options"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <div class="label">
             <label for="rhodecode_captcha_public_key">${_('Google ReCaptcha public key')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_captcha_public_key',size=60)}
         </div>
         <div class="field">
             <span class="help-block">
                 ${_('Public key for reCaptcha system.')}
             </span>
         </div>
 
         <div class="label">
             <label for="rhodecode_captcha_private_key">${_('Google ReCaptcha private key')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_captcha_private_key',size=60)}
         </div>
         <div class="field">
             <span class="help-block">
                 ${_('Private key for reCaptcha system. Setting this value will enable captcha on registration')}
             </span>
         </div>
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading" id="header-code-options">
         <h3 class="panel-title">${_('Custom Header Code')} <a class="permalink" href="#header-code-options"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <div class="select">
             <select id="pre_template" >
                 <option value="#">${_('Templates...')}</option>
                 <option value="ga">Google Analytics</option>
                 <option value="clicky">Clicky</option>
                 <option value="server_announce">${_('Server Announcement')}</option>
                 <option value="flash_filtering">${_('Flash message filtering')}</option>
             </select>
         </div>
         <div style="padding: 10px 0px"></div>
         <div class="textarea text-area">
             ${h.textarea('rhodecode_pre_code',cols=23,rows=5,class_="medium")}
             <span class="help-block">${_('Custom js/css code added at the end of the <header/> tag.')}
                          ${_('Use <script/> or <css/> tags to define custom styling or scripting')}</span>
         </div>
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading" id="footer-code-options">
         <h3 class="panel-title">${_('Custom Footer Code')} <a class="permalink" href="#footer-code-options"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <div class="select">
             <select id="post_template" >
                 <option value="#">${_('Templates...')}</option>
                 <option value="ga">Google Analytics</option>
                 <option value="clicky">Clicky</option>
                 <option value="server_announce">${_('Server Announcement')}</option>
             </select>
         </div>
         <div style="padding: 10px 0px"></div>
         <div class="textarea text-area">
             ${h.textarea('rhodecode_post_code',cols=23,rows=5, class_="medium")}
             <span class="help-block">${_('Custom js/css code added at the end of the <body> tag.')}
                         ${_('Use <script> or <css> tags to define custom styling or scripting')}</span>
         </div>
     </div>
 </div>
 
 <div class="buttons">
     ${h.submit('save',_('Save settings'),class_="btn")}
     ${h.reset('reset',_('Reset'),class_="btn")}
 </div>
 ${h.end_form()}
 
 
 
 ## TEMPLATES ##
 ###############
 
 <script id="ga_tmpl" type="text/x-template">
 <%text filter="h">
 <script>
  // Google Analytics
  // Put your Google Analytics code instead of _GACODE_
  var _gaq_code = '_GACODE_';
  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', _gaq_code]);
  _gaq.push(['_trackPageview']);
 
  (function() {
   var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
   ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
   var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();
 
  rhodecode_statechange_callback = function(url, data){
   // ANALYTICS callback on html5 history state changed
   // triggered by file browser, url is the new url,
   // data is extra info passed from the State object
   if (typeof window._gaq !== 'undefined') {
     _gaq.push(['_trackPageview', url]);
   }
  };
 </script>
 </%text>
 </script>
 
 
 
 <script id="clicky_tmpl" type="text/x-template">
 <%text filter="h">
 <script src="//static.getclicky.com/js" type="text/javascript"></script>
 <script type="text/javascript">
  // Clicky Analytics - should be used in the footer code section.
  // Put your Clicky code instead of _CLICKYCODE_ here,
  // and below in the <img> tag.
  var _cl_code = _CLICKYCODE_;
  try{clicky.init(_cl_code);}catch(e){}
 
  rhodecode_statechange_callback = function(url, data){
   // ANALYTICS callback on html5 history state changed
   // triggered by file browser, url is the new url,
   // data is extra info passed from the State object
   if (typeof window.clicky !== 'undefined') {
    clicky.log(url);
   }
 }
 </script>
 <noscript>
 // Put your clicky code in the src file.
 <p><img alt="Clicky" width="1" height="1"
         src="//in.getclicky.com/_CLICKYCODE_ns.gif" /></p>
 </noscript>
 </%text>
 </script>
 
 
 
 <script id="server_announce_tmpl" type='text/x-template'>
 <%text filter="h">
 <script>
 // Server announcement displayed on the top of the page.
 // This can be used to send a global maintenance messages or other
 // important messages to all users of the RhodeCode Enterprise system.
 
 $(document).ready(function(e){
 
  // EDIT - put your message below
  var message = "TYPE YOUR MESSAGE HERE";
 
  // EDIT - choose "info"/"warning"/"error"/"success"/"neutral" as appropriate
  var alert_level = "info";
 
  $("#body").prepend(
   ("<div id='server-announcement' class='"+alert_level+"'>_MSG_"+"</div>").replace("_MSG_", message)
  )
 })
 </script>
 </%text>
 </script>
 
 <script id="flash_filtering_tmpl" type='text/x-template'>
 <%text filter="h">
 <script>
     // This filters out some flash messages before they are presented to user
     // based on their contents. Could be used to filter out warnings/errors
     // of license messages
 
     var filteredMessages = [];
     for(var i =0; i< alertMessagePayloads.length; i++){
         if (typeof alertMessagePayloads[i].message.subdata.subtype !== 'undefined' &&
                 alertMessagePayloads[i].message.subdata.subtype.indexOf('rc_license') !== -1){
             continue
         }
         filteredMessages.push(alertMessagePayloads[i]);
     }
     alertMessagePayloads = filteredMessages;
 </script>
 </%text>
 </script>
 
 <script>
 var pre_cm = initCodeMirror('rhodecode_pre_code', '', false);
 var pre_old = pre_cm.getValue();
 
 var post_cm = initCodeMirror('rhodecode_post_code', '', false);
 var post_old = post_cm.getValue();
 
 var get_data = function(type, old){
     var get_tmpl = function(tmpl_name){
         // unescape some stuff
         return htmlEnDeCode.htmlDecode($('#'+tmpl_name+'_tmpl').html());
     };
     return {
         '#': old,
         'ga': get_tmpl('ga'),
         'clicky': get_tmpl('clicky'),
         'server_announce': get_tmpl('server_announce'),
         'flash_filtering': get_tmpl('flash_filtering')
     }[type]
 };
 
 $('#pre_template').select2({
     containerCssClass: 'drop-menu',
     dropdownCssClass: 'drop-menu-dropdown',
     dropdownAutoWidth: true,
     minimumResultsForSearch: -1
 });
 
 $('#post_template').select2({
     containerCssClass: 'drop-menu',
     dropdownCssClass: 'drop-menu-dropdown',
     dropdownAutoWidth: true,
     minimumResultsForSearch: -1
 });
 
 $('#post_template').on('change', function(e){
     var sel = this.value;
     post_cm.setValue(get_data(sel, post_old))
 });
 
 $('#pre_template').on('change', function(e){
     var sel = this.value;
     pre_cm.setValue(get_data(sel, pre_old))
 })
 </script>

rhodecode/templates/admin/settings/settings_hooks.mako

@@ -1,93 +1,92 b''
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Built in Mercurial hooks - read only')}</h3>
     </div>
     <div class="panel-body">
         <div class="form">
             <div class="fields">
               % for hook in c.hooks:
                 <div class="field">
                     <div class="label label">
                         <label for="${hook.ui_key}">${hook.ui_key}</label>
                     </div>
                     <div class="input" >
                       ${h.text(hook.ui_key,hook.ui_value,size=59,readonly="readonly")}
                     </div>
                 </div>
               % endfor
             </div>
             <span class="help-block">${_('Hooks can be used to trigger actions on certain events such as push / pull. They can trigger Python functions or external applications.')}</span>
         </div>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Custom hooks')}</h3>
     </div>
     <div class="panel-body">
         % if c.visual.allow_custom_hooks_settings:
-        ${h.secure_form(h.url('admin_settings_hooks'), request=request)}
+        ${h.secure_form(h.route_path('admin_settings_hooks_update'), request=request)}
         <div class="form">
             <div class="fields">
 
               % for hook in c.custom_hooks:
               <div class="field"  id="${'id%s' % hook.ui_id }">
                 <div class="label label">
                     <label for="${hook.ui_key}">${hook.ui_key}</label>
                 </div>
                 <div class="input" >
                     ${h.hidden('hook_ui_key',hook.ui_key)}
                     ${h.hidden('hook_ui_value',hook.ui_value)}
                     ${h.text('hook_ui_value_new',hook.ui_value,size=59)}
                     <span class="btn btn-danger"
                     onclick="ajaxActionHook(${hook.ui_id},'${'id%s' % hook.ui_id }')">
                     ${_('Delete')}
                     </span>
                 </div>
               </div>
               % endfor
 
               <div class="field customhooks">
                 <div class="label">
                   <div class="input-wrapper">
                      ${h.text('new_hook_ui_key',size=30)}
                   </div>
                 </div>
                 <div class="input">
                     ${h.text('new_hook_ui_value',size=59)}
                 </div>
               </div>
               <div class="buttons">
                  ${h.submit('save',_('Save'),class_="btn")}
               </div>
             </div>
         </div>
         ${h.end_form()}
         %else:
             DISABLED
         % endif
     </div>
 </div>
 
 
 <script type="text/javascript">
 function ajaxActionHook(hook_id,field_id) {
-    var sUrl = "${h.url('admin_settings_hooks')}";
+    var sUrl = "${h.route_path('admin_settings_hooks_delete')}";
     var callback =  function (o) {
             var elem = $("#"+field_id);
             elem.remove();
         };
     var postData = {
-      '_method': 'delete',
       'hook_id': hook_id,
       'csrf_token': CSRF_TOKEN
     };
     var request = $.post(sUrl, postData)
             .done(callback)
             .fail(function (data, textStatus, errorThrown) {
                 alert("Error while deleting hooks.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(this)[0].url));
         });
-};
+}
 </script>

rhodecode/templates/admin/settings/settings_issuetracker.mako

@@ -1,34 +1,34 b''
 <%namespace name="its" file="/base/issue_tracker_settings.mako"/>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Issue Tracker / Wiki Patterns')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('admin_settings_issuetracker_save'), request=request)}
+        ${h.secure_form(h.route_path('admin_settings_issuetracker_update'), request=request)}
             ${its.issue_tracker_settings_table(
                 patterns=c.issuetracker_entries.items(),
-                form_url=h.url('admin_settings_issuetracker'),
-                delete_url=h.url('admin_issuetracker_delete')
+                form_url=h.route_path('admin_settings_issuetracker'),
+                delete_url=h.route_path('admin_settings_issuetracker_delete')
             )}
               <div class="buttons">
                   <button type="submit" class="btn btn-primary" id="save">${_('Save')}</button>
                   <button type="reset" class="btn">${_('Reset')}</button>
               </div>
          ${h.end_form()}
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Test Patterns')}</h3>
     </div>
     <div class="panel-body">
         ${its.issue_tracker_new_row()}
-        ${its.issue_tracker_settings_test(test_url=h.url('admin_issuetracker_test'))}
+        ${its.issue_tracker_settings_test(test_url=h.route_path('admin_settings_issuetracker_test'))}
     </div>
 </div>
 
 
 
 

rhodecode/templates/admin/settings/settings_labs.mako

@@ -1,58 +1,58 b''
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Labs Settings')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('admin_settings_labs'), request=request)}
+        ${h.secure_form(h.route_path('admin_settings_labs_update'), request=request)}
           <div class="form">
             <div class="fields">
               % if not c.lab_settings:
                 ${_('There are no Labs settings currently')}
               % else:
                   % for lab_setting in c.lab_settings:
                   <div class="field">
                     <div class="label">
                       <label>${lab_setting.group}:</label>
                     </div>
                     % if lab_setting.type == 'bool':
                       <div class="checkboxes">
                         <div class="checkbox">
                           ${h.checkbox(lab_setting.key, 'True')}
                           % if lab_setting.label:
                             <label for="${lab_setting.key}">${lab_setting.label}</label>
                           % endif
                         </div>
                         % if lab_setting.help:
                           <p class="help-block">${lab_setting.help}</p>
                         % endif
                       </div>
                     % else:
                       <div class="input">
                         ${h.text(lab_setting.key, size=60)}
 
                         ## TODO: johbo: This style does not yet exist for our forms,
                         ## the lab settings seem not to adhere to the structure which
                         ## we use in other places.
                         % if lab_setting.label:
                           <label for="${lab_setting.key}">${lab_setting.label}</label>
                         % endif
 
                         % if lab_setting.help:
                           <p class="help-block">${lab_setting.help}</p>
                         % endif
                       </div>
                     % endif
                   </div>
                   % endfor
                   <div class="buttons">
                     ${h.submit('save', _('Save settings'), class_='btn')}
                     ${h.reset('reset', _('Reset'), class_='btn')}
                   </div>
               % endif
             </div>
           </div>
         ${h.end_form()}
     </div>
 </div>
 
 

rhodecode/templates/admin/settings/settings_mapping.mako

@@ -1,28 +1,28 b''
-${h.secure_form(h.url('admin_settings_mapping'), request=request)}
+${h.secure_form(h.route_path('admin_settings_mapping_update'), request=request)}
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Import New Groups or Repositories')}</h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('destroy',True)}
             <label for="destroy">${_('Destroy old data')}</label>
         </div>
         <span class="help-block">${_('In case a repository or a group was deleted from the filesystem and it still exists in the database, check this option to remove obsolete data from the database.')}</span>
 
         <div class="checkbox">
             ${h.checkbox('invalidate',True)}
             <label for="invalidate"> ${_('Invalidate cache for all repositories')}</label>
         </div>
         <span class="help-block">${_('Each cache data for repositories will be cleaned with this option selected. Use this to reload data and clear cache keys.')}</span>
 
         <div class="buttons">
             ${h.submit('rescan',_('Rescan Filesystem'),class_="btn")}
         </div>
 
     </div>
 </div>
 
 
 ${h.end_form()}

rhodecode/templates/admin/settings/settings_vcs.mako

@@ -1,66 +1,65 b''
 <%namespace name="vcss" file="/base/vcs_settings.mako"/>
 
-${h.secure_form(h.url('admin_settings_vcs'), request=request)}
+${h.secure_form(h.route_path('admin_settings_vcs_update'), request=request)}
     <div>
         ${vcss.vcs_settings_fields(
             suffix='',
             svn_tag_patterns=c.svn_tag_patterns,
             svn_branch_patterns=c.svn_branch_patterns,
             display_globals=True,
             allow_repo_location_change=c.visual.allow_repo_location_change
         )}
         <div class="buttons">
             ${h.submit('save',_('Save settings'),class_="btn")}
             ${h.reset('reset',_('Reset'),class_="btn")}
        </div>
     </div>
 ${h.end_form()}
 
 <script type="text/javascript">
 
     function ajaxDeletePattern(pattern_id, field_id) {
-        var sUrl = "${h.url('admin_settings_vcs')}";
+        var sUrl = "${h.route_path('admin_settings_vcs_svn_pattern_delete')}";
         var callback =  function (o) {
             var elem = $("#"+field_id);
             elem.remove();
         };
         var postData = {
-            '_method': 'delete',
             'delete_svn_pattern': pattern_id,
             'csrf_token': CSRF_TOKEN
         };
         var request = $.post(sUrl, postData)
                 .done(callback)
                 .fail(function (data, textStatus, errorThrown) {
                     alert("Error while deleting hooks.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(this)[0].url));
             });
     };
 
     $(document).ready(function() {
 
         var unlockpath = function() {
             $('#path_unlock_icon').removeClass('icon-lock').addClass('icon-unlock');
             $('#paths_root_path').removeAttr('readonly').removeClass('disabled');
         };
 
         $('#path_unlock').on('click', function(e) {
             unlockpath();
         });
 
         if ($('.locked_input').children().hasClass('error-message')) {
             unlockpath();
         }
 
         /* On click handler for the `Generate Apache Config` button. It sends a
         POST request to trigger the (re)generation of the mod_dav_svn config. */
         $('#vcs_svn_generate_cfg').on('click', function(event) {
             event.preventDefault();
             var url = "${h.route_path('admin_settings_vcs_svn_generate_cfg')}";
             var jqxhr = $.post(url, {'csrf_token': CSRF_TOKEN});
             jqxhr.done(function(data) {
                 $.Topic('/notifications').publish(data);
             });
         });
 
     });
 </script>

rhodecode/templates/admin/settings/settings_visual.mako

@@ -1,226 +1,226 b''
-${h.secure_form(h.url('admin_settings_visual'), request=request)}
+${h.secure_form(h.route_path('admin_settings_visual_update'), request=request)}
 
 <div class="panel panel-default">
     <div class="panel-heading" id="general">
         <h3 class="panel-title">${_('General')}</h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('rhodecode_repository_fields','True')}
             <label for="rhodecode_repository_fields">${_('Use repository extra fields')}</label>
         </div>
         <span class="help-block">${_('Allows storing additional customized fields per repository.')}</span>
 
         <div></div>
         <div class="checkbox">
             ${h.checkbox('rhodecode_show_version','True')}
             <label for="rhodecode_show_version">${_('Show RhodeCode version')}</label>
         </div>
         <span class="help-block">${_('Shows or hides a version number of RhodeCode displayed in the footer.')}</span>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="gravatars">
         <h3 class="panel-title">${_('Gravatars')}</h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('rhodecode_use_gravatar','True')}
             <label for="rhodecode_use_gravatar">${_('Use Gravatars based avatars')}</label>
         </div>
         <span class="help-block">${_('Use gravatar.com as avatar system for RhodeCode accounts. If this is disabled avatars are generated based on initials and email.')}</span>
 
         <div class="label">
             <label for="rhodecode_gravatar_url">${_('Gravatar URL')}</label>
         </div>
         <div class="input">
             <div class="field">
                 ${h.text('rhodecode_gravatar_url', size='100%')}
             </div>
 
             <div class="field">
             <span class="help-block">${_('''Gravatar url allows you to use other avatar server application.
                                             Following variables of the URL will be replaced accordingly.
                                             {scheme}    'http' or 'https' sent from running RhodeCode server,
                                             {email}     user email,
                                             {md5email}  md5 hash of the user email (like at gravatar.com),
                                             {size}      size of the image that is expected from the server application,
                                             {netloc}    network location/server host of running RhodeCode server''')}</span>
             </div>
         </div>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="meta-tagging">
         <h3 class="panel-title">${_('Meta-Tagging')}</h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('rhodecode_stylify_metatags','True')}
             <label for="rhodecode_stylify_metatags">${_('Stylify recognised meta tags')}</label>
         </div>
         <span class="help-block">${_('Parses meta tags from repository or repository group description fields and turns them into colored tags.')}</span>
         <div>
             <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
             ${dt.metatags_help()}
         </div>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Dashboard Items')}</h3>
     </div>
     <div class="panel-body">
         <div class="label">
             <label for="rhodecode_dashboard_items">${_('Main page dashboard items')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_dashboard_items',size=5)}
         </div>
         <div class="field">
             <span class="help-block">${_('Number of items displayed in the main page dashboard before pagination is shown.')}</span>
         </div>
 
         <div class="label">
             <label for="rhodecode_admin_grid_items">${_('Admin pages items')}</label>
         </div>
         <div class="field input">
             ${h.text('rhodecode_admin_grid_items',size=5)}
         </div>
         <div class="field">
             <span class="help-block">${_('Number of items displayed in the admin pages grids before pagination is shown.')}</span>
         </div>
     </div>
 </div>
 
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="commit-id">
         <h3 class="panel-title">${_('Commit ID Style')}</h3>
     </div>
     <div class="panel-body">
         <div class="label">
             <label for="rhodecode_show_sha_length">${_('Commit sha length')}</label>
         </div>
         <div class="input">
             <div class="field">
                 ${h.text('rhodecode_show_sha_length',size=5)}
             </div>
             <div class="field">
                 <span class="help-block">${_('''Number of chars to show in commit sha displayed in web interface.
                                                 By default it's shown as r123:9043a6a4c226 this value defines the
                                                 length of the sha after the `r123:` part.''')}</span>
             </div>
         </div>
 
         <div class="checkbox">
             ${h.checkbox('rhodecode_show_revision_number','True')}
             <label for="rhodecode_show_revision_number">${_('Show commit ID numeric reference')} / ${_('Commit show revision number')}</label>
         </div>
         <span class="help-block">${_('''Show revision number in commit sha displayed in web interface.
                                         By default it's shown as r123:9043a6a4c226 this value defines the
                                         if the `r123:` part is shown.''')}</span>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading" id="icons">
         <h3 class="panel-title">${_('Icons')}</h3>
     </div>
     <div class="panel-body">
         <div class="checkbox">
             ${h.checkbox('rhodecode_show_public_icon','True')}
             <label for="rhodecode_show_public_icon">${_('Show public repo icon on repositories')}</label>
         </div>
         <div></div>
 
         <div class="checkbox">
             ${h.checkbox('rhodecode_show_private_icon','True')}
             <label for="rhodecode_show_private_icon">${_('Show private repo icon on repositories')}</label>
         </div>
         <span class="help-block">${_('Show public/private icons next to repositories names.')}</span>
     </div>
 </div>
 
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Markup Renderer')}</h3>
     </div>
     <div class="panel-body">
         <div class="field select">
             ${h.select('rhodecode_markup_renderer', '', ['rst', 'markdown'])}
         </div>
         <div class="field">
             <span class="help-block">${_('Default renderer used to render comments, pull request descriptions and other description elements. After change old entries will still work correctly.')}</span>
         </div>
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Clone URL')}</h3>
     </div>
     <div class="panel-body">
         <div class="field">
             ${h.text('rhodecode_clone_uri_tmpl', size=60)}
         </div>
 
         <div class="field">
             <span class="help-block">
                 ${_('''Schema of clone url construction eg. '{scheme}://{user}@{netloc}/{repo}', available vars:
                        {scheme} 'http' or 'https' sent from running RhodeCode server,
                        {user}   current user username,
                        {netloc} network location/server host of running RhodeCode server,
                        {repo}   full repository name,
                        {repoid} ID of repository, can be used to contruct clone-by-id''')}
             </span>
         </div>
     </div>
 </div>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Custom Support Link')}</h3>
     </div>
     <div class="panel-body">
         <div class="field">
             ${h.text('rhodecode_support_url', size=60)}
         </div>
         <div class="field">
             <span class="help-block">
                 ${_('''Custom url for the support link located at the bottom.
                     The default is set to %(default_url)s. In case there's a need
                     to change the support link to internal issue tracker, it should be done here.
                     ''') % {'default_url': h.route_url('rhodecode_support')}}
             </span>
         </div>
     </div>
 </div>
 
 <div class="buttons">
     ${h.submit('save',_('Save settings'),class_="btn")}
     ${h.reset('reset',_('Reset'),class_="btn")}
 </div>
 
 
 ${h.end_form()}
 
 <script>
 $(document).ready(function() {
     $('#rhodecode_markup_renderer').select2({
         containerCssClass: 'drop-menu',
         dropdownCssClass: 'drop-menu-dropdown',
         dropdownAutoWidth: true,
         minimumResultsForSearch: -1
     });
 });
 </script>

rhodecode/templates/base/base.mako

@@ -1,609 +1,609 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="root.mako"/>
 
 <div class="outerwrapper">
   <!-- HEADER -->
   <div class="header">
       <div id="header-inner" class="wrapper">
           <div id="logo">
               <div class="logo-wrapper">
                   <a href="${h.route_path('home')}"><img src="${h.asset('images/rhodecode-logo-white-216x60.png')}" alt="RhodeCode"/></a>
               </div>
               %if c.rhodecode_name:
                <div class="branding">- ${h.branding(c.rhodecode_name)}</div>
               %endif
           </div>
           <!-- MENU BAR NAV -->
           ${self.menu_bar_nav()}
           <!-- END MENU BAR NAV -->
       </div>
   </div>
   ${self.menu_bar_subnav()}
   <!-- END HEADER -->
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
 
       <rhodecode-toast id="notifications"></rhodecode-toast>
 
       <div class="main">
           ${next.main()}
       </div>
   </div>
   <!-- END CONTENT -->
 
 </div>
 <!-- FOOTER -->
 <div id="footer">
    <div id="footer-inner" class="title wrapper">
        <div>
            <p class="footer-link-right">
                % if c.visual.show_version:
                    RhodeCode Enterprise ${c.rhodecode_version} ${c.rhodecode_edition}
                % endif
                &copy; 2010-${h.datetime.today().year}, <a href="${h.route_url('rhodecode_official')}" target="_blank">RhodeCode GmbH</a>. All rights reserved.
                % if c.visual.rhodecode_support_url:
                   <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>
                % endif
            </p>
            <% sid = 'block' if request.GET.get('showrcid') else 'none' %>
            <p class="server-instance" style="display:${sid}">
                ## display hidden instance ID if specially defined
                % if c.rhodecode_instanceid:
                    ${_('RhodeCode instance id: %s') % c.rhodecode_instanceid}
                % endif
            </p>
        </div>
    </div>
 </div>
 
 <!-- END FOOTER -->
 
 ### MAKO DEFS ###
 
 <%def name="menu_bar_subnav()">
 </%def>
 
 <%def name="breadcrumbs(class_='breadcrumbs')">
     <div class="${class_}">
     ${self.breadcrumbs_links()}
     </div>
 </%def>
 
 <%def name="admin_menu()">
   <ul class="admin_menu submenu">
       <li><a href="${h.route_path('admin_audit_logs')}">${_('Admin audit logs')}</a></li>
       <li><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
       <li><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
       <li><a href="${h.route_path('users')}">${_('Users')}</a></li>
       <li><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
       <li><a href="${h.route_path('admin_permissions_application')}">${_('Permissions')}</a></li>
       <li><a href="${h.route_path('auth_home', traverse='')}">${_('Authentication')}</a></li>
       <li><a href="${h.route_path('global_integrations_home')}">${_('Integrations')}</a></li>
       <li><a href="${h.route_path('admin_defaults_repositories')}">${_('Defaults')}</a></li>
-      <li class="last"><a href="${h.url('admin_settings')}">${_('Settings')}</a></li>
+      <li class="last"><a href="${h.route_path('admin_settings')}">${_('Settings')}</a></li>
   </ul>
 </%def>
 
 
 <%def name="dt_info_panel(elements)">
     <dl class="dl-horizontal">
     %for dt, dd, title, show_items in elements:
       <dt>${dt}:</dt>
       <dd title="${h.tooltip(title)}">
       %if callable(dd):
           ## allow lazy evaluation of elements
           ${dd()}
       %else:
           ${dd}
       %endif
       %if show_items:
           <span class="btn-collapse" data-toggle="item-${h.md5_safe(dt)[:6]}-details">${_('Show More')} </span>
       %endif
       </dd>
 
       %if show_items:
           <div class="collapsable-content" data-toggle="item-${h.md5_safe(dt)[:6]}-details" style="display: none">
           %for item in show_items:
               <dt></dt>
               <dd>${item}</dd>
           %endfor
           </div>
       %endif
 
     %endfor
     </dl>
 </%def>
 
 
 <%def name="gravatar(email, size=16)">
   <%
     if (size > 16):
         gravatar_class = 'gravatar gravatar-large'
     else:
         gravatar_class = 'gravatar'
   %>
   <%doc>
     TODO: johbo: For now we serve double size images to make it smooth
     for retina. This is how it worked until now. Should be replaced
     with a better solution at some point.
   </%doc>
   <img class="${gravatar_class}" src="${h.gravatar_url(email, size * 2)}" height="${size}" width="${size}">
 </%def>
 
 
 <%def name="gravatar_with_user(contact, size=16, show_disabled=False)">
   <% email = h.email_or_none(contact) %>
   <div class="rc-user tooltip" title="${h.tooltip(h.author_string(email))}">
     ${self.gravatar(email, size)}
     <span class="${'user user-disabled' if show_disabled else 'user'}"> ${h.link_to_user(contact)}</span>
   </div>
 </%def>
 
 
 ## admin menu used for people that have some admin resources
 <%def name="admin_menu_simple(repositories=None, repository_groups=None, user_groups=None)">
   <ul class="submenu">
    %if repositories:
       <li class="local-admin-repos"><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
    %endif
    %if repository_groups:
       <li class="local-admin-repo-groups"><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
    %endif
    %if user_groups:
       <li class="local-admin-user-groups"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
    %endif
   </ul>
 </%def>
 
 <%def name="repo_page_title(repo_instance)">
 <div class="title-content">
     <div class="title-main">
         ## SVN/HG/GIT icons
         %if h.is_hg(repo_instance):
             <i class="icon-hg"></i>
         %endif
         %if h.is_git(repo_instance):
             <i class="icon-git"></i>
         %endif
         %if h.is_svn(repo_instance):
             <i class="icon-svn"></i>
         %endif
 
         ## public/private
         %if repo_instance.private:
             <i class="icon-repo-private"></i>
         %else:
             <i class="icon-repo-public"></i>
         %endif
 
         ## repo name with group name
         ${h.breadcrumb_repo_link(c.rhodecode_db_repo)}
 
     </div>
 
     ## FORKED
     %if repo_instance.fork:
     <p>
         <i class="icon-code-fork"></i> ${_('Fork of')}
         <a href="${h.route_path('repo_summary',repo_name=repo_instance.fork.repo_name)}">${repo_instance.fork.repo_name}</a>
     </p>
     %endif
 
     ## IMPORTED FROM REMOTE
     %if repo_instance.clone_uri:
     <p>
        <i class="icon-code-fork"></i> ${_('Clone from')}
        <a href="${h.safe_str(h.hide_credentials(repo_instance.clone_uri))}">${h.hide_credentials(repo_instance.clone_uri)}</a>
     </p>
     %endif
 
     ## LOCKING STATUS
      %if repo_instance.locked[0]:
        <p class="locking_locked">
            <i class="icon-repo-lock"></i>
            ${_('Repository locked by %(user)s') % {'user': h.person_by_id(repo_instance.locked[0])}}
        </p>
      %elif repo_instance.enable_locking:
          <p class="locking_unlocked">
              <i class="icon-repo-unlock"></i>
              ${_('Repository not locked. Pull repository to lock it.')}
          </p>
      %endif
 
 </div>
 </%def>
 
 <%def name="repo_menu(active=None)">
     <%
     def is_active(selected):
         if selected == active:
             return "active"
     %>
 
   <!--- CONTEXT BAR -->
   <div id="context-bar">
     <div class="wrapper">
       <ul id="context-pages" class="horizontal-list navigation">
         <li class="${is_active('summary')}"><a class="menulink" href="${h.route_path('repo_summary', repo_name=c.repo_name)}"><div class="menulabel">${_('Summary')}</div></a></li>
         <li class="${is_active('changelog')}"><a class="menulink" href="${h.route_path('repo_changelog', repo_name=c.repo_name)}"><div class="menulabel">${_('Changelog')}</div></a></li>
         <li class="${is_active('files')}"><a class="menulink" href="${h.route_path('repo_files', repo_name=c.repo_name, commit_id=c.rhodecode_db_repo.landing_rev[1], f_path='')}"><div class="menulabel">${_('Files')}</div></a></li>
         <li class="${is_active('compare')}"><a class="menulink" href="${h.route_path('repo_compare_select',repo_name=c.repo_name)}"><div class="menulabel">${_('Compare')}</div></a></li>
         ## TODO: anderson: ideally it would have a function on the scm_instance "enable_pullrequest() and enable_fork()"
         %if c.rhodecode_db_repo.repo_type in ['git','hg']:
           <li class="${is_active('showpullrequest')}">
             <a class="menulink" href="${h.route_path('pullrequest_show_all', repo_name=c.repo_name)}" title="${h.tooltip(_('Show Pull Requests for %s') % c.repo_name)}">
               %if c.repository_pull_requests:
                 <span class="pr_notifications">${c.repository_pull_requests}</span>
               %endif
               <div class="menulabel">${_('Pull Requests')}</div>
             </a>
           </li>
         %endif
         <li class="${is_active('options')}">
           <a class="menulink dropdown">
               <div class="menulabel">${_('Options')} <div class="show_more"></div></div>
           </a>
           <ul class="submenu">
              %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
                    <li><a href="${h.route_path('edit_repo',repo_name=c.repo_name)}">${_('Settings')}</a></li>
              %endif
               %if c.rhodecode_db_repo.fork:
                <li>
                    <a title="${h.tooltip(_('Compare fork with %s' % c.rhodecode_db_repo.fork.repo_name))}"
                       href="${h.route_path('repo_compare',
                             repo_name=c.rhodecode_db_repo.fork.repo_name,
                             source_ref_type=c.rhodecode_db_repo.landing_rev[0],
                             source_ref=c.rhodecode_db_repo.landing_rev[1],
                             target_repo=c.repo_name,target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_rev[0],
                             target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_rev[1],
                             _query=dict(merge=1))}"
                     >
                    ${_('Compare fork')}
                    </a>
                </li>
               %endif
 
               <li><a href="${h.route_path('search_repo',repo_name=c.repo_name)}">${_('Search')}</a></li>
 
               %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking:
                 %if c.rhodecode_db_repo.locked[0]:
                   <li><a class="locking_del" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Unlock')}</a></li>
                 %else:
                   <li><a class="locking_add" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Lock')}</a></li>
                 %endif
               %endif
               %if c.rhodecode_user.username != h.DEFAULT_USER:
                 %if c.rhodecode_db_repo.repo_type in ['git','hg']:
                   <li><a href="${h.route_path('repo_fork_new',repo_name=c.repo_name)}">${_('Fork')}</a></li>
                   <li><a href="${h.route_path('pullrequest_new',repo_name=c.repo_name)}">${_('Create Pull Request')}</a></li>
                 %endif
               %endif
              </ul>
         </li>
       </ul>
     </div>
     <div class="clear"></div>
   </div>
   <!--- END CONTEXT BAR -->
 
 </%def>
 
 <%def name="usermenu(active=False)">
     ## USER MENU
     <li id="quick_login_li" class="${'active' if active else ''}">
       <a id="quick_login_link" class="menulink childs">
         ${gravatar(c.rhodecode_user.email, 20)}
         <span class="user">
           %if c.rhodecode_user.username != h.DEFAULT_USER:
             <span class="menu_link_user">${c.rhodecode_user.username}</span><div class="show_more"></div>
           %else:
             <span>${_('Sign in')}</span>
           %endif
         </span>
       </a>
 
   <div class="user-menu submenu">
       <div id="quick_login">
         %if c.rhodecode_user.username == h.DEFAULT_USER:
             <h4>${_('Sign in to your account')}</h4>
             ${h.form(h.route_path('login', _query={'came_from': h.current_route_path(request)}), needs_csrf_token=False)}
             <div class="form form-vertical">
                 <div class="fields">
                     <div class="field">
                         <div class="label">
                             <label for="username">${_('Username')}:</label>
                         </div>
                         <div class="input">
                             ${h.text('username',class_='focus',tabindex=1)}
                         </div>
 
                     </div>
                     <div class="field">
                         <div class="label">
                             <label for="password">${_('Password')}:</label>
                             %if h.HasPermissionAny('hg.password_reset.enabled')():
                               <span class="forgot_password">${h.link_to(_('(Forgot password?)'),h.route_path('reset_password'), class_='pwd_reset')}</span>
                             %endif
                         </div>
                         <div class="input">
                             ${h.password('password',class_='focus',tabindex=2)}
                         </div>
                     </div>
                     <div class="buttons">
                         <div class="register">
                         %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():
                          ${h.link_to(_("Don't have an account?"),h.route_path('register'))} <br/>
                         %endif
                         ${h.link_to(_("Using external auth? Sign In here."),h.route_path('login'))}
                         </div>
                         <div class="submit">
                             ${h.submit('sign_in',_('Sign In'),class_="btn btn-small",tabindex=3)}
                         </div>
                     </div>
                 </div>
             </div>
             ${h.end_form()}
         %else:
             <div class="">
                 <div class="big_gravatar">${gravatar(c.rhodecode_user.email, 48)}</div>
                 <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>
                 <div class="email">${c.rhodecode_user.email}</div>
             </div>
             <div class="">
             <ol class="links">
               <li>${h.link_to(_(u'My account'),h.route_path('my_account_profile'))}</li>
               % if c.rhodecode_user.personal_repo_group:
                 <li>${h.link_to(_(u'My personal group'), h.route_path('repo_group_home', repo_group_name=c.rhodecode_user.personal_repo_group.group_name))}</li>
               % endif
               <li class="logout">
               ${h.secure_form(h.route_path('logout'), request=request)}
                   ${h.submit('log_out', _(u'Sign Out'),class_="btn btn-primary")}
               ${h.end_form()}
               </li>
             </ol>
             </div>
         %endif
       </div>
   </div>
       %if c.rhodecode_user.username != h.DEFAULT_USER:
         <div class="pill_container">
           <a class="menu_link_notifications ${'empty' if c.unread_notifications == 0 else ''}" href="${h.route_path('notifications_show_all')}">${c.unread_notifications}</a>
         </div>
       % endif
     </li>
 </%def>
 
 <%def name="menu_items(active=None)">
     <%
     def is_active(selected):
         if selected == active:
             return "active"
         return ""
     %>
     <ul id="quick" class="main_nav navigation horizontal-list">
       <!-- repo switcher -->
       <li class="${is_active('repositories')} repo_switcher_li has_select2">
         <input id="repo_switcher" name="repo_switcher" type="hidden">
       </li>
 
       ## ROOT MENU
       %if c.rhodecode_user.username != h.DEFAULT_USER:
         <li class="${is_active('journal')}">
           <a class="menulink" title="${_('Show activity journal')}" href="${h.route_path('journal')}">
             <div class="menulabel">${_('Journal')}</div>
           </a>
         </li>
       %else:
         <li class="${is_active('journal')}">
           <a class="menulink" title="${_('Show Public activity journal')}" href="${h.route_path('journal_public')}">
             <div class="menulabel">${_('Public journal')}</div>
           </a>
         </li>
       %endif
         <li class="${is_active('gists')}">
           <a class="menulink childs" title="${_('Show Gists')}" href="${h.route_path('gists_show')}">
             <div class="menulabel">${_('Gists')}</div>
           </a>
         </li>
       <li class="${is_active('search')}">
           <a class="menulink" title="${_('Search in repositories you have access to')}" href="${h.route_path('search')}">
             <div class="menulabel">${_('Search')}</div>
           </a>
       </li>
       % if h.HasPermissionAll('hg.admin')('access admin main page'):
         <li class="${is_active('admin')}">
           <a class="menulink childs" title="${_('Admin settings')}" href="#" onclick="return false;">
             <div class="menulabel">${_('Admin')} <div class="show_more"></div></div>
           </a>
           ${admin_menu()}
         </li>
       % elif c.rhodecode_user.repositories_admin or c.rhodecode_user.repository_groups_admin or c.rhodecode_user.user_groups_admin:
       <li class="${is_active('admin')}">
           <a class="menulink childs" title="${_('Delegated Admin settings')}">
             <div class="menulabel">${_('Admin')} <div class="show_more"></div></div>
           </a>
           ${admin_menu_simple(c.rhodecode_user.repositories_admin,
                               c.rhodecode_user.repository_groups_admin,
                               c.rhodecode_user.user_groups_admin or h.HasPermissionAny('hg.usergroup.create.true')())}
       </li>
       % endif
       % if c.debug_style:
       <li class="${is_active('debug_style')}">
           <a class="menulink" title="${_('Style')}" href="${h.route_path('debug_style_home')}">
             <div class="menulabel">${_('Style')}</div>
           </a>
       </li>
       % endif
       ## render extra user menu
       ${usermenu(active=(active=='my_account'))}
     </ul>
 
     <script type="text/javascript">
         var visual_show_public_icon = "${c.visual.show_public_icon}" == "True";
 
         /*format the look of items in the list*/
         var format = function(state, escapeMarkup){
             if (!state.id){
               return state.text; // optgroup
             }
             var obj_dict = state.obj;
             var tmpl = '';
 
             if(obj_dict && state.type == 'repo'){
                 if(obj_dict['repo_type'] === 'hg'){
                     tmpl += '<i class="icon-hg"></i> ';
                 }
                 else if(obj_dict['repo_type'] === 'git'){
                     tmpl += '<i class="icon-git"></i> ';
                 }
                 else if(obj_dict['repo_type'] === 'svn'){
                     tmpl += '<i class="icon-svn"></i> ';
                 }
                 if(obj_dict['private']){
                     tmpl += '<i class="icon-lock" ></i> ';
                 }
                 else if(visual_show_public_icon){
                     tmpl += '<i class="icon-unlock-alt"></i> ';
                 }
             }
             if(obj_dict && state.type == 'commit') {
                 tmpl += '<i class="icon-tag"></i>';
             }
             if(obj_dict && state.type == 'group'){
                 tmpl += '<i class="icon-folder-close"></i> ';
             }
             tmpl += escapeMarkup(state.text);
             return tmpl;
         };
 
         var formatResult = function(result, container, query, escapeMarkup) {
             return format(result, escapeMarkup);
         };
 
         var formatSelection = function(data, container, escapeMarkup) {
             return format(data, escapeMarkup);
         };
 
         $("#repo_switcher").select2({
             cachedDataSource: {},
             minimumInputLength: 2,
             placeholder: '<div class="menulabel">${_('Go to')} <div class="show_more"></div></div>',
             dropdownAutoWidth: true,
             formatResult: formatResult,
             formatSelection: formatSelection,
             containerCssClass: "repo-switcher",
             dropdownCssClass: "repo-switcher-dropdown",
             escapeMarkup: function(m){
                 // don't escape our custom placeholder
                 if(m.substr(0,23) == '<div class="menulabel">'){
                     return m;
                 }
 
                 return Select2.util.escapeMarkup(m);
             },
             query: $.debounce(250, function(query){
                 self = this;
                 var cacheKey = query.term;
                 var cachedData = self.cachedDataSource[cacheKey];
 
                 if (cachedData) {
                     query.callback({results: cachedData.results});
                 } else {
                     $.ajax({
                         url: pyroutes.url('goto_switcher_data'),
                         data: {'query': query.term},
                         dataType: 'json',
                         type: 'GET',
                         success: function(data) {
                             self.cachedDataSource[cacheKey] = data;
                             query.callback({results: data.results});
                         },
                         error: function(data, textStatus, errorThrown) {
                             alert("Error while fetching entries.\nError code {0} ({1}).".format(data.status, data.statusText));
                         }
                     })
                 }
             })
         });
 
         $("#repo_switcher").on('select2-selecting', function(e){
             e.preventDefault();
             window.location = e.choice.url;
         });
 
     </script>
     <script src="${h.asset('js/rhodecode/base/keyboard-bindings.js', ver=c.rhodecode_version_hash)}"></script>
 </%def>
 
 <div class="modal" id="help_kb" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
     <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
           <h4 class="modal-title" id="myModalLabel">${_('Keyboard shortcuts')}</h4>
         </div>
         <div class="modal-body">
               <div class="block-left">
                 <table class="keyboard-mappings">
                     <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Site-wide shortcuts')}</th>
                   </tr>
                   <%
                      elems = [
                          ('/', 'Open quick search box'),
                          ('g h', 'Goto home page'),
                          ('g g', 'Goto my private gists page'),
                          ('g G', 'Goto my public gists page'),
                          ('n r', 'New repository page'),
                          ('n g', 'New gist page'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
                   </table>
               </div>
               <div class="block-left">
                 <table class="keyboard-mappings">
                 <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Repositories')}</th>
                   </tr>
                   <%
                      elems = [
                          ('g s', 'Goto summary page'),
                          ('g c', 'Goto changelog page'),
                          ('g f', 'Goto files page'),
                          ('g F', 'Goto files page with file search activated'),
                          ('g p', 'Goto pull requests page'),
                          ('g o', 'Goto repository settings'),
                          ('g O', 'Goto repository permissions settings'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
               </table>
             </div>
         </div>
         <div class="modal-footer">
         </div>
       </div><!-- /.modal-content -->
     </div><!-- /.modal-dialog -->
 </div><!-- /.modal -->