repo-groups: moved to pyramid

rhodecode/apps/admin/tests/test_admin_repository_groups.py

@@ -0,0 +1,176 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 os
+import pytest
+
+from rhodecode.apps._base import ADMIN_PREFIX
+from rhodecode.lib import helpers as h
+from rhodecode.model.db import Repository, UserRepoToPerm, User
+from rhodecode.model.meta import Session
+from rhodecode.model.repo_group import RepoGroupModel
+from rhodecode.tests import (
+    assert_session_flash, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH, TestController)
+from rhodecode.tests.fixture import Fixture
+
+fixture = Fixture()
+
+
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'repo_groups': ADMIN_PREFIX + '/repo_groups',
+        'repo_group_new': ADMIN_PREFIX + '/repo_group/new',
+        'repo_group_create': ADMIN_PREFIX + '/repo_group/create',
+
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
+def _get_permission_for_user(user, repo):
+    perm = UserRepoToPerm.query()\
+        .filter(UserRepoToPerm.repository ==
+                Repository.get_by_repo_name(repo))\
+        .filter(UserRepoToPerm.user == User.get_by_username(user))\
+        .all()
+    return perm
+
+
[e-mail]("app")
+class TestAdminRepositoryGroups(object):
+    def test_show_repo_groups(self, autologin_user):
+        response = self.app.get(route_path('repo_groups'))
+        response.mustcontain('data: []')
+
+    def test_show_repo_groups_after_creating_group(self, autologin_user):
+        fixture.create_repo_group('test_repo_group')
+        response = self.app.get(route_path('repo_groups'))
+        response.mustcontain('"name_raw": "test_repo_group"')
+        fixture.destroy_repo_group('test_repo_group')
+
+    def test_new(self, autologin_user):
+        self.app.get(route_path('repo_group_new'))
+
+    def test_new_with_parent_group(self, autologin_user, user_util):
+        gr = user_util.create_repo_group()
+
+        self.app.get(route_path('repo_group_new'),
+                     params=dict(parent_group=gr.group_name))
+
+    def test_new_by_regular_user_no_permission(self, autologin_regular_user):
+        self.app.get(route_path('repo_group_new'), status=403)
+
+    @pytest.mark.parametrize('repo_group_name', [
+        'git_repo',
+        'git_repo_ąć',
+        'hg_repo',
+        '12345',
+        'hg_repo_ąć',
+    ])
+    def test_create(self, autologin_user, repo_group_name, csrf_token):
+        repo_group_name_unicode = repo_group_name.decode('utf8')
+        description = 'description for newly created repo group'
+
+        response = self.app.post(
+            route_path('repo_group_create'),
+            fixture._get_group_create_params(
+                group_name=repo_group_name,
+                group_description=description,
+                csrf_token=csrf_token))
+
+        # run the check page that triggers the flash message
+        repo_gr_url = h.route_path(
+            'repo_group_home', repo_group_name=repo_group_name)
+
+        assert_session_flash(
+            response,
+            'Created repository group <a href="%s">%s</a>' % (
+                repo_gr_url, repo_group_name_unicode))
+
+        # # test if the repo group was created in the database
+        new_repo_group = RepoGroupModel()._get_repo_group(
+            repo_group_name_unicode)
+        assert new_repo_group is not None
+
+        assert new_repo_group.group_name == repo_group_name_unicode
+        assert new_repo_group.group_description == description
+
+        # test if the repository is visible in the list ?
+        response = self.app.get(repo_gr_url)
+        response.mustcontain(repo_group_name)
+
+        # test if the repository group was created on filesystem
+        is_on_filesystem = os.path.isdir(
+            os.path.join(TESTS_TMP_PATH, repo_group_name))
+        if not is_on_filesystem:
+            self.fail('no repo group %s in filesystem' % repo_group_name)
+
+        RepoGroupModel().delete(repo_group_name_unicode)
+        Session().commit()
+
+    @pytest.mark.parametrize('repo_group_name', [
+        'git_repo',
+        'git_repo_ąć',
+        'hg_repo',
+        '12345',
+        'hg_repo_ąć',
+    ])
+    def test_create_subgroup(self, autologin_user, user_util, repo_group_name, csrf_token):
+        parent_group = user_util.create_repo_group()
+        parent_group_name = parent_group.group_name
+
+        expected_group_name = '{}/{}'.format(
+            parent_group_name, repo_group_name)
+        expected_group_name_unicode = expected_group_name.decode('utf8')
+
+        try:
+            response = self.app.post(
+                route_path('repo_group_create'),
+                fixture._get_group_create_params(
+                    group_name=repo_group_name,
+                    group_parent_id=parent_group.group_id,
+                    group_description='Test desciption',
+                    csrf_token=csrf_token))
+
+            assert_session_flash(
+                response,
+                u'Created repository group <a href="%s">%s</a>' % (
+                    h.route_path('repo_group_home',
+                                 repo_group_name=expected_group_name),
+                    expected_group_name_unicode))
+        finally:
+            RepoGroupModel().delete(expected_group_name_unicode)
+            Session().commit()
+
+    def test_user_with_creation_permissions_cannot_create_subgroups(
+            self, autologin_regular_user, user_util):
+
+        user_util.grant_user_permission(
+            TEST_USER_REGULAR_LOGIN, 'hg.repogroup.create.true')
+        parent_group = user_util.create_repo_group()
+        parent_group_id = parent_group.group_id
+        self.app.get(
+            route_path('repo_group_new',
+                       params=dict(parent_group=parent_group_id), ),
+            status=403)

rhodecode/apps/admin/views/repo_groups.py

@@ -0,0 +1,204 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 formencode
+import formencode.htmlfill
+
+from pyramid.httpexceptions import HTTPFound, HTTPForbidden
+from pyramid.view import view_config
+from pyramid.renderers import render
+from pyramid.response import Response
+
+from rhodecode.apps._base import BaseAppView, DataGridAppView
+
+from rhodecode.lib.ext_json import json
+from rhodecode.lib.auth import (
+    LoginRequired, CSRFRequired, NotAnonymous,
+    HasPermissionAny, HasRepoGroupPermissionAny)
+from rhodecode.lib import helpers as h, audit_logger
+from rhodecode.lib.utils2 import safe_int, safe_unicode
+from rhodecode.model.forms import RepoGroupForm
+from rhodecode.model.repo_group import RepoGroupModel
+from rhodecode.model.scm import RepoGroupList
+from rhodecode.model.db import Session, RepoGroup
+
+log = logging.getLogger(__name__)
+
+
+class AdminRepoGroupsView(BaseAppView, DataGridAppView):
+
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
+
+    def _load_form_data(self, c):
+        allow_empty_group = False
+
+        if self._can_create_repo_group():
+            # we're global admin, we're ok and we can create TOP level groups
+            allow_empty_group = True
+
+        # override the choices for this form, we need to filter choices
+        # and display only those we have ADMIN right
+        groups_with_admin_rights = RepoGroupList(
+            RepoGroup.query().all(),
+            perm_set=['group.admin'])
+        c.repo_groups = RepoGroup.groups_choices(
+            groups=groups_with_admin_rights,
+            show_empty_group=allow_empty_group)
+
+    def _can_create_repo_group(self, parent_group_id=None):
+        is_admin = HasPermissionAny('hg.admin')('group create controller')
+        create_repo_group = HasPermissionAny(
+            'hg.repogroup.create.true')('group create controller')
+        if is_admin or (create_repo_group and not parent_group_id):
+            # we're global admin, or we have global repo group create
+            # permission
+            # we're ok and we can create TOP level groups
+            return True
+        elif parent_group_id:
+            # we check the permission if we can write to parent group
+            group = RepoGroup.get(parent_group_id)
+            group_name = group.group_name if group else None
+            if HasRepoGroupPermissionAny('group.admin')(
+                    group_name, 'check if user is an admin of group'):
+                # we're an admin of passed in group, we're ok.
+                return True
+            else:
+                return False
+        return False
+
+    @LoginRequired()
+    @NotAnonymous()
+    # perms check inside
+    @view_config(
+        route_name='repo_groups', request_method='GET',
+        renderer='rhodecode:templates/admin/repo_groups/repo_groups.mako')
+    def repo_group_list(self):
+        c = self.load_default_context()
+
+        repo_group_list = RepoGroup.get_all_repo_groups()
+        repo_group_list_acl = RepoGroupList(
+            repo_group_list, perm_set=['group.admin'])
+        repo_group_data = RepoGroupModel().get_repo_groups_as_dict(
+            repo_group_list=repo_group_list_acl, admin=True)
+        c.data = json.dumps(repo_group_data)
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @NotAnonymous()
+    # perm checks inside
+    @view_config(
+        route_name='repo_group_new', request_method='GET',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_add.mako')
+    def repo_group_new(self):
+        c = self.load_default_context()
+
+        # perm check for admin, create_group perm or admin of parent_group
+        parent_group_id = safe_int(self.request.GET.get('parent_group'))
+        if not self._can_create_repo_group(parent_group_id):
+            raise HTTPForbidden()
+
+        self._load_form_data(c)
+
+        defaults = {}  # Future proof for default of repo group
+        data = render(
+            'rhodecode:templates/admin/repo_groups/repo_group_add.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()
+    @NotAnonymous()
+    @CSRFRequired()
+    # perm checks inside
+    @view_config(
+        route_name='repo_group_create', request_method='POST',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_add.mako')
+    def repo_group_create(self):
+        c = self.load_default_context()
+        _ = self.request.translate
+
+        parent_group_id = safe_int(self.request.POST.get('group_parent_id'))
+        can_create = self._can_create_repo_group(parent_group_id)
+
+        self._load_form_data(c)
+        # permissions for can create group based on parent_id are checked
+        # here in the Form
+        available_groups = map(lambda k: safe_unicode(k[0]), c.repo_groups)
+        repo_group_form = RepoGroupForm(available_groups=available_groups,
+                                        can_create_in_root=can_create)()
+
+        repo_group_name = self.request.POST.get('group_name')
+        try:
+            owner = self._rhodecode_user
+            form_result = repo_group_form.to_python(dict(self.request.POST))
+            repo_group = RepoGroupModel().create(
+                group_name=form_result['group_name_full'],
+                group_description=form_result['group_description'],
+                owner=owner.user_id,
+                copy_permissions=form_result['group_copy_permissions']
+            )
+            Session().flush()
+
+            repo_group_data = repo_group.get_api_data()
+            audit_logger.store_web(
+                'repo_group.create', action_data={'data': repo_group_data},
+                user=self._rhodecode_user)
+
+            Session().commit()
+
+            _new_group_name = form_result['group_name_full']
+
+            repo_group_url = h.link_to(
+                _new_group_name,
+                h.route_path('repo_group_home', repo_group_name=_new_group_name))
+            h.flash(h.literal(_('Created repository group %s')
+                    % repo_group_url), category='success')
+
+        except formencode.Invalid as errors:
+            data = render(
+                'rhodecode:templates/admin/repo_groups/repo_group_add.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)
+        except Exception:
+            log.exception("Exception during creation of repository group")
+            h.flash(_('Error occurred during creation of repository group %s')
+                    % repo_group_name, category='error')
+            raise HTTPFound(h.route_path('home'))
+
+        raise HTTPFound(
+            h.route_path('repo_group_home',
+                         repo_group_name=form_result['group_name_full']))

rhodecode/apps/repo_group/tests/test_repo_groups_advanced.py

@@ -0,0 +1,89 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 pytest
+
+from rhodecode.tests import assert_session_flash
+
+
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'edit_repo_group_advanced':
+            '/{repo_group_name}/_settings/advanced',
+        'edit_repo_group_advanced_delete':
+            '/{repo_group_name}/_settings/advanced/delete',
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
[e-mail]("app")
+class TestRepoGroupsAdvancedView(object):
+
+    @pytest.mark.parametrize('repo_group_name', [
+        'gro',
+        '12345',
+    ])
+    def test_show_advanced_settings(self, autologin_user, user_util, repo_group_name):
+        user_util._test_name = repo_group_name
+        gr = user_util.create_repo_group()
+        self.app.get(
+            route_path('edit_repo_group_advanced',
+                       repo_group_name=gr.group_name))
+
+    def test_show_advanced_settings_delete(self, autologin_user, user_util,
+                                           csrf_token):
+        gr = user_util.create_repo_group(auto_cleanup=False)
+        repo_group_name = gr.group_name
+
+        params = dict(
+            csrf_token=csrf_token
+        )
+        response = self.app.post(
+            route_path('edit_repo_group_advanced_delete',
+                       repo_group_name=repo_group_name), params=params)
+        assert_session_flash(
+            response, 'Removed repository group `{}`'.format(repo_group_name))
+
+    def test_delete_not_possible_with_objects_inside(self, autologin_user,
+                                                     repo_groups, csrf_token):
+        zombie_group, parent_group, child_group = repo_groups
+
+        response = self.app.get(
+            route_path('edit_repo_group_advanced',
+                       repo_group_name=parent_group.group_name))
+
+        response.mustcontain(
+            'This repository group includes 1 children repository group')
+
+        params = dict(
+            csrf_token=csrf_token
+        )
+        response = self.app.post(
+            route_path('edit_repo_group_advanced_delete',
+                       repo_group_name=parent_group.group_name), params=params)
+
+        assert_session_flash(
+            response, 'This repository group contains 1 subgroup '
+                      'and cannot be deleted')

rhodecode/apps/repo_group/tests/test_repo_groups_permissions.py

@@ -0,0 +1,49 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 pytest
+
+
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'edit_repo_group_perms':
+            '/{repo_group_name:}/_settings/permissions',
+        'edit_repo_group_perms_update':
+            '/{repo_group_name}/_settings/permissions/update',
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
[e-mail]("app")
+class TestRepoGroupsPermissionsView(object):
+
+    def test_edit_repo_group_perms(self, user_util, autologin_user):
+        repo_group = user_util.create_repo_group()
+        self.app.get(
+            route_path('edit_repo_group_perms',
+                       repo_group_name=repo_group.group_name), status=200)
+
+    def test_update_permissions(self):
+        pass

rhodecode/apps/repo_group/tests/test_repo_groups_settings.py

@@ -0,0 +1,90 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 pytest
+
+from rhodecode.tests import assert_session_flash
+
+
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'edit_repo_group': '/{repo_group_name}/_edit',
+        # Update is POST to the above url
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
[e-mail]("app")
+class TestRepoGroupsSettingsView(object):
+
+    @pytest.mark.parametrize('repo_group_name', [
+        'gro',
+        u'12345',
+    ])
+    def test_edit(self, user_util, autologin_user, repo_group_name):
+        user_util._test_name = repo_group_name
+        repo_group = user_util.create_repo_group()
+
+        self.app.get(
+            route_path('edit_repo_group', repo_group_name=repo_group.group_name),
+            status=200)
+
+    def test_update(self, csrf_token, autologin_user, user_util, rc_fixture):
+        repo_group = user_util.create_repo_group()
+        repo_group_name = repo_group.group_name
+
+        description = 'description for newly created repo group'
+        form_data = rc_fixture._get_group_create_params(
+            group_name=repo_group.group_name,
+            group_description=description,
+            csrf_token=csrf_token,
+            repo_group_name=repo_group.group_name,
+            repo_group_owner=repo_group.user.username)
+
+        response = self.app.post(
+            route_path('edit_repo_group',
+                       repo_group_name=repo_group.group_name),
+            form_data,
+            status=302)
+
+        assert_session_flash(
+            response, 'Repository Group `{}` updated successfully'.format(
+                repo_group_name))
+
+    def test_update_fails_when_parent_pointing_to_self(
+            self, csrf_token, user_util, autologin_user, rc_fixture):
+        group = user_util.create_repo_group()
+        response = self.app.post(
+            route_path('edit_repo_group', repo_group_name=group.group_name),
+            rc_fixture._get_group_create_params(
+                repo_group_name=group.group_name,
+                repo_group_owner=group.user.username,
+                repo_group=group.group_id,
+                csrf_token=csrf_token),
+            status=200
+            )
+        response.mustcontain(
+            '<span class="error-message">"{}" is not one of -1'.format(
+                group.group_id))

rhodecode/apps/repo_group/views/repo_group_advanced.py

@@ -0,0 +1,105 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011-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
+
+from pyramid.view import view_config
+from pyramid.httpexceptions import HTTPFound
+
+from rhodecode.apps._base import RepoGroupAppView
+from rhodecode.lib import helpers as h
+from rhodecode.lib import audit_logger
+from rhodecode.lib.auth import (
+    LoginRequired, CSRFRequired, HasRepoGroupPermissionAnyDecorator)
+from rhodecode.model.repo_group import RepoGroupModel
+from rhodecode.model.meta import Session
+
+log = logging.getLogger(__name__)
+
+
+class RepoGroupSettingsView(RepoGroupAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @view_config(
+        route_name='edit_repo_group_advanced', request_method='GET',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_repo_group_advanced(self):
+        c = self.load_default_context()
+        c.active = 'advanced'
+        c.repo_group = self.db_repo_group
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_repo_group_advanced_delete', request_method='POST',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_repo_group_delete(self):
+        _ = self.request.translate
+        _ungettext = self.request.plularize
+        c = self.load_default_context()
+        c.repo_group = self.db_repo_group
+
+        repos = c.repo_group.repositories.all()
+        if repos:
+            msg = _ungettext(
+                'This repository group contains %(num)d repository and cannot be deleted',
+                'This repository group contains %(num)d repositories and cannot be'
+                ' deleted',
+                len(repos)) % {'num': len(repos)}
+            h.flash(msg, category='warning')
+            raise HTTPFound(
+                h.route_path('edit_repo_group_advanced',
+                             repo_group_name=self.db_repo_group_name))
+
+        children = c.repo_group.children.all()
+        if children:
+            msg = _ungettext(
+                'This repository group contains %(num)d subgroup and cannot be deleted',
+                'This repository group contains %(num)d subgroups and cannot be deleted',
+                len(children)) % {'num': len(children)}
+            h.flash(msg, category='warning')
+            raise HTTPFound(
+                h.route_path('edit_repo_group_advanced',
+                             repo_group_name=self.db_repo_group_name))
+
+        try:
+            old_values = c.repo_group.get_api_data()
+            RepoGroupModel().delete(self.db_repo_group_name)
+
+            audit_logger.store_web(
+                'repo_group.delete', action_data={'old_data': old_values},
+                user=c.rhodecode_user)
+
+            Session().commit()
+            h.flash(_('Removed repository group `%s`') % self.db_repo_group_name,
+                    category='success')
+        except Exception:
+            log.exception("Exception during deletion of repository group")
+            h.flash(_('Error occurred during deletion of repository group %s')
+                    % self.db_repo_group_name, category='error')
+
+        raise HTTPFound(h.route_path('repo_groups'))

rhodecode/apps/repo_group/views/repo_group_permissions.py

@@ -0,0 +1,100 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011-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
+
+from pyramid.view import view_config
+from pyramid.httpexceptions import HTTPFound
+
+from rhodecode.apps._base import RepoGroupAppView
+from rhodecode.lib import helpers as h
+from rhodecode.lib import audit_logger
+from rhodecode.lib.auth import (
+    LoginRequired, HasRepoGroupPermissionAnyDecorator, CSRFRequired)
+from rhodecode.model.repo_group import RepoGroupModel
+from rhodecode.model.forms import RepoGroupPermsForm
+from rhodecode.model.meta import Session
+
+log = logging.getLogger(__name__)
+
+
+class RepoGroupPermissionsView(RepoGroupAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @view_config(
+        route_name='edit_repo_group_perms', request_method='GET',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_repo_group_permissions(self):
+        c = self.load_default_context()
+        c.active = 'permissions'
+        c.repo_group = self.db_repo_group
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_repo_group_perms_update', request_method='POST',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_repo_groups_permissions_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'perms'
+        c.repo_group = self.db_repo_group
+
+        valid_recursive_choices = ['none', 'repos', 'groups', 'all']
+        form = RepoGroupPermsForm(valid_recursive_choices)()\
+            .to_python(self.request.POST)
+
+        if not c.rhodecode_user.is_admin:
+            if self._revoke_perms_on_yourself(form):
+                msg = _('Cannot change permission for yourself as admin')
+                h.flash(msg, category='warning')
+                raise HTTPFound(
+                    h.route_path('edit_repo_group_perms',
+                                 group_name=self.db_repo_group_name))
+
+        # iterate over all members(if in recursive mode) of this groups and
+        # set the permissions !
+        # this can be potentially heavy operation
+        changes = RepoGroupModel().update_permissions(
+            c.repo_group,
+            form['perm_additions'], form['perm_updates'], form['perm_deletions'],
+            form['recursive'])
+
+        action_data = {
+            'added': changes['added'],
+            'updated': changes['updated'],
+            'deleted': changes['deleted'],
+        }
+        audit_logger.store_web(
+            'repo_group.edit.permissions', action_data=action_data,
+            user=c.rhodecode_user)
+
+        Session().commit()
+        h.flash(_('Repository Group permissions updated'), category='success')
+        raise HTTPFound(
+            h.route_path('edit_repo_group_perms',
+                         repo_group_name=self.db_repo_group_name))

rhodecode/apps/repo_group/views/repo_group_settings.py

@@ -0,0 +1,183 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011-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 deform
+
+from pyramid.view import view_config
+from pyramid.httpexceptions import HTTPFound
+
+from rhodecode.apps._base import RepoGroupAppView
+from rhodecode.forms import RcForm
+from rhodecode.lib import helpers as h
+from rhodecode.lib import audit_logger
+from rhodecode.lib.auth import (
+    LoginRequired, HasPermissionAll,
+    HasRepoGroupPermissionAny, HasRepoGroupPermissionAnyDecorator, CSRFRequired)
+from rhodecode.model.db import Session, RepoGroup
+from rhodecode.model.scm import RepoGroupList
+from rhodecode.model.repo_group import RepoGroupModel
+from rhodecode.model.validation_schema.schemas import repo_group_schema
+
+log = logging.getLogger(__name__)
+
+
+class RepoGroupSettingsView(RepoGroupAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        c.repo_group = self.db_repo_group
+        no_parrent = not c.repo_group.parent_group
+        can_create_in_root = self._can_create_repo_group()
+
+        show_root_location = False
+        if no_parrent or can_create_in_root:
+            # we're global admin, we're ok and we can create TOP level groups
+            # or in case this group is already at top-level we also allow
+            # creation in root
+            show_root_location = True
+
+        acl_groups = RepoGroupList(
+            RepoGroup.query().all(),
+            perm_set=['group.admin'])
+        c.repo_groups = RepoGroup.groups_choices(
+            groups=acl_groups,
+            show_empty_group=show_root_location)
+        # filter out current repo group
+        exclude_group_ids = [c.repo_group.group_id]
+        c.repo_groups = filter(lambda x: x[0] not in exclude_group_ids,
+                               c.repo_groups)
+        c.repo_groups_choices = map(lambda k: k[0], c.repo_groups)
+
+        parent_group = c.repo_group.parent_group
+
+        add_parent_group = (parent_group and (
+            parent_group.group_id not in c.repo_groups_choices))
+        if add_parent_group:
+            c.repo_groups_choices.append(parent_group.group_id)
+            c.repo_groups.append(RepoGroup._generate_choice(parent_group))
+
+        self._register_global_c(c)
+        return c
+
+    def _can_create_repo_group(self, parent_group_id=None):
+        is_admin = HasPermissionAll('hg.admin')('group create controller')
+        create_repo_group = HasPermissionAll(
+            'hg.repogroup.create.true')('group create controller')
+        if is_admin or (create_repo_group and not parent_group_id):
+            # we're global admin, or we have global repo group create
+            # permission
+            # we're ok and we can create TOP level groups
+            return True
+        elif parent_group_id:
+            # we check the permission if we can write to parent group
+            group = RepoGroup.get(parent_group_id)
+            group_name = group.group_name if group else None
+            if HasRepoGroupPermissionAny('group.admin')(
+                    group_name, 'check if user is an admin of group'):
+                # we're an admin of passed in group, we're ok.
+                return True
+            else:
+                return False
+        return False
+
+    def _get_schema(self, c, old_values=None):
+        return repo_group_schema.RepoGroupSettingsSchema().bind(
+            repo_group_repo_group_options=c.repo_groups_choices,
+            repo_group_repo_group_items=c.repo_groups,
+
+            # user caller
+            user=self._rhodecode_user,
+            old_values=old_values
+        )
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @view_config(
+        route_name='edit_repo_group', request_method='GET',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_settings(self):
+        c = self.load_default_context()
+        c.active = 'settings'
+
+        defaults = RepoGroupModel()._get_defaults(self.db_repo_group_name)
+        defaults['repo_group_owner'] = defaults['user']
+
+        schema = self._get_schema(c)
+        c.form = RcForm(schema, appstruct=defaults)
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_repo_group', request_method='POST',
+        renderer='rhodecode:templates/admin/repo_groups/repo_group_edit.mako')
+    def edit_settings_update(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'settings'
+
+        old_repo_group_name = self.db_repo_group_name
+        new_repo_group_name = old_repo_group_name
+
+        old_values = RepoGroupModel()._get_defaults(self.db_repo_group_name)
+        schema = self._get_schema(c, old_values=old_values)
+
+        c.form = RcForm(schema)
+        pstruct = self.request.POST.items()
+
+        try:
+            schema_data = c.form.validate(pstruct)
+        except deform.ValidationFailure as err_form:
+            return self._get_template_context(c)
+
+        # data is now VALID, proceed with updates
+        # save validated data back into the updates dict
+        validated_updates = dict(
+            group_name=schema_data['repo_group']['repo_group_name_without_group'],
+            group_parent_id=schema_data['repo_group']['repo_group_id'],
+            user=schema_data['repo_group_owner'],
+            group_description=schema_data['repo_group_description'],
+            enable_locking=schema_data['repo_group_enable_locking'],
+        )
+
+        try:
+            RepoGroupModel().update(self.db_repo_group, validated_updates)
+
+            audit_logger.store_web(
+                'repo_group.edit', action_data={'old_data': old_values},
+                user=c.rhodecode_user)
+
+            Session().commit()
+
+            # use the new full name for redirect once we know we updated
+            # the name on filesystem and in DB
+            new_repo_group_name = schema_data['repo_group_name']
+
+            h.flash(_('Repository Group `{}` updated successfully').format(
+                old_repo_group_name), category='success')
+
+        except Exception:
+            log.exception("Exception during update or repository group")
+            h.flash(_('Error occurred during update of repository group %s')
+                    % old_repo_group_name, category='error')
+
+        raise HTTPFound(
+            h.route_path('edit_repo_group', repo_group_name=new_repo_group_name))

rhodecode/apps/_base/__init__.py

@@ -1,570 +1,584 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 time
 import logging
 import operator
 
 from pyramid.httpexceptions import HTTPFound
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import StrictAttributeDict, safe_int, datetime_to_time
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model import repo
 from rhodecode.model import repo_group
 from rhodecode.model import user_group
 from rhodecode.model import user
 from rhodecode.model.db import User
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 
 ADMIN_PREFIX = '/_admin'
 STATIC_FILE_PREFIX = '/_static'
 
 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)',
 }
 
 
 def add_route_with_slash(config,name, pattern, **kw):
     config.add_route(name, pattern, **kw)
     if not pattern.endswith('/'):
         config.add_route(name + '_slash', pattern + '/', **kw)
 
 
 def add_route_requirements(route_path, requirements=URL_NAME_REQUIREMENTS):
     """
     Adds regex requirements to pyramid routes using a mapping dict
     e.g::
         add_route_requirements('{repo_name}/settings')
     """
     for key, regex in requirements.items():
         route_path = route_path.replace('{%s}' % key, '{%s:%s}' % (key, regex))
     return route_path
 
 
 def get_format_ref_id(repo):
     """Returns a `repo` specific reference formatter function"""
     if h.is_svn(repo):
         return _format_ref_id_svn
     else:
         return _format_ref_id
 
 
 def _format_ref_id(name, raw_id):
     """Default formatting of a given reference `name`"""
     return name
 
 
 def _format_ref_id_svn(name, raw_id):
     """Special way of formatting a reference for Subversion including path"""
     return '%s@%s' % (name, raw_id)
 
 
 class TemplateArgs(StrictAttributeDict):
     pass
 
 
 class BaseAppView(object):
 
     def __init__(self, context, request):
         self.request = request
         self.context = context
         self.session = request.session
         self._rhodecode_user = request.user  # auth user
         self._rhodecode_db_user = self._rhodecode_user.get_instance()
         self._maybe_needs_password_change(
             request.matched_route.name, self._rhodecode_db_user)
 
     def _maybe_needs_password_change(self, view_name, user_obj):
         log.debug('Checking if user %s needs password change on view %s',
                   user_obj, view_name)
         skip_user_views = [
             'logout', 'login',
             'my_account_password', 'my_account_password_update'
         ]
 
         if not user_obj:
             return
 
         if user_obj.username == User.DEFAULT_USER:
             return
 
         now = time.time()
         should_change = user_obj.user_data.get('force_password_change')
         change_after = safe_int(should_change) or 0
         if should_change and now > change_after:
             log.debug('User %s requires password change', user_obj)
             h.flash('You are required to change your password', 'warning',
                     ignore_duplicate=True)
 
             if view_name not in skip_user_views:
                 raise HTTPFound(
                     self.request.route_path('my_account_password'))
 
     def _log_creation_exception(self, e, repo_name):
         _ = self.request.translate
         reason = None
         if len(e.args) == 2:
             reason = e.args[1]
 
         if reason == 'INVALID_CERTIFICATE':
             log.exception(
                 'Exception creating a repository: invalid certificate')
             msg = (_('Error creating repository %s: invalid certificate')
                    % repo_name)
         else:
             log.exception("Exception creating a repository")
             msg = (_('Error creating repository %s')
                    % repo_name)
         return msg
 
     def _get_local_tmpl_context(self, include_app_defaults=False):
         c = TemplateArgs()
         c.auth_user = self.request.user
         # TODO(marcink): migrate the usage of c.rhodecode_user to c.auth_user
         c.rhodecode_user = self.request.user
 
         if include_app_defaults:
             # NOTE(marcink): after full pyramid migration include_app_defaults
             # should be turned on by default
             from rhodecode.lib.base import attach_context_attributes
             attach_context_attributes(c, self.request, self.request.user.user_id)
 
         return c
 
     def _register_global_c(self, tmpl_args):
         """
         Registers attributes to pylons global `c`
         """
 
         # TODO(marcink): remove once pyramid migration is finished
         from pylons import tmpl_context as c
         try:
             for k, v in tmpl_args.items():
                 setattr(c, k, v)
         except TypeError:
             log.exception('Failed to register pylons C')
             pass
 
     def _get_template_context(self, tmpl_args):
         self._register_global_c(tmpl_args)
 
         local_tmpl_args = {
             'defaults': {},
             'errors': {},
             # register a fake 'c' to be used in templates instead of global
             # pylons c, after migration to pyramid we should rename it to 'c'
             # make sure we replace usage of _c in templates too
             '_c': tmpl_args
         }
         local_tmpl_args.update(tmpl_args)
         return local_tmpl_args
 
     def load_default_context(self):
         """
         example:
 
         def load_default_context(self):
             c = self._get_local_tmpl_context()
             c.custom_var = 'foobar'
             self._register_global_c(c)
             return c
         """
         raise NotImplementedError('Needs implementation in view class')
 
 
 class RepoAppView(BaseAppView):
 
     def __init__(self, context, request):
         super(RepoAppView, self).__init__(context, request)
         self.db_repo = request.db_repo
         self.db_repo_name = self.db_repo.repo_name
         self.db_repo_pull_requests = ScmModel().get_pull_requests(self.db_repo)
 
     def _handle_missing_requirements(self, error):
         log.error(
             'Requirements are missing for repository %s: %s',
             self.db_repo_name, error.message)
 
     def _get_local_tmpl_context(self, include_app_defaults=False):
         _ = self.request.translate
         c = super(RepoAppView, self)._get_local_tmpl_context(
             include_app_defaults=include_app_defaults)
 
         # register common vars for this type of view
         c.rhodecode_db_repo = self.db_repo
         c.repo_name = self.db_repo_name
         c.repository_pull_requests = self.db_repo_pull_requests
 
         c.repository_requirements_missing = False
         try:
             self.rhodecode_vcs_repo = self.db_repo.scm_instance()
         except RepositoryRequirementError as e:
             c.repository_requirements_missing = True
             self._handle_missing_requirements(e)
             self.rhodecode_vcs_repo = None
 
         if (not c.repository_requirements_missing
             and self.rhodecode_vcs_repo is None):
             # unable to fetch this repo as vcs instance, report back to user
             h.flash(_(
                 "The repository `%(repo_name)s` cannot be loaded in filesystem. "
                 "Please check if it exist, or is not damaged.") %
                     {'repo_name': c.repo_name},
                     category='error', ignore_duplicate=True)
             raise HTTPFound(h.route_path('home'))
 
         return c
 
     def _get_f_path(self, matchdict, default=None):
         f_path = matchdict.get('f_path')
         if f_path:
             # fix for multiple initial slashes that causes errors for GIT
             return f_path.lstrip('/')
 
         return default
 
 
 class RepoGroupAppView(BaseAppView):
     def __init__(self, context, request):
         super(RepoGroupAppView, self).__init__(context, request)
         self.db_repo_group = request.db_repo_group
         self.db_repo_group_name = self.db_repo_group.group_name
 
+    def _revoke_perms_on_yourself(self, form_result):
+        _updates = filter(lambda u: self._rhodecode_user.user_id == int(u[0]),
+                          form_result['perm_updates'])
+        _additions = filter(lambda u: self._rhodecode_user.user_id == int(u[0]),
+                            form_result['perm_additions'])
+        _deletions = filter(lambda u: self._rhodecode_user.user_id == int(u[0]),
+                            form_result['perm_deletions'])
+        admin_perm = 'group.admin'
+        if _updates and _updates[0][1] != admin_perm or \
+           _additions and _additions[0][1] != admin_perm or \
+           _deletions and _deletions[0][1] != admin_perm:
+            return True
+        return False
+
 
 class UserGroupAppView(BaseAppView):
     def __init__(self, context, request):
         super(UserGroupAppView, self).__init__(context, request)
         self.db_user_group = request.db_user_group
         self.db_user_group_name = self.db_user_group.users_group_name
 
 
 class UserAppView(BaseAppView):
     def __init__(self, context, request):
         super(UserAppView, self).__init__(context, request)
         self.db_user = request.db_user
         self.db_user_id = self.db_user.user_id
 
         _ = self.request.translate
         if not request.db_user_supports_default:
             if self.db_user.username == User.DEFAULT_USER:
                 h.flash(_("Editing user `{}` is disabled.".format(
                     User.DEFAULT_USER)), category='warning')
                 raise HTTPFound(h.route_path('users'))
 
 
 class DataGridAppView(object):
     """
     Common class to have re-usable grid rendering components
     """
 
     def _extract_ordering(self, request, column_map=None):
         column_map = column_map or {}
         column_index = safe_int(request.GET.get('order[0][column]'))
         order_dir = request.GET.get(
             'order[0][dir]', 'desc')
         order_by = request.GET.get(
             'columns[%s][data][sort]' % column_index, 'name_raw')
 
         # translate datatable to DB columns
         order_by = column_map.get(order_by) or order_by
 
         search_q = request.GET.get('search[value]')
         return search_q, order_by, order_dir
 
     def _extract_chunk(self, request):
         start = safe_int(request.GET.get('start'), 0)
         length = safe_int(request.GET.get('length'), 25)
         draw = safe_int(request.GET.get('draw'))
         return draw, start, length
 
     def _get_order_col(self, order_by, model):
         if isinstance(order_by, basestring):
             try:
                 return operator.attrgetter(order_by)(model)
             except AttributeError:
                 return None
         else:
             return order_by
 
 
 class BaseReferencesView(RepoAppView):
     """
     Base for reference view for branches, tags and bookmarks.
     """
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         self._register_global_c(c)
         return c
 
     def load_refs_context(self, ref_items, partials_template):
         _render = self.request.get_partial_renderer(partials_template)
         pre_load = ["author", "date", "message"]
 
         is_svn = h.is_svn(self.rhodecode_vcs_repo)
         is_hg = h.is_hg(self.rhodecode_vcs_repo)
 
         format_ref_id = get_format_ref_id(self.rhodecode_vcs_repo)
 
         closed_refs = {}
         if is_hg:
             closed_refs = self.rhodecode_vcs_repo.branches_closed
 
         data = []
         for ref_name, commit_id in ref_items:
             commit = self.rhodecode_vcs_repo.get_commit(
                 commit_id=commit_id, pre_load=pre_load)
             closed = ref_name in closed_refs
 
             # TODO: johbo: Unify generation of reference links
             use_commit_id = '/' in ref_name or is_svn
 
             if use_commit_id:
                 files_url = h.route_path(
                     'repo_files',
                     repo_name=self.db_repo_name,
                     f_path=ref_name if is_svn else '',
                     commit_id=commit_id)
 
             else:
                 files_url = h.route_path(
                     'repo_files',
                     repo_name=self.db_repo_name,
                     f_path=ref_name if is_svn else '',
                     commit_id=ref_name,
                     _query=dict(at=ref_name))
 
             data.append({
                 "name": _render('name', ref_name, files_url, closed),
                 "name_raw": ref_name,
                 "date": _render('date', commit.date),
                 "date_raw": datetime_to_time(commit.date),
                 "author": _render('author', commit.author),
                 "commit": _render(
                     'commit', commit.message, commit.raw_id, commit.idx),
                 "commit_raw": commit.idx,
                 "compare": _render(
                     'compare', format_ref_id(ref_name, commit.raw_id)),
             })
 
         return data
 
 
 class RepoRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'repo_route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
 
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         repo_name = info['match']['repo_name']
         repo_model = repo.RepoModel()
         by_name_match = repo_model.get_by_repo_name(repo_name, cache=True)
 
         def redirect_if_creating(db_repo):
             if db_repo.repo_state in [repo.Repository.STATE_PENDING]:
                 raise HTTPFound(
                     request.route_path('repo_creating',
                                        repo_name=db_repo.repo_name))
 
         if by_name_match:
             # register this as request object we can re-use later
             request.db_repo = by_name_match
             redirect_if_creating(by_name_match)
             return True
 
         by_id_match = repo_model.get_repo_by_id(repo_name)
         if by_id_match:
             request.db_repo = by_id_match
             redirect_if_creating(by_id_match)
             return True
 
         return False
 
 
 class RepoTypeRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val or ['hg', 'git', 'svn']
 
     def text(self):
         return 'repo_accepted_type = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         rhodecode_db_repo = request.db_repo
 
         log.debug(
             '%s checking repo type for %s in %s',
             self.__class__.__name__, rhodecode_db_repo.repo_type, self.val)
 
         if rhodecode_db_repo.repo_type in self.val:
             return True
         else:
             log.warning('Current view is not supported for repo type:%s',
                         rhodecode_db_repo.repo_type)
             #
             # h.flash(h.literal(
             #     _('Action not supported for %s.' % rhodecode_repo.alias)),
             #     category='warning')
             # return redirect(
             #     route_path('repo_summary', repo_name=cls.rhodecode_db_repo.repo_name))
 
             return False
 
 
 class RepoGroupRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'repo_group_route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         repo_group_name = info['match']['repo_group_name']
         repo_group_model = repo_group.RepoGroupModel()
         by_name_match = repo_group_model.get_by_group_name(
             repo_group_name, cache=True)
 
         if by_name_match:
             # register this as request object we can re-use later
             request.db_repo_group = by_name_match
             return True
 
         return False
 
 
 class UserGroupRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'user_group_route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         user_group_id = info['match']['user_group_id']
         user_group_model = user_group.UserGroup()
         by_id_match = user_group_model.get(
             user_group_id, cache=True)
 
         if by_id_match:
             # register this as request object we can re-use later
             request.db_user_group = by_id_match
             return True
 
         return False
 
 
 class UserRoutePredicateBase(object):
     supports_default = None
 
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         raise NotImplementedError()
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         user_id = info['match']['user_id']
         user_model = user.User()
         by_id_match = user_model.get(
             user_id, cache=True)
 
         if by_id_match:
             # register this as request object we can re-use later
             request.db_user = by_id_match
             request.db_user_supports_default = self.supports_default
             return True
 
         return False
 
 
 class UserRoutePredicate(UserRoutePredicateBase):
     supports_default = False
 
     def text(self):
         return 'user_route = %s' % self.val
 
     phash = text
 
 
 class UserRouteWithDefaultPredicate(UserRoutePredicateBase):
     supports_default = True
 
     def text(self):
         return 'user_with_default_route = %s' % self.val
 
     phash = text
 
 
 def includeme(config):
     config.add_route_predicate(
         'repo_route', RepoRoutePredicate)
     config.add_route_predicate(
         'repo_accepted_types', RepoTypeRoutePredicate)
     config.add_route_predicate(
         'repo_group_route', RepoGroupRoutePredicate)
     config.add_route_predicate(
         'user_group_route', UserGroupRoutePredicate)
     config.add_route_predicate(
         'user_route_with_default', UserRouteWithDefaultPredicate)
     config.add_route_predicate(
         'user_route', UserRoutePredicate)
  No newline at end of file

rhodecode/apps/admin/__init__.py

@@ -1,312 +1,325 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.admin.navigation import NavigationRegistry
 from rhodecode.config.routing 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')
 
     # 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):
     settings = config.get_settings()
 
     # Create admin navigation registry and add it to the pyramid registry.
     labs_active = str2bool(settings.get('labs_settings_active', False))
     navigation_registry = NavigationRegistry(labs_active=labs_active)
     config.registry.registerUtility(navigation_registry)
 
     # 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/repo_group/__init__.py

@@ -1,33 +1,61 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 add_route_with_slash
 
 
 def includeme(config):
 
-    # Summary
+    # Settings
+    config.add_route(
+        name='edit_repo_group',
+        pattern='/{repo_group_name:.*?[^/]}/_edit',
+        repo_group_route=True)
+    # update is POST on edit_repo_group
+
+    # Settings advanced
+    config.add_route(
+        name='edit_repo_group_advanced',
+        pattern='/{repo_group_name:.*?[^/]}/_settings/advanced',
+        repo_group_route=True)
+
+    config.add_route(
+        name='edit_repo_group_advanced_delete',
+        pattern='/{repo_group_name:.*?[^/]}/_settings/advanced/delete',
+        repo_group_route=True)
+
+    # settings permissions
+    config.add_route(
+        name='edit_repo_group_perms',
+        pattern='/{repo_group_name:.*?[^/]}/_settings/permissions',
+        repo_group_route=True)
+
+    config.add_route(
+        name='edit_repo_group_perms_update',
+        pattern='/{repo_group_name:.*?[^/]}/_settings/permissions/update',
+        repo_group_route=True)
+
+    # Summary, NOTE(marcink): needs to be at the end for catch-all
     add_route_with_slash(
         config,
         name='repo_group_home',
         pattern='/{repo_group_name:.*?[^/]}', repo_group_route=True)
 
     # Scan module for configuration decorators.
     config.scan('.views', ignore='.tests')
-

rhodecode/apps/repo_group/tests/__init__.py

@@ -0,0 +1,19 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/

rhodecode/apps/repository/__init__.py

@@ -1,455 +1,455 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 add_route_with_slash
 
 
 def includeme(config):
 
     # repo creating checks, special cases that aren't repo routes
     config.add_route(
         name='repo_creating',
         pattern='/{repo_name:.*?[^/]}/repo_creating')
 
     config.add_route(
         name='repo_creating_check',
         pattern='/{repo_name:.*?[^/]}/repo_creating_check')
 
     # Summary
     # NOTE(marcink): one additional route is defined in very bottom, catch
     # all pattern
     config.add_route(
         name='repo_summary_explicit',
         pattern='/{repo_name:.*?[^/]}/summary', repo_route=True)
     config.add_route(
         name='repo_summary_commits',
         pattern='/{repo_name:.*?[^/]}/summary-commits', repo_route=True)
 
     # Commits
     config.add_route(
         name='repo_commit',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_children',
         pattern='/{repo_name:.*?[^/]}/changeset_children/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_parents',
         pattern='/{repo_name:.*?[^/]}/changeset_parents/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_raw',
         pattern='/{repo_name:.*?[^/]}/changeset-diff/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_patch',
         pattern='/{repo_name:.*?[^/]}/changeset-patch/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_download',
         pattern='/{repo_name:.*?[^/]}/changeset-download/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_data',
         pattern='/{repo_name:.*?[^/]}/changeset-data/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_create',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/create', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_preview',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/preview', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_delete',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/{comment_id}/delete', repo_route=True)
 
     # still working url for backward compat.
     config.add_route(
         name='repo_commit_raw_deprecated',
         pattern='/{repo_name:.*?[^/]}/raw-changeset/{commit_id}', repo_route=True)
 
     # Files
     config.add_route(
         name='repo_archivefile',
         pattern='/{repo_name:.*?[^/]}/archive/{fname}', repo_route=True)
 
     config.add_route(
         name='repo_files_diff',
         pattern='/{repo_name:.*?[^/]}/diff/{f_path:.*}', repo_route=True)
     config.add_route(  # legacy route to make old links work
         name='repo_files_diff_2way_redirect',
         pattern='/{repo_name:.*?[^/]}/diff-2way/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files',
         pattern='/{repo_name:.*?[^/]}/files/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_files:default_path',
         pattern='/{repo_name:.*?[^/]}/files/{commit_id}/', repo_route=True)
     config.add_route(
         name='repo_files:default_commit',
         pattern='/{repo_name:.*?[^/]}/files', repo_route=True)
 
     config.add_route(
         name='repo_files:rendered',
         pattern='/{repo_name:.*?[^/]}/render/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files:annotated',
         pattern='/{repo_name:.*?[^/]}/annotate/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_files:annotated_previous',
         pattern='/{repo_name:.*?[^/]}/annotate-previous/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_nodetree_full',
         pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_nodetree_full:default_path',
         pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/', repo_route=True)
 
     config.add_route(
         name='repo_files_nodelist',
         pattern='/{repo_name:.*?[^/]}/nodelist/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_raw',
         pattern='/{repo_name:.*?[^/]}/raw/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_download',
         pattern='/{repo_name:.*?[^/]}/download/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(  # backward compat to keep old links working
         name='repo_file_download:legacy',
         pattern='/{repo_name:.*?[^/]}/rawfile/{commit_id}/{f_path:.*}',
         repo_route=True)
 
     config.add_route(
         name='repo_file_history',
         pattern='/{repo_name:.*?[^/]}/history/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_authors',
         pattern='/{repo_name:.*?[^/]}/authors/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files_remove_file',
         pattern='/{repo_name:.*?[^/]}/remove_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_delete_file',
         pattern='/{repo_name:.*?[^/]}/delete_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_edit_file',
         pattern='/{repo_name:.*?[^/]}/edit_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_update_file',
         pattern='/{repo_name:.*?[^/]}/update_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_add_file',
         pattern='/{repo_name:.*?[^/]}/add_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_create_file',
         pattern='/{repo_name:.*?[^/]}/create_file/{commit_id}/{f_path:.*}',
         repo_route=True)
 
     # Refs data
     config.add_route(
         name='repo_refs_data',
         pattern='/{repo_name:.*?[^/]}/refs-data', repo_route=True)
 
     config.add_route(
         name='repo_refs_changelog_data',
         pattern='/{repo_name:.*?[^/]}/refs-data-changelog', repo_route=True)
 
     config.add_route(
         name='repo_stats',
         pattern='/{repo_name:.*?[^/]}/repo_stats/{commit_id}', repo_route=True)
 
     # Changelog
     config.add_route(
         name='repo_changelog',
         pattern='/{repo_name:.*?[^/]}/changelog', repo_route=True)
     config.add_route(
         name='repo_changelog_file',
         pattern='/{repo_name:.*?[^/]}/changelog/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_changelog_elements',
         pattern='/{repo_name:.*?[^/]}/changelog_elements', repo_route=True)
     config.add_route(
         name='repo_changelog_elements_file',
         pattern='/{repo_name:.*?[^/]}/changelog_elements/{commit_id}/{f_path:.*}', repo_route=True)
 
     # Compare
     config.add_route(
         name='repo_compare_select',
         pattern='/{repo_name:.*?[^/]}/compare', repo_route=True)
 
     config.add_route(
         name='repo_compare',
         pattern='/{repo_name:.*?[^/]}/compare/{source_ref_type}@{source_ref:.*?}...{target_ref_type}@{target_ref:.*?}', repo_route=True)
 
     # Tags
     config.add_route(
         name='tags_home',
         pattern='/{repo_name:.*?[^/]}/tags', repo_route=True)
 
     # Branches
     config.add_route(
         name='branches_home',
         pattern='/{repo_name:.*?[^/]}/branches', repo_route=True)
 
     # Bookmarks
     config.add_route(
         name='bookmarks_home',
         pattern='/{repo_name:.*?[^/]}/bookmarks', repo_route=True)
 
     # Forks
     config.add_route(
         name='repo_fork_new',
         pattern='/{repo_name:.*?[^/]}/fork', repo_route=True,
         repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='repo_fork_create',
         pattern='/{repo_name:.*?[^/]}/fork/create', repo_route=True,
         repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='repo_forks_show_all',
         pattern='/{repo_name:.*?[^/]}/forks', repo_route=True,
         repo_accepted_types=['hg', 'git'])
     config.add_route(
         name='repo_forks_data',
         pattern='/{repo_name:.*?[^/]}/forks/data', repo_route=True,
         repo_accepted_types=['hg', 'git'])
 
     # Pull Requests
     config.add_route(
         name='pullrequest_show',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_show_all',
         pattern='/{repo_name:.*?[^/]}/pull-request',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_show_all_data',
         pattern='/{repo_name:.*?[^/]}/pull-request-data',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_repo_refs',
         pattern='/{repo_name:.*?[^/]}/pull-request/refs/{target_repo_name:.*?[^/]}',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_repo_destinations',
         pattern='/{repo_name:.*?[^/]}/pull-request/repo-destinations',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_new',
         pattern='/{repo_name:.*?[^/]}/pull-request/new',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_create',
         pattern='/{repo_name:.*?[^/]}/pull-request/create',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_update',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/update',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_merge',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/merge',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_delete',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/delete',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_comment_create',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_comment_delete',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment/{comment_id}/delete',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     # Settings
     config.add_route(
         name='edit_repo',
         pattern='/{repo_name:.*?[^/]}/settings', repo_route=True)
+    # update is POST on edit_repo
 
     # Settings advanced
     config.add_route(
         name='edit_repo_advanced',
         pattern='/{repo_name:.*?[^/]}/settings/advanced', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_delete',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/delete', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_locking',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/locking', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_journal',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/journal', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_fork',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/fork', repo_route=True)
 
     # Caches
     config.add_route(
         name='edit_repo_caches',
         pattern='/{repo_name:.*?[^/]}/settings/caches', repo_route=True)
 
     # Permissions
     config.add_route(
         name='edit_repo_perms',
         pattern='/{repo_name:.*?[^/]}/settings/permissions', repo_route=True)
 
     # Maintenance
     config.add_route(
         name='edit_repo_maintenance',
         pattern='/{repo_name:.*?[^/]}/settings/maintenance', repo_route=True)
 
     config.add_route(
         name='edit_repo_maintenance_execute',
         pattern='/{repo_name:.*?[^/]}/settings/maintenance/execute', repo_route=True)
 
     # Fields
     config.add_route(
         name='edit_repo_fields',
         pattern='/{repo_name:.*?[^/]}/settings/fields', repo_route=True)
     config.add_route(
         name='edit_repo_fields_create',
         pattern='/{repo_name:.*?[^/]}/settings/fields/create', repo_route=True)
     config.add_route(
         name='edit_repo_fields_delete',
         pattern='/{repo_name:.*?[^/]}/settings/fields/{field_id}/delete', repo_route=True)
 
     # Locking
     config.add_route(
         name='repo_edit_toggle_locking',
         pattern='/{repo_name:.*?[^/]}/settings/toggle_locking', repo_route=True)
 
     # Remote
     config.add_route(
         name='edit_repo_remote',
         pattern='/{repo_name:.*?[^/]}/settings/remote', repo_route=True)
     config.add_route(
         name='edit_repo_remote_pull',
         pattern='/{repo_name:.*?[^/]}/settings/remote/pull', repo_route=True)
 
-
     # Statistics
     config.add_route(
         name='edit_repo_statistics',
         pattern='/{repo_name:.*?[^/]}/settings/statistics', repo_route=True)
     config.add_route(
         name='edit_repo_statistics_reset',
         pattern='/{repo_name:.*?[^/]}/settings/statistics/update', repo_route=True)
 
     # Issue trackers
     config.add_route(
         name='edit_repo_issuetracker',
         pattern='/{repo_name:.*?[^/]}/settings/issue_trackers', repo_route=True)
     config.add_route(
         name='edit_repo_issuetracker_test',
         pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/test', repo_route=True)
     config.add_route(
         name='edit_repo_issuetracker_delete',
         pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/delete', repo_route=True)
     config.add_route(
         name='edit_repo_issuetracker_update',
         pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/update', repo_route=True)
 
     # VCS Settings
     config.add_route(
         name='edit_repo_vcs',
         pattern='/{repo_name:.*?[^/]}/settings/vcs', repo_route=True)
     config.add_route(
         name='edit_repo_vcs_update',
         pattern='/{repo_name:.*?[^/]}/settings/vcs/update', repo_route=True)
 
     # svn pattern
     config.add_route(
         name='edit_repo_vcs_svn_pattern_delete',
         pattern='/{repo_name:.*?[^/]}/settings/vcs/svn_pattern/delete', repo_route=True)
 
     # Repo Review Rules (EE feature)
     config.add_route(
         name='repo_reviewers',
         pattern='/{repo_name:.*?[^/]}/settings/review/rules', repo_route=True)
 
     config.add_route(
         name='repo_default_reviewers_data',
         pattern='/{repo_name:.*?[^/]}/settings/review/default-reviewers', repo_route=True)
 
     # Strip
     config.add_route(
         name='edit_repo_strip',
         pattern='/{repo_name:.*?[^/]}/settings/strip', repo_route=True)
 
     config.add_route(
         name='strip_check',
         pattern='/{repo_name:.*?[^/]}/settings/strip_check', repo_route=True)
 
     config.add_route(
         name='strip_execute',
         pattern='/{repo_name:.*?[^/]}/settings/strip_execute', repo_route=True)
 
     # Audit logs
     config.add_route(
         name='edit_repo_audit_logs',
         pattern='/{repo_name:.*?[^/]}/settings/audit_logs', repo_route=True)
 
     # ATOM/RSS Feed
     config.add_route(
         name='rss_feed_home',
         pattern='/{repo_name:.*?[^/]}/feed/rss', repo_route=True)
 
     config.add_route(
         name='atom_feed_home',
         pattern='/{repo_name:.*?[^/]}/feed/atom', repo_route=True)
 
     # NOTE(marcink): needs to be at the end for catch-all
     add_route_with_slash(
         config,
         name='repo_summary',
         pattern='/{repo_name:.*?[^/]}', repo_route=True)
 
     # Scan module for configuration decorators.
     config.scan('.views', ignore='.tests')

rhodecode/apps/repository/tests/__init__.py

@@ -0,0 +1,19 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/

rhodecode/apps/repository/tests/test_repo_settings.py

@@ -1,232 +1,232 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
 
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model.db import Repository, UserRepoToPerm, Permission, User
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, assert_session_flash)
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
 
     base_url = {
         'edit_repo': '/{repo_name}/settings',
         'edit_repo_advanced': '/{repo_name}/settings/advanced',
         'edit_repo_caches': '/{repo_name}/settings/caches',
         'edit_repo_perms': '/{repo_name}/settings/permissions',
         'edit_repo_vcs': '/{repo_name}/settings/vcs',
         'edit_repo_issuetracker': '/{repo_name}/settings/issue_trackers',
         'edit_repo_fields': '/{repo_name}/settings/fields',
         'edit_repo_remote': '/{repo_name}/settings/remote',
         'edit_repo_statistics': '/{repo_name}/settings/statistics',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminRepoSettings(object):
     @pytest.mark.parametrize('urlname', [
         'edit_repo',
         'edit_repo_caches',
         'edit_repo_perms',
         'edit_repo_advanced',
         'edit_repo_vcs',
         'edit_repo_issuetracker',
         'edit_repo_fields',
         'edit_repo_remote',
         'edit_repo_statistics',
     ])
     def test_show_page(self, urlname, app, backend):
         app.get(route_path(urlname, repo_name=backend.repo_name), status=200)
 
     def test_edit_accessible_when_missing_requirements(
             self, backend_hg, autologin_user):
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
         with scm_patcher:
             self.app.get(route_path('edit_repo', repo_name=backend_hg.repo_name))
 
     @pytest.mark.parametrize('update_settings', [
         {'repo_description': 'alter-desc'},
         {'repo_owner': TEST_USER_REGULAR_LOGIN},
         {'repo_private': 'true'},
         {'repo_enable_locking': 'true'},
         {'repo_enable_downloads': 'true'},
     ])
     def test_update_repo_settings(self, update_settings, csrf_token, backend, user_util):
         repo = user_util.create_repo(repo_type=backend.alias)
         repo_name = repo.repo_name
 
         params = fixture._get_repo_create_params(
                 csrf_token=csrf_token,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_owner=TEST_USER_ADMIN_LOGIN,
                 repo_description='DESC',
 
                 repo_private='false',
                 repo_enable_locking='false',
                 repo_enable_downloads='false')
         params.update(update_settings)
         self.app.post(
             route_path('edit_repo', repo_name=repo_name),
             params=params, status=302)
 
         repo = Repository.get_by_repo_name(repo_name)
         assert repo.user.username == \
                update_settings.get('repo_owner', repo.user.username)
 
         assert repo.description == \
                update_settings.get('repo_description', repo.description)
 
         assert repo.private == \
                str2bool(update_settings.get(
                    'repo_private', repo.private))
 
         assert repo.enable_locking == \
                str2bool(update_settings.get(
                    'repo_enable_locking', repo.enable_locking))
 
         assert repo.enable_downloads == \
                str2bool(update_settings.get(
                    'repo_enable_downloads', repo.enable_downloads))
 
     def test_update_repo_name_via_settings(self, csrf_token, user_util, backend):
         repo = user_util.create_repo(repo_type=backend.alias)
         repo_name = repo.repo_name
 
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
         new_name = repo_group_name + '_' + repo_name
 
         params = fixture._get_repo_create_params(
                 csrf_token=csrf_token,
                 repo_name=new_name,
                 repo_type=backend.alias,
                 repo_owner=TEST_USER_ADMIN_LOGIN,
                 repo_description='DESC',
                 repo_private='false',
                 repo_enable_locking='false',
                 repo_enable_downloads='false')
         self.app.post(
             route_path('edit_repo', repo_name=repo_name),
             params=params, status=302)
         repo = Repository.get_by_repo_name(new_name)
         assert repo.repo_name == new_name
 
     def test_update_repo_group_via_settings(self, csrf_token, user_util, backend):
         repo = user_util.create_repo(repo_type=backend.alias)
         repo_name = repo.repo_name
 
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
         repo_group_id = repo_group.group_id
 
         new_name = repo_group_name + '/' + repo_name
         params = fixture._get_repo_create_params(
                 csrf_token=csrf_token,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_owner=TEST_USER_ADMIN_LOGIN,
                 repo_description='DESC',
                 repo_group=repo_group_id,
                 repo_private='false',
                 repo_enable_locking='false',
                 repo_enable_downloads='false')
         self.app.post(
             route_path('edit_repo', repo_name=repo_name),
             params=params, status=302)
         repo = Repository.get_by_repo_name(new_name)
         assert repo.repo_name == new_name
 
     def test_set_private_flag_sets_default_user_permissions_to_none(
             self, autologin_user, backend, csrf_token):
 
         # initially repository perm should be read
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.read'
         assert not backend.repo.private
 
         response = self.app.post(
             route_path('edit_repo', repo_name=backend.repo_name),
             params=fixture._get_repo_create_params(
                 repo_private='true',
                 repo_name=backend.repo_name,
                 repo_type=backend.alias,
                 repo_owner=TEST_USER_ADMIN_LOGIN,
                 csrf_token=csrf_token), status=302)
 
         assert_session_flash(
             response,
-            msg='Repository %s updated successfully' % (backend.repo_name))
+            msg='Repository `%s` updated successfully' % (backend.repo_name))
 
         repo = Repository.get_by_repo_name(backend.repo_name)
         assert repo.private is True
 
         # now the repo default permission should be None
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.none'
 
         response = self.app.post(
             route_path('edit_repo', repo_name=backend.repo_name),
             params=fixture._get_repo_create_params(
                 repo_private='false',
                 repo_name=backend.repo_name,
                 repo_type=backend.alias,
                 repo_owner=TEST_USER_ADMIN_LOGIN,
                 csrf_token=csrf_token), status=302)
 
         assert_session_flash(
             response,
-            msg='Repository %s updated successfully' % (backend.repo_name))
+            msg='Repository `%s` updated successfully' % (backend.repo_name))
         assert backend.repo.private is False
 
         # we turn off private now the repo default permission should stay None
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.none'
 
         # update this permission back
         perm[0].permission = Permission.get_by_key('repository.read')
         Session().add(perm[0])
         Session().commit()

rhodecode/apps/repository/views/repo_settings.py

@@ -1,251 +1,251 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-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 deform
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.forms import RcForm
 from rhodecode.lib import helpers as h
 from rhodecode.lib import audit_logger
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired)
 from rhodecode.model.db import RepositoryField, RepoGroup, Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import RepoGroupList, ScmModel
 from rhodecode.model.validation_schema.schemas import repo_schema
 
 log = logging.getLogger(__name__)
 
 
 class RepoSettingsView(RepoAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         acl_groups = RepoGroupList(
             RepoGroup.query().all(),
             perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: k[0], c.repo_groups)
 
         # in case someone no longer have a group.write access to a repository
         # pre fill the list with this entry, we don't care if this is the same
         # but it will allow saving repo data properly.
         repo_group = self.db_repo.group
         if repo_group and repo_group.group_id not in c.repo_groups_choices:
             c.repo_groups_choices.append(repo_group.group_id)
             c.repo_groups.append(RepoGroup._generate_choice(repo_group))
 
         if c.repository_requirements_missing or self.rhodecode_vcs_repo is None:
             # we might be in missing requirement state, so we load things
             # without touching scm_instance()
             c.landing_revs_choices, c.landing_revs = \
                 ScmModel().get_repo_landing_revs()
         else:
             c.landing_revs_choices, c.landing_revs = \
                 ScmModel().get_repo_landing_revs(self.db_repo)
 
         c.personal_repo_group = c.auth_user.personal_repo_group
         c.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == self.db_repo).all()
 
         self._register_global_c(c)
         return c
 
     def _get_schema(self, c, old_values=None):
         return repo_schema.RepoSettingsSchema().bind(
             repo_type=self.db_repo.repo_type,
             repo_type_options=[self.db_repo.repo_type],
             repo_ref_options=c.landing_revs_choices,
             repo_ref_items=c.landing_revs,
             repo_repo_group_options=c.repo_groups_choices,
             repo_repo_group_items=c.repo_groups,
             # user caller
             user=self._rhodecode_user,
             old_values=old_values
         )
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @view_config(
         route_name='edit_repo', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def edit_settings(self):
         c = self.load_default_context()
         c.active = 'settings'
 
         defaults = RepoModel()._get_defaults(self.db_repo_name)
         defaults['repo_owner'] = defaults['user']
         defaults['repo_landing_commit_ref'] = defaults['repo_landing_rev']
 
         schema = self._get_schema(c)
         c.form = RcForm(schema, appstruct=defaults)
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='edit_repo', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def edit_settings_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'settings'
         old_repo_name = self.db_repo_name
 
         old_values = self.db_repo.get_api_data()
         schema = self._get_schema(c, old_values=old_values)
 
         c.form = RcForm(schema)
         pstruct = self.request.POST.items()
         pstruct.append(('repo_type', self.db_repo.repo_type))
         try:
             schema_data = c.form.validate(pstruct)
         except deform.ValidationFailure as err_form:
             return self._get_template_context(c)
 
         # data is now VALID, proceed with updates
         # save validated data back into the updates dict
         validated_updates = dict(
             repo_name=schema_data['repo_group']['repo_name_without_group'],
             repo_group=schema_data['repo_group']['repo_group_id'],
 
             user=schema_data['repo_owner'],
             repo_description=schema_data['repo_description'],
             repo_private=schema_data['repo_private'],
             clone_uri=schema_data['repo_clone_uri'],
             repo_landing_rev=schema_data['repo_landing_commit_ref'],
             repo_enable_statistics=schema_data['repo_enable_statistics'],
             repo_enable_locking=schema_data['repo_enable_locking'],
             repo_enable_downloads=schema_data['repo_enable_downloads'],
         )
         # detect if CLONE URI changed, if we get OLD means we keep old values
         if schema_data['repo_clone_uri_change'] == 'OLD':
             validated_updates['clone_uri'] = self.db_repo.clone_uri
 
         # use the new full name for redirect
         new_repo_name = schema_data['repo_group']['repo_name_with_group']
 
         # save extra fields into our validated data
         for key, value in pstruct:
             if key.startswith(RepositoryField.PREFIX):
                 validated_updates[key] = value
 
         try:
             RepoModel().update(self.db_repo, **validated_updates)
             ScmModel().mark_for_invalidation(new_repo_name)
 
             audit_logger.store_web(
                 'repo.edit', action_data={'old_data': old_values},
                 user=self._rhodecode_user, repo=self.db_repo)
 
             Session().commit()
 
-            h.flash(_('Repository {} updated successfully').format(
+            h.flash(_('Repository `{}` updated successfully').format(
                 old_repo_name), category='success')
         except Exception:
             log.exception("Exception during update of repository")
             h.flash(_('Error occurred during update of repository {}').format(
                 old_repo_name), category='error')
 
         raise HTTPFound(
             h.route_path('edit_repo', repo_name=new_repo_name))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @view_config(
         route_name='repo_edit_toggle_locking', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def toggle_locking(self):
         """
         Toggle locking of repository by simple GET call to url
         """
         _ = self.request.translate
         repo = self.db_repo
 
         try:
             if repo.enable_locking:
                 if repo.locked[0]:
                     Repository.unlock(repo)
                     action = _('Unlocked')
                 else:
                     Repository.lock(
                         repo, self._rhodecode_user.user_id,
                         lock_reason=Repository.LOCK_WEB)
                     action = _('Locked')
 
                 h.flash(_('Repository has been %s') % action,
                         category='success')
         except Exception:
             log.exception("Exception during unlocking")
             h.flash(_('An error occurred during unlocking'),
                     category='error')
         raise HTTPFound(
             h.route_path('repo_summary', repo_name=self.db_repo_name))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @view_config(
         route_name='edit_repo_statistics', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def edit_statistics_form(self):
         c = self.load_default_context()
 
         if self.db_repo.stats:
             # this is on what revision we ended up so we add +1 for count
             last_rev = self.db_repo.stats.stat_on_revision + 1
         else:
             last_rev = 0
 
         c.active = 'statistics'
         c.stats_revision = last_rev
         c.repo_last_rev = self.rhodecode_vcs_repo.count()
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
         else:
             c.stats_percentage = '%.2f' % (
             (float((last_rev)) / c.repo_last_rev) * 100)
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='edit_repo_statistics_reset', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def repo_statistics_reset(self):
         _ = self.request.translate
 
         try:
             RepoModel().delete_stats(self.db_repo_name)
             Session().commit()
         except Exception:
             log.exception('Edit statistics failure')
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
         raise HTTPFound(
             h.route_path('edit_repo_statistics', repo_name=self.db_repo_name))

rhodecode/config/routing.py

@@ -1,311 +1,264 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 REPOSITORY GROUPS ROUTES
-    with rmap.submapper(path_prefix=ADMIN_PREFIX,
-                        controller='admin/repo_groups') as m:
-        m.connect('repo_groups', '/repo_groups',
-                  action='create', conditions={'method': ['POST']})
-        m.connect('repo_groups', '/repo_groups',
-                  action='index', conditions={'method': ['GET']})
-        m.connect('new_repo_group', '/repo_groups/new',
-                  action='new', conditions={'method': ['GET']})
-        m.connect('update_repo_group', '/repo_groups/{group_name}',
-                  action='update', conditions={'method': ['PUT'],
-                                               'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-
-        # EXTRAS REPO GROUP ROUTES
-        m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
-                  action='edit',
-                  conditions={'method': ['GET'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-        m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
-                  action='edit',
-                  conditions={'method': ['PUT'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-
-        m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
-                  action='edit_repo_group_advanced',
-                  conditions={'method': ['GET'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-        m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
-                  action='edit_repo_group_advanced',
-                  conditions={'method': ['PUT'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-
-        m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
-                  action='edit_repo_group_perms',
-                  conditions={'method': ['GET'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-        m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
-                  action='update_perms',
-                  conditions={'method': ['PUT'], 'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-
-        m.connect('delete_repo_group', '/repo_groups/{group_name}',
-                  action='delete', conditions={'method': ['DELETE'],
-                                               'function': check_group},
-                  requirements=URL_NAME_REQUIREMENTS)
-
     # 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_supervisor', '/settings/supervisor',
                   action='settings_supervisor', conditions={'method': ['GET']})
         m.connect('admin_settings_supervisor_log', '/settings/supervisor/{procid}/log',
                   action='settings_supervisor_log', 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/integrations/routes.py

@@ -1,230 +1,230 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-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
 
 from rhodecode.apps._base import ADMIN_PREFIX, add_route_requirements
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.model.db import Repository, Integration, RepoGroup
 from rhodecode.integrations import integration_type_registry
 
 log = logging.getLogger(__name__)
 
 
 def includeme(config):
 
     # global integrations
     config.add_route('global_integrations_new',
                      ADMIN_PREFIX + '/integrations/new')
     config.add_view('rhodecode.integrations.views.GlobalIntegrationsView',
                     attr='new_integration',
                     renderer='rhodecode:templates/admin/integrations/new.mako',
                     request_method='GET',
                     route_name='global_integrations_new')
 
     config.add_route('global_integrations_home',
                      ADMIN_PREFIX + '/integrations')
     config.add_route('global_integrations_list',
                      ADMIN_PREFIX + '/integrations/{integration}')
     for route_name in ['global_integrations_home', 'global_integrations_list']:
         config.add_view('rhodecode.integrations.views.GlobalIntegrationsView',
                         attr='integration_list',
                         renderer='rhodecode:templates/admin/integrations/list.mako',
                         request_method='GET',
                         route_name=route_name)
 
     config.add_route('global_integrations_create',
                      ADMIN_PREFIX + '/integrations/{integration}/new',
                      custom_predicates=(valid_integration,))
     config.add_route('global_integrations_edit',
                      ADMIN_PREFIX + '/integrations/{integration}/{integration_id}',
                      custom_predicates=(valid_integration,))
 
     for route_name in ['global_integrations_create', 'global_integrations_edit']:
         config.add_view('rhodecode.integrations.views.GlobalIntegrationsView',
                         attr='settings_get',
                         renderer='rhodecode:templates/admin/integrations/form.mako',
                         request_method='GET',
                         route_name=route_name)
         config.add_view('rhodecode.integrations.views.GlobalIntegrationsView',
                         attr='settings_post',
                         renderer='rhodecode:templates/admin/integrations/form.mako',
                         request_method='POST',
                         route_name=route_name)
 
     # repo group integrations
     config.add_route('repo_group_integrations_home',
-                     add_route_requirements('/{repo_group_name}/settings/integrations'),
+                     add_route_requirements('/{repo_group_name}/_settings/integrations'),
                      repo_group_route=True)
 
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='integration_list',
                     renderer='rhodecode:templates/admin/integrations/list.mako',
                     request_method='GET',
                     route_name='repo_group_integrations_home')
 
     config.add_route('repo_group_integrations_new',
-                     add_route_requirements('/{repo_group_name}/settings/integrations/new'),
+                     add_route_requirements('/{repo_group_name}/_settings/integrations/new'),
                      repo_group_route=True)
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='new_integration',
                     renderer='rhodecode:templates/admin/integrations/new.mako',
                     request_method='GET',
                     route_name='repo_group_integrations_new')
 
     config.add_route('repo_group_integrations_list',
-                     add_route_requirements('/{repo_group_name}/settings/integrations/{integration}'),
+                     add_route_requirements('/{repo_group_name}/_settings/integrations/{integration}'),
                      repo_group_route=True,
                      custom_predicates=(valid_integration,))
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='integration_list',
                     renderer='rhodecode:templates/admin/integrations/list.mako',
                     request_method='GET',
                     route_name='repo_group_integrations_list')
 
     config.add_route('repo_group_integrations_create',
-                     add_route_requirements('/{repo_group_name}/settings/integrations/{integration}/new'),
+                     add_route_requirements('/{repo_group_name}/_settings/integrations/{integration}/new'),
                      repo_group_route=True,
                      custom_predicates=(valid_integration,))
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='settings_get',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='GET',
                     route_name='repo_group_integrations_create')
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='settings_post',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='POST',
                     route_name='repo_group_integrations_create')
 
     config.add_route('repo_group_integrations_edit',
-                     add_route_requirements('/{repo_group_name}/settings/integrations/{integration}/{integration_id}'),
+                     add_route_requirements('/{repo_group_name}/_settings/integrations/{integration}/{integration_id}'),
                      repo_group_route=True,
                      custom_predicates=(valid_integration,))
 
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='settings_get',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='GET',
                     route_name='repo_group_integrations_edit')
     config.add_view('rhodecode.integrations.views.RepoGroupIntegrationsView',
                     attr='settings_post',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='POST',
                     route_name='repo_group_integrations_edit')
 
     # repo integrations
     config.add_route('repo_integrations_home',
                      add_route_requirements('/{repo_name}/settings/integrations'),
                      repo_route=True)
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='integration_list',
                     request_method='GET',
                     renderer='rhodecode:templates/admin/integrations/list.mako',
                     route_name='repo_integrations_home')
 
     config.add_route('repo_integrations_new',
                      add_route_requirements('/{repo_name}/settings/integrations/new'),
                      repo_route=True)
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='new_integration',
                     renderer='rhodecode:templates/admin/integrations/new.mako',
                     request_method='GET',
                     route_name='repo_integrations_new')
 
     config.add_route('repo_integrations_list',
                      add_route_requirements('/{repo_name}/settings/integrations/{integration}'),
                      repo_route=True,
                      custom_predicates=(valid_integration,))
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='integration_list',
                     request_method='GET',
                     renderer='rhodecode:templates/admin/integrations/list.mako',
                     route_name='repo_integrations_list')
 
     config.add_route('repo_integrations_create',
                      add_route_requirements('/{repo_name}/settings/integrations/{integration}/new'),
                      repo_route=True,
                      custom_predicates=(valid_integration,))
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='settings_get',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='GET',
                     route_name='repo_integrations_create')
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='settings_post',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='POST',
                     route_name='repo_integrations_create')
 
     config.add_route('repo_integrations_edit',
                      add_route_requirements('/{repo_name}/settings/integrations/{integration}/{integration_id}'),
                      repo_route=True,
                      custom_predicates=(valid_integration,))
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='settings_get',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='GET',
                     route_name='repo_integrations_edit')
     config.add_view('rhodecode.integrations.views.RepoIntegrationsView',
                     attr='settings_post',
                     renderer='rhodecode:templates/admin/integrations/form.mako',
                     request_method='POST',
                     route_name='repo_integrations_edit')
 
 
 
 def valid_integration(info, request):
     integration_type = info['match']['integration']
     integration_id = info['match'].get('integration_id')
 
     if integration_type not in integration_type_registry:
         return False
 
     if integration_id:
         if not safe_int(integration_id):
             return False
 
         integration = Integration.get(integration_id)
         if not integration:
             return False
         if integration.integration_type != integration_type:
             return False
 
         # match types to repo or repo group
         repo_name = info['match'].get('repo_name')
         repo_group_name = info['match'].get('repo_group_name')
         repo, repo_group = None, None
         if repo_name:
             repo = Repository.get_by_repo_name(repo_name)
             if not repo:
                 return False
 
         if repo_group_name:
             repo_group = RepoGroup.get_by_group_name(repo_group_name)
             if not repo_group:
                 return False
 
         if repo and repo.repo_id != integration.repo_id:
             return False
         if repo_group and repo_group.group_id != integration.repo_group_id:
             return False
 
     return True

rhodecode/integrations/tests/test_integrations.py

@@ -1,269 +1,269 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 pytest
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.model.db import Integration
 from rhodecode.model.meta import Session
 from rhodecode.integrations import integration_type_registry
 
 
 def route_path(name, **kwargs):
     return {
         'home': '/',
     }[name].format(**kwargs)
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationsView(object):
     pass
 
 
 class TestGlobalIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self):
         url = ADMIN_PREFIX + '/integrations'
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(self, global_integration_stub):
         url = ADMIN_PREFIX + '/integrations'
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(no=['exist yet'])
         response.mustcontain(global_integration_stub.name)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_new_integration_page(self, IntegrationType):
         url = ADMIN_PREFIX + '/integrations/new'
 
         response = self.app.get(url, status=200)
         if not IntegrationType.is_dummy:
             url = (ADMIN_PREFIX + '/integrations/{integration}/new').format(
                     integration=IntegrationType.key)
             response.mustcontain(url)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, IntegrationType):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=IntegrationType.key)
         if IntegrationType.is_dummy:
             self.app.get(url, status=404)
         else:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
 
     def test_post_integration_page(self, StubIntegrationType, csrf_token,
                                    test_repo_group, backend_random):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(
             self.app, url, csrf_token, admin_view=True,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, backend_random):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=backend_random.repo.repo_name)
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(self, repo_integration_stub):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=repo_integration_stub.repo.repo_name)
         stub_name = repo_integration_stub.name
 
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(stub_name)
         response.mustcontain(no=['exist yet'])
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_new_integration_page(self, backend_random, IntegrationType):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/new'.format(
             repo_name=repo_name)
 
         response = self.app.get(url, status=200)
 
         url = '/{repo_name}/settings/integrations/{integration}/new'.format(
                 repo_name=repo_name,
                 integration=IntegrationType.key)
         if not IntegrationType.is_dummy:
             response.mustcontain(url)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, backend_random, IntegrationType):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/{integration_key}/new'.format(
             repo_name=repo_name, integration_key=IntegrationType.key)
         if IntegrationType.is_dummy:
             self.app.get(url, status=404)
         else:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
 
     def test_post_integration_page(self, backend_random, test_repo_group,
                                    StubIntegrationType, csrf_token):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/{integration_key}/new'.format(
             repo_name=repo_name, integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(
             self.app, url, csrf_token, admin_view=False,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoGroupIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, test_repo_group):
-        url = '/{repo_group_name}/settings/integrations'.format(
+        url = '/{repo_group_name}/_settings/integrations'.format(
             repo_group_name=test_repo_group.group_name)
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(
             self, test_repo_group, repogroup_integration_stub):
 
-        url = '/{repo_group_name}/settings/integrations'.format(
+        url = '/{repo_group_name}/_settings/integrations'.format(
             repo_group_name=test_repo_group.group_name)
 
         stub_name = repogroup_integration_stub.name
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(no=['exist yet'])
         response.mustcontain(stub_name)
 
     def test_new_integration_page(self, test_repo_group):
         repo_group_name = test_repo_group.group_name
-        url = '/{repo_group_name}/settings/integrations/new'.format(
+        url = '/{repo_group_name}/_settings/integrations/new'.format(
             repo_group_name=test_repo_group.group_name)
 
         response = self.app.get(url)
 
         assert response.status_code == 200
 
         for integration_key, integration_obj in integration_type_registry.items():
             if not integration_obj.is_dummy:
                 nurl = (
-                    '/{repo_group_name}/settings/integrations/{integration}/new').format(
+                    '/{repo_group_name}/_settings/integrations/{integration}/new').format(
                     repo_group_name=repo_group_name,
                     integration=integration_key)
                 response.mustcontain(nurl)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(
             self, test_repo_group, IntegrationType):
 
         repo_group_name = test_repo_group.group_name
-        url = ('/{repo_group_name}/settings/integrations/{integration_key}/new'
+        url = ('/{repo_group_name}/_settings/integrations/{integration_key}/new'
                ).format(repo_group_name=repo_group_name,
                         integration_key=IntegrationType.key)
 
         if not IntegrationType.is_dummy:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
         else:
             self.app.get(url, status=404)
 
     def test_post_integration_page(self, test_repo_group, backend_random,
                                    StubIntegrationType, csrf_token):
 
         repo_group_name = test_repo_group.group_name
-        url = ('/{repo_group_name}/settings/integrations/{integration_key}/new'
+        url = ('/{repo_group_name}/_settings/integrations/{integration_key}/new'
                ).format(repo_group_name=repo_group_name,
                         integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(
             self.app, url, csrf_token, admin_view=False,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 def _post_integration_test_helper(app, url, csrf_token, repo, repo_group,
                                   admin_view):
     """
     Posts form data to create integration at the url given then deletes it and
     checks if the redirect url is correct.
     """
     repo_name = repo.repo_name
     repo_group_name = repo_group.group_name
     app.post(url, params={}, status=403)  # missing csrf check
     response = app.post(url, params={'csrf_token': csrf_token})
     assert response.status_code == 200
     response.mustcontain('Errors exist')
 
     scopes_destinations = [
         ('global',
                 ADMIN_PREFIX + '/integrations'),
         ('root-repos',
                 ADMIN_PREFIX + '/integrations'),
         ('repo:%s' % repo_name,
                 '/%s/settings/integrations' % repo_name),
         ('repogroup:%s' % repo_group_name,
-                '/%s/settings/integrations' % repo_group_name),
+                '/%s/_settings/integrations' % repo_group_name),
         ('repogroup-recursive:%s' % repo_group_name,
-                '/%s/settings/integrations' % repo_group_name),
+                '/%s/_settings/integrations' % repo_group_name),
     ]
 
     for scope, destination in scopes_destinations:
         if admin_view:
             destination = ADMIN_PREFIX + '/integrations'
 
         form_data = [
             ('csrf_token', csrf_token),
             ('__start__', 'options:mapping'),
             ('name', 'test integration'),
             ('scope', scope),
             ('enabled', 'true'),
             ('__end__', 'options:mapping'),
             ('__start__', 'settings:mapping'),
             ('test_int_field', '34'),
             ('test_string_field', ''), # empty value on purpose as it's required
             ('__end__', 'settings:mapping'),
         ]
         errors_response = app.post(url, form_data)
         assert 'Errors exist' in errors_response.body
 
         form_data[-2] = ('test_string_field', 'data!')
         assert Session().query(Integration).count() == 0
         created_response = app.post(url, form_data)
         assert Session().query(Integration).count() == 1
 
         delete_response = app.post(
             created_response.location,
             params={'csrf_token': csrf_token, 'delete': 'delete'})
 
         assert Session().query(Integration).count() == 0
         assert delete_response.location.endswith(destination)

rhodecode/model/repo_group.py

@@ -1,738 +1,764 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-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/
 
 
 """
 repo group model for RhodeCode
 """
 
 import os
 import datetime
 import itertools
 import logging
 import shutil
 import traceback
 import string
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode import events
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (_hash_key,
     RepoGroup, UserRepoGroupToPerm, User, Permission, UserGroupRepoGroupToPerm,
     UserGroup, Repository)
 from rhodecode.model.settings import VcsSettingsModel, SettingsModel
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.utils2 import action_logger_generic, datetime_to_time
 
 log = logging.getLogger(__name__)
 
 
 class RepoGroupModel(BaseModel):
 
     cls = RepoGroup
     PERSONAL_GROUP_DESC = 'personal repo group of user `%(username)s`'
     PERSONAL_GROUP_PATTERN = '${username}'  # default
 
     def _get_user_group(self, users_group):
         return self._get_instance(UserGroup, users_group,
                                   callback=UserGroup.get_by_group_name)
 
     def _get_repo_group(self, repo_group):
         return self._get_instance(RepoGroup, repo_group,
                                   callback=RepoGroup.get_by_group_name)
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
 
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def get_by_group_name(self, repo_group_name, cache=None):
         repo = self.sa.query(RepoGroup) \
             .filter(RepoGroup.group_name == repo_group_name)
 
         if cache:
             name_key = _hash_key(repo_group_name)
             repo = repo.options(
                 FromCache("sql_cache_short", "get_repo_group_%s" % name_key))
         return repo.scalar()
 
     def get_default_create_personal_repo_group(self):
         value = SettingsModel().get_setting_by_name(
             'create_personal_repo_group')
         return value.app_settings_value if value else None or False
 
     def get_personal_group_name_pattern(self):
         value = SettingsModel().get_setting_by_name(
             'personal_repo_group_pattern')
         val = value.app_settings_value if value else None
         group_template = val or self.PERSONAL_GROUP_PATTERN
 
         group_template = group_template.lstrip('/')
         return group_template
 
     def get_personal_group_name(self, user):
         template = self.get_personal_group_name_pattern()
         return string.Template(template).safe_substitute(
             username=user.username,
             user_id=user.user_id,
         )
 
     def create_personal_repo_group(self, user, commit_early=True):
         desc = self.PERSONAL_GROUP_DESC % {'username': user.username}
         personal_repo_group_name = self.get_personal_group_name(user)
 
         # create a new one
         RepoGroupModel().create(
             group_name=personal_repo_group_name,
             group_description=desc,
             owner=user.username,
             personal=True,
             commit_early=commit_early)
 
     def _create_default_perms(self, new_group):
         # create default permission
         default_perm = 'group.read'
         def_user = User.get_default_user()
         for p in def_user.user_perms:
             if p.permission.permission_name.startswith('group.'):
                 default_perm = p.permission.permission_name
                 break
 
         repo_group_to_perm = UserRepoGroupToPerm()
         repo_group_to_perm.permission = Permission.get_by_key(default_perm)
 
         repo_group_to_perm.group = new_group
         repo_group_to_perm.user_id = def_user.user_id
         return repo_group_to_perm
 
     def _get_group_name_and_parent(self, group_name_full, repo_in_path=False,
                                    get_object=False):
         """
         Get's the group name and a parent group name from given group name.
         If repo_in_path is set to truth, we asume the full path also includes
         repo name, in such case we clean the last element.
 
         :param group_name_full:
         """
         split_paths = 1
         if repo_in_path:
             split_paths = 2
         _parts = group_name_full.rsplit(RepoGroup.url_sep(), split_paths)
 
         if repo_in_path and len(_parts) > 1:
             # such case last element is the repo_name
             _parts.pop(-1)
         group_name_cleaned = _parts[-1]  # just the group name
         parent_repo_group_name = None
 
         if len(_parts) > 1:
             parent_repo_group_name = _parts[0]
 
         parent_group = None
         if parent_repo_group_name:
             parent_group = RepoGroup.get_by_group_name(parent_repo_group_name)
 
         if get_object:
             return group_name_cleaned, parent_repo_group_name, parent_group
 
         return group_name_cleaned, parent_repo_group_name
 
     def check_exist_filesystem(self, group_name, exc_on_failure=True):
         create_path = os.path.join(self.repos_path, group_name)
         log.debug('creating new group in %s', create_path)
 
         if os.path.isdir(create_path):
             if exc_on_failure:
                 abs_create_path = os.path.abspath(create_path)
                 raise Exception('Directory `{}` already exists !'.format(abs_create_path))
             return False
         return True
 
     def _create_group(self, group_name):
         """
         makes repository group on filesystem
 
         :param repo_name:
         :param parent_id:
         """
 
         self.check_exist_filesystem(group_name)
         create_path = os.path.join(self.repos_path, group_name)
         log.debug('creating new group in %s', create_path)
         os.makedirs(create_path, mode=0755)
         log.debug('created group in %s', create_path)
 
     def _rename_group(self, old, new):
         """
         Renames a group on filesystem
 
         :param group_name:
         """
 
         if old == new:
             log.debug('skipping group rename')
             return
 
         log.debug('renaming repository group from %s to %s', old, new)
 
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
 
         log.debug('renaming repos paths from %s to %s', old_path, new_path)
 
         if os.path.isdir(new_path):
             raise Exception('Was trying to rename to already '
                             'existing dir %s' % new_path)
         shutil.move(old_path, new_path)
 
     def _delete_filesystem_group(self, group, force_delete=False):
         """
         Deletes a group from a filesystem
 
         :param group: instance of group from database
         :param force_delete: use shutil rmtree to remove all objects
         """
         paths = group.full_path.split(RepoGroup.url_sep())
         paths = os.sep.join(paths)
 
         rm_path = os.path.join(self.repos_path, paths)
         log.info("Removing group %s", rm_path)
         # delete only if that path really exists
         if os.path.isdir(rm_path):
             if force_delete:
                 shutil.rmtree(rm_path)
             else:
                 # archive that group`
                 _now = datetime.datetime.now()
                 _ms = str(_now.microsecond).rjust(6, '0')
                 _d = 'rm__%s_GROUP_%s' % (
                     _now.strftime('%Y%m%d_%H%M%S_' + _ms), group.name)
                 shutil.move(rm_path, os.path.join(self.repos_path, _d))
 
     def create(self, group_name, group_description, owner, just_db=False,
                copy_permissions=False, personal=None, commit_early=True):
 
         (group_name_cleaned,
          parent_group_name) = RepoGroupModel()._get_group_name_and_parent(group_name)
 
         parent_group = None
         if parent_group_name:
             parent_group = self._get_repo_group(parent_group_name)
             if not parent_group:
                 # we tried to create a nested group, but the parent is not
                 # existing
                 raise ValueError(
                     'Parent group `%s` given in `%s` group name '
                     'is not yet existing.' % (parent_group_name, group_name))
 
         # because we are doing a cleanup, we need to check if such directory
         # already exists. If we don't do that we can accidentally delete
         # existing directory via cleanup that can cause data issues, since
         # delete does a folder rename to special syntax later cleanup
         # functions can delete this
         cleanup_group = self.check_exist_filesystem(group_name,
                                                     exc_on_failure=False)
+        user = self._get_user(owner)
+        if not user:
+            raise ValueError('Owner %s not found as rhodecode user', owner)
+
         try:
-            user = self._get_user(owner)
             new_repo_group = RepoGroup()
             new_repo_group.user = user
             new_repo_group.group_description = group_description or group_name
             new_repo_group.parent_group = parent_group
             new_repo_group.group_name = group_name
             new_repo_group.personal = personal
 
             self.sa.add(new_repo_group)
 
             # create an ADMIN permission for owner except if we're super admin,
             # later owner should go into the owner field of groups
             if not user.is_admin:
                 self.grant_user_permission(repo_group=new_repo_group,
                                            user=owner, perm='group.admin')
 
             if parent_group and copy_permissions:
                 # copy permissions from parent
                 user_perms = UserRepoGroupToPerm.query() \
                     .filter(UserRepoGroupToPerm.group == parent_group).all()
 
                 group_perms = UserGroupRepoGroupToPerm.query() \
                     .filter(UserGroupRepoGroupToPerm.group == parent_group).all()
 
                 for perm in user_perms:
                     # don't copy over the permission for user who is creating
                     # this group, if he is not super admin he get's admin
                     # permission set above
                     if perm.user != user or user.is_admin:
                         UserRepoGroupToPerm.create(
                             perm.user, new_repo_group, perm.permission)
 
                 for perm in group_perms:
                     UserGroupRepoGroupToPerm.create(
                         perm.users_group, new_repo_group, perm.permission)
             else:
                 perm_obj = self._create_default_perms(new_repo_group)
                 self.sa.add(perm_obj)
 
             # now commit the changes, earlier so we are sure everything is in
             # the database.
             if commit_early:
                 self.sa.commit()
             if not just_db:
                 self._create_group(new_repo_group.group_name)
 
             # trigger the post hook
             from rhodecode.lib.hooks_base import log_create_repository_group
             repo_group = RepoGroup.get_by_group_name(group_name)
             log_create_repository_group(
                 created_by=user.username, **repo_group.get_dict())
 
             # Trigger create event.
             events.trigger(events.RepoGroupCreateEvent(repo_group))
 
             return new_repo_group
         except Exception:
             self.sa.rollback()
             log.exception('Exception occurred when creating repository group, '
                           'doing cleanup...')
             # rollback things manually !
             repo_group = RepoGroup.get_by_group_name(group_name)
             if repo_group:
                 RepoGroup.delete(repo_group.group_id)
                 self.sa.commit()
                 if cleanup_group:
                     RepoGroupModel()._delete_filesystem_group(repo_group)
             raise
 
     def update_permissions(
             self, repo_group, perm_additions=None, perm_updates=None,
             perm_deletions=None, recursive=None, check_perms=True,
             cur_user=None):
         from rhodecode.model.repo import RepoModel
         from rhodecode.lib.auth import HasUserGroupPermissionAny
 
         if not perm_additions:
             perm_additions = []
         if not perm_updates:
             perm_updates = []
         if not perm_deletions:
             perm_deletions = []
 
         req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')
 
         changes = {
             'added': [],
             'updated': [],
             'deleted': []
         }
 
         def _set_perm_user(obj, user, perm):
             if isinstance(obj, RepoGroup):
                 self.grant_user_permission(
                     repo_group=obj, user=user, perm=perm)
             elif isinstance(obj, Repository):
                 # private repos will not allow to change the default
                 # permissions using recursive mode
                 if obj.private and user == User.DEFAULT_USER:
                     return
 
                 # we set group permission but we have to switch to repo
                 # permission
                 perm = perm.replace('group.', 'repository.')
                 RepoModel().grant_user_permission(
                     repo=obj, user=user, perm=perm)
 
         def _set_perm_group(obj, users_group, perm):
             if isinstance(obj, RepoGroup):
                 self.grant_user_group_permission(
                     repo_group=obj, group_name=users_group, perm=perm)
             elif isinstance(obj, Repository):
                 # we set group permission but we have to switch to repo
                 # permission
                 perm = perm.replace('group.', 'repository.')
                 RepoModel().grant_user_group_permission(
                     repo=obj, group_name=users_group, perm=perm)
 
         def _revoke_perm_user(obj, user):
             if isinstance(obj, RepoGroup):
                 self.revoke_user_permission(repo_group=obj, user=user)
             elif isinstance(obj, Repository):
                 RepoModel().revoke_user_permission(repo=obj, user=user)
 
         def _revoke_perm_group(obj, user_group):
             if isinstance(obj, RepoGroup):
                 self.revoke_user_group_permission(
                     repo_group=obj, group_name=user_group)
             elif isinstance(obj, Repository):
                 RepoModel().revoke_user_group_permission(
                     repo=obj, group_name=user_group)
 
         # start updates
         log.debug('Now updating permissions for %s in recursive mode:%s',
                   repo_group, recursive)
 
         # initialize check function, we'll call that multiple times
         has_group_perm = HasUserGroupPermissionAny(*req_perms)
 
         for obj in repo_group.recursive_groups_and_repos():
             # iterated obj is an instance of a repos group or repository in
             # that group, recursive option can be: none, repos, groups, all
             if recursive == 'all':
                 obj = obj
             elif recursive == 'repos':
                 # skip groups, other than this one
                 if isinstance(obj, RepoGroup) and not obj == repo_group:
                     continue
             elif recursive == 'groups':
                 # skip repos
                 if isinstance(obj, Repository):
                     continue
             else:  # recursive == 'none':
                 #  DEFAULT option - don't apply to iterated objects
                 # also we do a break at the end of this loop. if we are not
                 # in recursive mode
                 obj = repo_group
 
             change_obj = obj.get_api_data()
 
             # update permissions
             for member_id, perm, member_type in perm_updates:
                 member_id = int(member_id)
                 if member_type == 'user':
                     member_name = User.get(member_id).username
                     # this updates also current one if found
                     _set_perm_user(obj, user=member_id, perm=perm)
                 else:  # set for user group
                     member_name = UserGroup.get(member_id).users_group_name
                     if not check_perms or has_group_perm(member_name,
                                                          user=cur_user):
                         _set_perm_group(obj, users_group=member_id, perm=perm)
 
                 changes['updated'].append(
                     {'change_obj': change_obj, 'type': member_type,
                      'id': member_id, 'name': member_name, 'new_perm': perm})
 
             # set new permissions
             for member_id, perm, member_type in perm_additions:
                 member_id = int(member_id)
                 if member_type == 'user':
                     member_name = User.get(member_id).username
                     _set_perm_user(obj, user=member_id, perm=perm)
                 else:  # set for user group
                     # check if we have permissions to alter this usergroup
                     member_name = UserGroup.get(member_id).users_group_name
                     if not check_perms or has_group_perm(member_name,
                                                          user=cur_user):
                         _set_perm_group(obj, users_group=member_id, perm=perm)
 
                 changes['added'].append(
                     {'change_obj': change_obj, 'type': member_type,
                      'id': member_id, 'name': member_name, 'new_perm': perm})
 
             # delete permissions
             for member_id, perm, member_type in perm_deletions:
                 member_id = int(member_id)
                 if member_type == 'user':
                     member_name = User.get(member_id).username
                     _revoke_perm_user(obj, user=member_id)
                 else:  # set for user group
                     # check if we have permissions to alter this usergroup
                     member_name = UserGroup.get(member_id).users_group_name
                     if not check_perms or has_group_perm(member_name,
                                                          user=cur_user):
                         _revoke_perm_group(obj, user_group=member_id)
 
                 changes['deleted'].append(
                     {'change_obj': change_obj, 'type': member_type,
                      'id': member_id, 'name': member_name, 'new_perm': perm})
 
             # if it's not recursive call for all,repos,groups
             # break the loop and don't proceed with other changes
             if recursive not in ['all', 'repos', 'groups']:
                 break
 
         return changes
 
     def update(self, repo_group, form_data):
         try:
             repo_group = self._get_repo_group(repo_group)
             old_path = repo_group.full_path
 
             # change properties
             if 'group_description' in form_data:
                 repo_group.group_description = form_data['group_description']
 
             if 'enable_locking' in form_data:
                 repo_group.enable_locking = form_data['enable_locking']
 
             if 'group_parent_id' in form_data:
                 parent_group = (
                     self._get_repo_group(form_data['group_parent_id']))
                 repo_group.group_parent_id = (
                     parent_group.group_id if parent_group else None)
                 repo_group.parent_group = parent_group
 
             # mikhail: to update the full_path, we have to explicitly
             # update group_name
             group_name = form_data.get('group_name', repo_group.name)
             repo_group.group_name = repo_group.get_new_name(group_name)
 
             new_path = repo_group.full_path
 
             if 'user' in form_data:
                 repo_group.user = User.get_by_username(form_data['user'])
             repo_group.updated_on = datetime.datetime.now()
             self.sa.add(repo_group)
 
             # iterate over all members of this groups and do fixes
             # set locking if given
             # if obj is a repoGroup also fix the name of the group according
             # to the parent
             # if obj is a Repo fix it's name
             # this can be potentially heavy operation
             for obj in repo_group.recursive_groups_and_repos():
                 # set the value from it's parent
                 obj.enable_locking = repo_group.enable_locking
                 if isinstance(obj, RepoGroup):
                     new_name = obj.get_new_name(obj.name)
                     log.debug('Fixing group %s to new name %s',
                               obj.group_name, new_name)
                     obj.group_name = new_name
                     obj.updated_on = datetime.datetime.now()
                 elif isinstance(obj, Repository):
                     # we need to get all repositories from this new group and
                     # rename them accordingly to new group path
                     new_name = obj.get_new_name(obj.just_name)
                     log.debug('Fixing repo %s to new name %s',
                               obj.repo_name, new_name)
                     obj.repo_name = new_name
                     obj.updated_on = datetime.datetime.now()
                 self.sa.add(obj)
 
             self._rename_group(old_path, new_path)
 
             # Trigger update event.
             events.trigger(events.RepoGroupUpdateEvent(repo_group))
 
             return repo_group
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def delete(self, repo_group, force_delete=False, fs_remove=True):
         repo_group = self._get_repo_group(repo_group)
         if not repo_group:
             return False
         try:
             self.sa.delete(repo_group)
             if fs_remove:
                 self._delete_filesystem_group(repo_group, force_delete)
             else:
                 log.debug('skipping removal from filesystem')
 
             # Trigger delete event.
             events.trigger(events.RepoGroupDeleteEvent(repo_group))
             return True
 
         except Exception:
             log.error('Error removing repo_group %s', repo_group)
             raise
 
     def grant_user_permission(self, repo_group, user, perm):
         """
         Grant permission for user on given repository group, or update
         existing one if found
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param user: Instance of User, user_id or username
         :param perm: Instance of Permission, or permission_name
         """
 
         repo_group = self._get_repo_group(repo_group)
         user = self._get_user(user)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserRepoGroupToPerm)\
             .filter(UserRepoGroupToPerm.user == user)\
             .filter(UserRepoGroupToPerm.group == repo_group)\
             .scalar()
         if obj is None:
             # create new !
             obj = UserRepoGroupToPerm()
         obj.group = repo_group
         obj.user = user
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, user, repo_group)
         action_logger_generic(
             'granted permission: {} to user: {} on repogroup: {}'.format(
                 perm, user, repo_group), namespace='security.repogroup')
         return obj
 
     def revoke_user_permission(self, repo_group, user):
         """
         Revoke permission for user on given repository group
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param user: Instance of User, user_id or username
         """
 
         repo_group = self._get_repo_group(repo_group)
         user = self._get_user(user)
 
         obj = self.sa.query(UserRepoGroupToPerm)\
             .filter(UserRepoGroupToPerm.user == user)\
             .filter(UserRepoGroupToPerm.group == repo_group)\
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm on %s on %s', repo_group, user)
             action_logger_generic(
                 'revoked permission from user: {} on repogroup: {}'.format(
                     user, repo_group), namespace='security.repogroup')
 
     def grant_user_group_permission(self, repo_group, group_name, perm):
         """
         Grant permission for user group on given repository group, or update
         existing one if found
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         :param perm: Instance of Permission, or permission_name
         """
         repo_group = self._get_repo_group(repo_group)
         group_name = self._get_user_group(group_name)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserGroupRepoGroupToPerm)\
             .filter(UserGroupRepoGroupToPerm.group == repo_group)\
             .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
 
         if obj is None:
             # create new
             obj = UserGroupRepoGroupToPerm()
 
         obj.group = repo_group
         obj.users_group = group_name
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, group_name, repo_group)
         action_logger_generic(
             'granted permission: {} to usergroup: {} on repogroup: {}'.format(
                 perm, group_name, repo_group), namespace='security.repogroup')
         return obj
 
     def revoke_user_group_permission(self, repo_group, group_name):
         """
         Revoke permission for user group on given repository group
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         """
         repo_group = self._get_repo_group(repo_group)
         group_name = self._get_user_group(group_name)
 
         obj = self.sa.query(UserGroupRepoGroupToPerm)\
             .filter(UserGroupRepoGroupToPerm.group == repo_group)\
             .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm to %s on %s', repo_group, group_name)
             action_logger_generic(
                 'revoked permission from usergroup: {} on repogroup: {}'.format(
                     group_name, repo_group), namespace='security.repogroup')
 
     def get_repo_groups_as_dict(self, repo_group_list=None, admin=False,
                                 super_user_actions=False):
 
         from pyramid.threadlocal import get_current_request
         _render = get_current_request().get_partial_renderer(
             'data_table/_dt_elements.mako')
         c = _render.get_call_context()
         h = _render.get_helpers()
 
         def quick_menu(repo_group_name):
             return _render('quick_repo_group_menu', repo_group_name)
 
         def repo_group_lnk(repo_group_name):
             return _render('repo_group_name', repo_group_name)
 
         def last_change(last_change):
             if admin and isinstance(last_change, datetime.datetime) and not last_change.tzinfo:
                 last_change = last_change + datetime.timedelta(seconds=
                     (datetime.datetime.now() - datetime.datetime.utcnow()).seconds)
             return _render("last_change", last_change)
 
         def desc(desc, personal):
             return _render(
                 'repo_group_desc', desc, personal, c.visual.stylify_metatags)
 
         def repo_group_actions(repo_group_id, repo_group_name, gr_count):
             return _render(
                 'repo_group_actions', repo_group_id, repo_group_name, gr_count)
 
         def repo_group_name(repo_group_name, children_groups):
             return _render("repo_group_name", repo_group_name, children_groups)
 
         def user_profile(username):
             return _render('user_profile', username)
 
         repo_group_data = []
         for group in repo_group_list:
 
             row = {
                 "menu": quick_menu(group.group_name),
                 "name": repo_group_lnk(group.group_name),
                 "name_raw": group.group_name,
                 "last_change": last_change(group.last_db_change),
                 "last_change_raw": datetime_to_time(group.last_db_change),
                 "desc": desc(group.description_safe, group.personal),
                 "top_level_repos": 0,
                 "owner": user_profile(group.user.username)
             }
             if admin:
                 repo_count = group.repositories.count()
                 children_groups = map(
                     h.safe_unicode,
                     itertools.chain((g.name for g in group.parents),
                                     (x.name for x in [group])))
                 row.update({
                     "action": repo_group_actions(
                         group.group_id, group.group_name, repo_count),
                     "top_level_repos": repo_count,
                     "name": repo_group_name(group.group_name, children_groups),
 
                 })
             repo_group_data.append(row)
 
         return repo_group_data
+
+    def _get_defaults(self, repo_group_name):
+        repo_group = RepoGroup.get_by_group_name(repo_group_name)
+
+        if repo_group is None:
+            return None
+
+        defaults = repo_group.get_dict()
+        defaults['repo_group_name'] = repo_group.name
+        defaults['repo_group_description'] = repo_group.group_description
+        defaults['repo_group_enable_locking'] = repo_group.enable_locking
+
+        # we use -1 as this is how in HTML, we mark an empty group
+        defaults['repo_group'] = defaults['group_parent_id'] or -1
+
+        # fill owner
+        if repo_group.user:
+            defaults.update({'user': repo_group.user.username})
+        else:
+            replacement_user = User.get_first_super_admin().username
+            defaults.update({'user': replacement_user})
+
+        return defaults

rhodecode/model/validation_schema/schemas/repo_group_schema.py

@@ -1,240 +1,284 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 colander
+import deform.widget
 
 from rhodecode.translation import _
 from rhodecode.model.validation_schema import validators, preparers, types
 
 
 def get_group_and_repo(repo_name):
     from rhodecode.model.repo_group import RepoGroupModel
     return RepoGroupModel()._get_group_name_and_parent(
         repo_name, get_object=True)
 
 
 @colander.deferred
 def deferred_can_write_to_group_validator(node, kw):
     old_values = kw.get('old_values') or {}
     request_user = kw.get('user')
 
     def can_write_group_validator(node, value):
         from rhodecode.lib.auth import (
             HasPermissionAny, HasRepoGroupPermissionAny)
         from rhodecode.model.repo_group import RepoGroupModel
 
         messages = {
             'invalid_parent_repo_group':
                 _(u"Parent repository group `{}` does not exist"),
             # permissions denied we expose as not existing, to prevent
             # resource discovery
             'permission_denied_parent_group':
                 _(u"Parent repository group `{}` does not exist"),
             'permission_denied_root':
                 _(u"You do not have the permission to store "
                   u"repository groups in the root location.")
         }
 
         value = value['repo_group_name']
         parent_group_name = value
 
         is_root_location = value is types.RootLocation
 
         # NOT initialized validators, we must call them
         can_create_repo_groups_at_root = HasPermissionAny(
             'hg.admin', 'hg.repogroup.create.true')
 
         if is_root_location:
             if can_create_repo_groups_at_root(user=request_user):
                 # we can create repo group inside tool-level. No more checks
                 # are required
                 return
             else:
                 raise colander.Invalid(node, messages['permission_denied_root'])
 
         # check if the parent repo group actually exists
         parent_group = None
         if parent_group_name:
             parent_group = RepoGroupModel().get_by_group_name(parent_group_name)
             if value and not parent_group:
                 raise colander.Invalid(
                     node, messages['invalid_parent_repo_group'].format(
                         parent_group_name))
 
         # check if we have permissions to create new groups under
         # parent repo group
         # create repositories with write permission on group is set to true
         create_on_write = HasPermissionAny(
             'hg.create.write_on_repogroup.true')(user=request_user)
 
         group_admin = HasRepoGroupPermissionAny('group.admin')(
             parent_group_name, 'can write into group validator', user=request_user)
         group_write = HasRepoGroupPermissionAny('group.write')(
             parent_group_name, 'can write into group validator', user=request_user)
 
         # creation by write access is currently disabled. Needs thinking if
         # we want to allow this...
         forbidden = not (group_admin or (group_write and create_on_write and 0))
 
         if parent_group and forbidden:
             msg = messages['permission_denied_parent_group'].format(
                 parent_group_name)
             raise colander.Invalid(node, msg)
 
     return can_write_group_validator
 
 
 @colander.deferred
 def deferred_repo_group_owner_validator(node, kw):
 
     def repo_owner_validator(node, value):
         from rhodecode.model.db import User
         existing = User.get_by_username(value)
         if not existing:
             msg = _(u'Repo group owner with id `{}` does not exists').format(
                 value)
             raise colander.Invalid(node, msg)
 
     return repo_owner_validator
 
 
 @colander.deferred
 def deferred_unique_name_validator(node, kw):
     request_user = kw.get('user')
     old_values = kw.get('old_values') or {}
 
     def unique_name_validator(node, value):
         from rhodecode.model.db import Repository, RepoGroup
         name_changed = value != old_values.get('group_name')
 
         existing = Repository.get_by_repo_name(value)
         if name_changed and existing:
             msg = _(u'Repository with name `{}` already exists').format(value)
             raise colander.Invalid(node, msg)
 
         existing_group = RepoGroup.get_by_group_name(value)
         if name_changed and existing_group:
             msg = _(u'Repository group with name `{}` already exists').format(
                 value)
             raise colander.Invalid(node, msg)
     return unique_name_validator
 
 
 @colander.deferred
 def deferred_repo_group_name_validator(node, kw):
     return validators.valid_name_validator
 
 
[e-mail]
+def deferred_repo_group_validator(node, kw):
+    options = kw.get(
+        'repo_group_repo_group_options')
+    return colander.OneOf([x for x in options])
+
+
[e-mail]
+def deferred_repo_group_widget(node, kw):
+    items = kw.get('repo_group_repo_group_items')
+    return deform.widget.Select2Widget(values=items)
+
+
 class GroupType(colander.Mapping):
     def _validate(self, node, value):
         try:
             return dict(repo_group_name=value)
         except Exception as e:
             raise colander.Invalid(
                 node, '"${val}" is not a mapping type: ${err}'.format(
                     val=value, err=e))
 
     def deserialize(self, node, cstruct):
         if cstruct is colander.null:
             return cstruct
 
         appstruct = super(GroupType, self).deserialize(node, cstruct)
         validated_name = appstruct['repo_group_name']
 
         # inject group based on once deserialized data
         (repo_group_name_without_group,
          parent_group_name,
          parent_group) = get_group_and_repo(validated_name)
 
         appstruct['repo_group_name_without_group'] = repo_group_name_without_group
         appstruct['repo_group_name'] = parent_group_name or types.RootLocation
         if parent_group:
             appstruct['repo_group_id'] = parent_group.group_id
 
         return appstruct
 
 
 class GroupSchema(colander.SchemaNode):
     schema_type = GroupType
     validator = deferred_can_write_to_group_validator
     missing = colander.null
 
 
 class RepoGroup(GroupSchema):
     repo_group_name = colander.SchemaNode(
         types.GroupNameType())
     repo_group_id = colander.SchemaNode(
         colander.String(), missing=None)
     repo_group_name_without_group = colander.SchemaNode(
         colander.String(), missing=None)
 
 
 class RepoGroupAccessSchema(colander.MappingSchema):
     repo_group = RepoGroup()
 
 
 class RepoGroupNameUniqueSchema(colander.MappingSchema):
     unique_repo_group_name = colander.SchemaNode(
         colander.String(),
         validator=deferred_unique_name_validator)
 
 
 class RepoGroupSchema(colander.Schema):
 
     repo_group_name = colander.SchemaNode(
         types.GroupNameType(),
         validator=deferred_repo_group_name_validator)
 
     repo_group_owner = colander.SchemaNode(
         colander.String(),
         validator=deferred_repo_group_owner_validator)
 
     repo_group_description = colander.SchemaNode(
-        colander.String(), missing='')
+        colander.String(), missing='', widget=deform.widget.TextAreaWidget())
 
     repo_group_copy_permissions = colander.SchemaNode(
         types.StringBooleanType(),
-        missing=False)
+        missing=False, widget=deform.widget.CheckboxWidget())
 
     repo_group_enable_locking = colander.SchemaNode(
         types.StringBooleanType(),
-        missing=False)
+        missing=False, widget=deform.widget.CheckboxWidget())
 
     def deserialize(self, cstruct):
         """
         Custom deserialize that allows to chain validation, and verify
         permissions, and as last step uniqueness
         """
 
         appstruct = super(RepoGroupSchema, self).deserialize(cstruct)
         validated_name = appstruct['repo_group_name']
 
         # second pass to validate permissions to repo_group
         second = RepoGroupAccessSchema().bind(**self.bindings)
         appstruct_second = second.deserialize({'repo_group': validated_name})
         # save result
         appstruct['repo_group'] = appstruct_second['repo_group']
 
         # thirds to validate uniqueness
         third = RepoGroupNameUniqueSchema().bind(**self.bindings)
         third.deserialize({'unique_repo_group_name': validated_name})
 
         return appstruct
+
+
+class RepoGroupSettingsSchema(RepoGroupSchema):
+    repo_group = colander.SchemaNode(
+        colander.Integer(),
+        validator=deferred_repo_group_validator,
+        widget=deferred_repo_group_widget,
+        missing='')
+
+    def deserialize(self, cstruct):
+        """
+        Custom deserialize that allows to chain validation, and verify
+        permissions, and as last step uniqueness
+        """
+
+        # first pass, to validate given data
+        appstruct = super(RepoGroupSchema, self).deserialize(cstruct)
+        validated_name = appstruct['repo_group_name']
+
+        # second pass to validate permissions to repo_group
+        second = RepoGroupAccessSchema().bind(**self.bindings)
+        appstruct_second = second.deserialize({'repo_group': validated_name})
+        # save result
+        appstruct['repo_group'] = appstruct_second['repo_group']
+
+        # thirds to validate uniqueness
+        third = RepoGroupNameUniqueSchema().bind(**self.bindings)
+        third.deserialize({'unique_repo_group_name': validated_name})
+
+        return appstruct

rhodecode/public/js/rhodecode/routes.js

@@ -1,285 +1,293 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_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_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.url('repo_groups'))}
+    ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
-    ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
+    ${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'))}
     &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.url('repo_groups'))}
+    ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
-    ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
+    ${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'))}
   %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.url('repo_groups'))}
+    ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     &raquo;
-    ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
+    ${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'))}
     &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/repo_groups/repo_group_add.mako

@@ -1,106 +1,106 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('Add repository group')}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('Repository groups'),h.url('repo_groups'))}
+    ${h.link_to(_('Repository groups'),h.route_path('repo_groups'))}
     &raquo;
     ${_('Add Repository Group')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='admin')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
-    ${h.secure_form(h.url('repo_groups'), request=request)}
+    ${h.secure_form(h.route_path('repo_group_create'), request=request)}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label">
                     <label for="group_name">${_('Group Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('group_name', class_="medium")}
                 </div>
              </div>
 
             <div class="field">
                 <div class="label">
                     <label for="group_description">${_('Description')}:</label>
                 </div>
                 <div class="textarea editor">
                     ${h.textarea('group_description',cols=23,rows=5,class_="medium")}
                     <% 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}').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="group_parent_id">${_('Group Parent')}:</label>
                  </div>
                  <div class="select">
                      ${h.select('group_parent_id',request.GET.get('parent_group'),c.repo_groups,class_="medium")}
                  </div>
             </div>
 
             <div id="copy_perms" class="field">
                 <div class="label label-checkbox">
                     <label for="group_copy_permissions">${_('Copy Parent Group Permissions')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('group_copy_permissions', value="True", checked="checked")}
                     <span class="help-block">${_('Copy permission settings from parent repository group.')}</span>
                 </div>
             </div>
 
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="btn")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 <script>
     $(document).ready(function(){
         var setCopyPermsOption = function(group_val){
             if(group_val != "-1"){
                 $('#copy_perms').show()
             }
             else{
                 $('#copy_perms').hide();
             }
         }
         $("#group_parent_id").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'dropdownAutoWidth': true
         });
         setCopyPermsOption($('#group_parent_id').val())
         $("#group_parent_id").on("change", function(e) {
             setCopyPermsOption(e.val)
         })
         $('#group_name').focus();
     })
 </script>
 </%def>

rhodecode/templates/admin/repo_groups/repo_group_edit.mako

@@ -1,61 +1,61 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('%s repository group settings') % c.repo_group.name}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('Repository Groups'),h.url('repo_groups'))}
+    ${h.link_to(_('Repository Groups'),h.route_path('repo_groups'))}
     %if c.repo_group.parent_group:
         &raquo; ${h.link_to(c.repo_group.parent_group.name, h.route_path('repo_group_home', repo_group_name=c.repo_group.parent_group.group_name))}
     %endif
     &raquo; ${c.repo_group.name}
 </%def>
 
 <%def name="breadcrumbs_side_links()">
     <ul class="links">
       <li>
-          <a href="${h.url('new_repo_group', parent_group=c.repo_group.group_id)}" class="btn btn-small btn-success">${_(u'Add Child Group')}</a>
+          <a href="${h.route_path('repo_group_new', _query=dict(parent_group=c.repo_group.group_id))}" class="btn btn-small btn-success">${_(u'Add Child Group')}</a>
       </li>
     </ul>
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='admin')}
 </%def>
 
 <%def name="main_content()">
     <%include file="/admin/repo_groups/repo_group_edit_${c.active}.mako"/>
 </%def>
 
 <%def name="main()">
 <div class="box">
   <div class="title">
       ${self.breadcrumbs()}
       ${self.breadcrumbs_side_links()}
   </div>
 
   <div class="sidebar-col-wrapper">
     ##main
     <div class="sidebar">
         <ul class="nav nav-pills nav-stacked">
-          <li class="${'active' if c.active=='settings' else ''}"><a href="${h.url('edit_repo_group', group_name=c.repo_group.group_name)}">${_('Settings')}</a></li>
-          <li class="${'active' if c.active=='perms' else ''}"><a href="${h.url('edit_repo_group_perms', group_name=c.repo_group.group_name)}">${_('Permissions')}</a></li>
-          <li class="${'active' if c.active=='advanced' else ''}"><a href="${h.url('edit_repo_group_advanced', group_name=c.repo_group.group_name)}">${_('Advanced')}</a></li>
+          <li class="${'active' if c.active=='settings' else ''}"><a href="${h.route_path('edit_repo_group', repo_group_name=c.repo_group.group_name)}">${_('Settings')}</a></li>
+          <li class="${'active' if c.active=='permissions' else ''}"><a href="${h.route_path('edit_repo_group_perms', repo_group_name=c.repo_group.group_name)}">${_('Permissions')}</a></li>
+          <li class="${'active' if c.active=='advanced' else ''}"><a href="${h.route_path('edit_repo_group_advanced', repo_group_name=c.repo_group.group_name)}">${_('Advanced')}</a></li>
           <li class="${'active' if c.active=='integrations' else ''}"><a href="${h.route_path('repo_group_integrations_home', repo_group_name=c.repo_group.group_name)}">${_('Integrations')}</a></li>
         </ul>
     </div>
 
     <div class="main-content-full-width">
       ${self.main_content()}
     </div>
 
   </div>
 </div>
 </%def>

rhodecode/templates/admin/repo_groups/repo_group_edit_advanced.mako

@@ -1,64 +1,64 b''
 <%namespace name="base" file="/base/base.mako"/>
 
 <%
  elems = [
     (_('Owner'), lambda:base.gravatar_with_user(c.repo_group.user.email), '', ''),
     (_('Created on'), h.format_date(c.repo_group.created_on), '', ''),
     (_('Is Personal Group'), c.repo_group.personal or False, '', ''),
 
     (_('Total repositories'), c.repo_group.repositories_recursive_count, '', ''),
     (_('Top level repositories'), c.repo_group.repositories.count(), '', c.repo_group.repositories.all()),
 
     (_('Children groups'), c.repo_group.children.count(), '', c.repo_group.children.all()),
  ]
 %>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Repository Group: %s') % c.repo_group.group_name}</h3>
     </div>
     <div class="panel-body">
         ${base.dt_info_panel(elems)}
     </div>
 
 </div>
 
 <div class="panel panel-danger">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Delete repository group')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('delete_repo_group', group_name=c.repo_group.group_name),method='delete', request=request)}
+        ${h.secure_form(h.route_path('edit_repo_group_advanced_delete', repo_group_name=c.repo_group.group_name), request=request)}
             <table class="display">
 
                 <tr>
                     <td>
                         ${_ungettext('This repository group includes %s children repository group.', 'This repository group includes %s children repository groups.', c.repo_group.children.count()) % c.repo_group.children.count()}
                     </td>
                     <td>
                     </td>
                     <td>
                     </td>
                 </tr>
                 <tr>
                     <td>
                         ${_ungettext('This repository group includes %s repository.', 'This repository group includes %s repositories.', c.repo_group.repositories_recursive_count) % c.repo_group.repositories_recursive_count}
                     </td>
                     <td>
                     </td>
                     <td>
                     </td>
                 </tr>
 
             </table>
             <div style="margin: 0 0 20px 0" class="fake-space"></div>
 
             <button class="btn btn-small btn-danger" type="submit"
                 onclick="return confirm('${_('Confirm to delete this group: %s') % (c.repo_group.group_name)}');">
                 ${_('Delete this repository group')}
             </button>
         ${h.end_form()}
     </div>
 </div>
 
 

rhodecode/templates/admin/repo_groups/repo_group_edit_permissions.mako

@@ -1,148 +1,146 b''
 <%namespace name="base" file="/base/base.mako"/>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Repository Group Permissions')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('edit_repo_group_perms', group_name=c.repo_group.group_name),method='put', request=request)}
+        ${h.secure_form(h.route_path('edit_repo_group_perms_update', repo_group_name=c.repo_group.group_name), request=request)}
         <table id="permissions_manage" class="rctable permissions">
             <tr>
                 <th class="td-radio">${_('None')}</th>
                 <th class="td-radio">${_('Read')}</th>
                 <th class="td-radio">${_('Write')}</th>
                 <th class="td-radio">${_('Admin')}</th>
-                <th class="td-user">${_('User/User Group')}</th>
+                <th class="td-owner">${_('User/User Group')}</th>
                 <th></th>
             </tr>
             ## USERS
             %for _user in c.repo_group.permissions():
                 %if getattr(_user, 'admin_row', None) or getattr(_user, 'owner_row', None):
                     <tr class="perm_admin_row">
                         <td class="td-radio">${h.radio('admin_perm_%s' % _user.user_id,'repository.none', disabled="disabled")}</td>
                         <td class="td-radio">${h.radio('admin_perm_%s' % _user.user_id,'repository.read', disabled="disabled")}</td>
                         <td class="td-radio">${h.radio('admin_perm_%s' % _user.user_id,'repository.write', disabled="disabled")}</td>
                         <td class="td-radio">${h.radio('admin_perm_%s' % _user.user_id,'repository.admin', 'repository.admin', disabled="disabled")}</td>
                         <td class="td-user">
                             ${base.gravatar(_user.email, 16)}
-                            <span class="user">
                                 ${h.link_to_user(_user.username)}
                                 %if getattr(_user, 'admin_row', None):
                                     (${_('super admin')})
                                 %endif
                                 %if getattr(_user, 'owner_row', None):
                                     (${_('owner')})
                                 %endif
-                            </span>
                         </td>
                         <td></td>
                     </tr>
                 %else:
+                    <tr>
                     ##forbid revoking permission from yourself, except if you're an super admin
-                    <tr>
                         %if c.rhodecode_user.user_id != _user.user_id or c.rhodecode_user.is_admin:
-                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.none')}</td>
-                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.read')}</td>
-                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.write')}</td>
-                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.admin')}</td>
+                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.none', checked=_user.permission=='group.none')}</td>
+                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.read', checked=_user.permission=='group.read')}</td>
+                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.write', checked=_user.permission=='group.write')}</td>
+                        <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.admin', checked=_user.permission=='group.admin')}</td>
                         <td class="td-user">
                             ${base.gravatar(_user.email, 16)}
                             <span class="user">
                                 % if _user.username == h.DEFAULT_USER:
                                     ${h.DEFAULT_USER} <span class="user-perm-help-text"> - ${_('permission for all other users')}</span>
                                 % else:
                                     ${h.link_to_user(_user.username)}
                                 % endif
                             </span>
                         </td>
                         <td class="td-action">
                             %if _user.username != h.DEFAULT_USER:
                                 <span  class="btn btn-link btn-danger revoke_perm"
                                   member="${_user.user_id}" member_type="user">
                                 <i class="icon-remove"></i> ${_('Revoke')}
                                 </span>
                             %endif
                         </td>
                         %else:
                             ## special case for current user permissions, we make sure he cannot take his own permissions
                             <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.none', disabled="disabled")}</td>
                             <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.read', disabled="disabled")}</td>
                             <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.write', disabled="disabled")}</td>
                             <td class="td-radio">${h.radio('u_perm_%s' % _user.user_id,'group.admin', disabled="disabled")}</td>
                             <td class="td-user">
                                 ${base.gravatar(_user.email, 16)}
                                 <span class="user">
                                     % if _user.username == h.DEFAULT_USER:
                                         ${h.DEFAULT_USER} <span class="user-perm-help-text"> - ${_('permission for all other users')}</span>
                                     % else:
                                         ${h.link_to_user(_user.username)}
                                     % endif
                                     <span class="user-perm-help-text">(${_('delegated admin')})</span>
                                 </span>
                             </td>
                             <td></td>
                         %endif
                     </tr>
                 %endif
             %endfor
 
             ## USER GROUPS
             %for _user_group in c.repo_group.permission_user_groups():
                 <tr id="id${id(_user_group.users_group_name)}">
-                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.none')}</td>
-                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.read')}</td>
-                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.write')}</td>
-                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.admin')}</td>
+                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.none', checked=_user_group.permission=='group.none')}</td>
+                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.read', checked=_user_group.permission=='group.read')}</td>
+                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.write', checked=_user_group.permission=='group.write')}</td>
+                    <td class="td-radio">${h.radio('g_perm_%s' % _user_group.users_group_id,'group.admin', checked=_user_group.permission=='group.admin')}</td>
                     <td class="td-componentname">
                         <i class="icon-group" ></i>
                         %if h.HasPermissionAny('hg.admin')():
                          <a href="${h.route_path('edit_user_group',user_group_id=_user_group.users_group_id)}">
                              ${_user_group.users_group_name}
                          </a>
                         %else:
                          ${_user_group.users_group_name}
                         %endif
                     </td>
                     <td class="td-action">
                         <span  class="btn btn-link btn-danger revoke_perm"
                               member="${_user_group.users_group_id}" member_type="user_group">
                         <i class="icon-remove"></i> ${_('Revoke')}
                         </span>
                     </td>
                 </tr>
             %endfor
 
             <tr class="new_members" id="add_perm_input"></tr>
         </table>
         <div id="add_perm" class="link">
             ${_('Add new')}
         </div>
         <div class="fields">
             <div class="field">
                <div class="label label-radio">
                    ${_('Apply to children')}:
                </div>
                <div class="radios">
                    ${h.radio('recursive', 'none', label=_('None'), checked="checked")}
                    ${h.radio('recursive', 'groups', label=_('Repository Groups'))}
                    ${h.radio('recursive', 'repos', label=_('Repositories'))}
                    ${h.radio('recursive', 'all', label=_('Both'))}
                <span class="help-block">${_('Set or revoke permissions to selected types of children of this group, including non-private repositories and other groups if chosen.')}</span>
                </div>
             </div>
         </div>
         <div class="buttons">
           ${h.submit('save',_('Save'),class_="btn btn-primary")}
           ${h.reset('reset',_('Reset'),class_="btn btn-danger")}
         </div>
         ${h.end_form()}
     </div>
 </div>
 <script type="text/javascript">
     $('#add_perm').on('click', function(e){
         addNewPermInput($(this), 'group');
     });
     $('.revoke_perm').on('click', function(e){
         markRevokePermInput($(this), 'group');
     })
 </script>

rhodecode/templates/admin/repo_groups/repo_group_edit_settings.mako

@@ -1,90 +1,95 b''
 ## -*- coding: utf-8 -*-
 <%namespace name="base" file="/base/base.mako"/>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Settings for Repository Group: %s') % c.repo_group.name}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('update_repo_group',group_name=c.repo_group.group_name),method='put', request=request)}
+        ${h.secure_form(h.route_path('edit_repo_group', repo_group_name=c.repo_group.group_name), request=request)}
         <div class="form">
             <!-- fields -->
             <div class="fields">
                 <div class="field">
                     <div class="label">
                         <label for="group_name">${_('Group Name')}:</label>
                     </div>
                     <div class="input">
-                        ${h.text('group_name',class_='medium')}
+                        ${c.form['repo_group_name'].render(css_class='medium', oid='group_name')|n}
+                        ${c.form.render_error(request, c.form['repo_group_name'])|n}
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="label">
+                        <label for="repo_group">${_('Group parent')}:</label>
+                    </div>
+                    <div class="select">
+                        ${c.form['repo_group'].render(css_class='medium', oid='repo_group')|n}
+                        ${c.form.render_error(request, c.form['repo_group'])|n}
+
+                        <p class="help-block">${_('Optional select a parent group to move this repository group into.')}</p>
                     </div>
                 </div>
 
                 <div class="field badged-field">
                     <div class="label">
-                        <label for="user">${_('Owner')}:</label>
+                        <label for="repo_group_owner">${_('Owner')}:</label>
                     </div>
                     <div class="input">
                         <div class="badge-input-container">
                             <div class="user-badge">
                                 ${base.gravatar_with_user(c.repo_group.user.email, show_disabled=not c.repo_group.user.active)}
                             </div>
                             <div class="badge-input-wrap">
-                                ${h.text('user', class_="medium", autocomplete="off")}
+                                ${c.form['repo_group_owner'].render(css_class='medium', oid='repo_group_owner')|n}
                             </div>
                         </div>
-                        <form:error name="user"/>
+                        ${c.form.render_error(request, c.form['repo_group_owner'])|n}
                         <p class="help-block">${_('Change owner of this repository group.')}</p>
                     </div>
                 </div>
 
                 <div class="field">
                     <div class="label label-textarea">
-                        <label for="group_description">${_('Description')}:</label>
+                        <label for="repo_group_description">${_('Description')}:</label>
                     </div>
                     <div class="textarea text-area editor">
-                        ${h.textarea('group_description',cols=23,rows=5,class_="medium")}
+                        ${c.form['repo_group_description'].render(css_class='medium', oid='repo_group_description')|n}
+                        ${c.form.render_error(request, c.form['repo_group_description'])|n}
+
                         <% 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}').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="group_parent_id">${_('Group parent')}:</label>
-                    </div>
-                    <div class="select">
-                        ${h.select('group_parent_id','',c.repo_groups,class_="medium")}
-                    </div>
-                </div>
-                <div class="field">
                     <div class="label label-checkbox">
-                        <label for="enable_locking">${_('Enable Repository Locking')}:</label>
+                        <label for="repo_group_enable_locking">${_('Enable Repository Locking')}:</label>
                     </div>
                     <div class="checkboxes">
-                        ${h.checkbox('enable_locking',value="True")}
+                        ${c.form['repo_group_enable_locking'].render(css_class='medium', oid='repo_group_enable_locking')|n}
+                        ${c.form.render_error(request, c.form['repo_group_enable_locking'])|n}
+
                         <span class="help-block">${_('Repository locking will be enabled on all subgroups and repositories inside this repository group. Pulling from a repository locks it, and it is unlocked by pushing back by the same user.')}</span>
                     </div>
                 </div>
+
                 <div class="buttons">
                   ${h.submit('save',_('Save'),class_="btn")}
                   ${h.reset('reset',_('Reset'),class_="btn")}
                 </div>
             </div>
         </div>
         ${h.end_form()}
     </div>
 </div>
 <script>
     $(document).ready(function(){
-        $("#group_parent_id").select2({
-            'containerCssClass': "drop-menu",
-            'dropdownCssClass': "drop-menu-dropdown",
-            'dropdownAutoWidth': true
-        });
-        UsersAutoComplete('user', '${c.rhodecode_user.user_id}');
+        UsersAutoComplete('repo_group_owner', '${c.rhodecode_user.user_id}');
     })
 </script>

rhodecode/templates/admin/repo_groups/repo_groups.mako

@@ -1,97 +1,97 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('Repository groups administration')}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" placeholder="${_('quick filter...')}" value=""/>
     ${h.link_to(_('Admin'),h.route_path('admin_home'))} &raquo; <span id="repo_group_count">0</span> ${_('repository groups')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='admin')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <div class="title">
         ${self.breadcrumbs()}
         <ul class="links">
             %if h.HasPermissionAny('hg.admin','hg.repogroup.create.true')():
              <li>
-               <a href="${h.url('new_repo_group')}" class="btn btn-small btn-success">${_(u'Add Repository Group')}</a>
+               <a href="${h.route_path('repo_group_new')}" class="btn btn-small btn-success">${_(u'Add Repository Group')}</a>
              </li>
             %endif
         </ul>
     </div>
     <div id="repos_list_wrap">
         <table id="group_list_table" class="display"></table>
     </div>
 </div>
 
 <script>
 $(document).ready(function() {
 
     var get_datatable_count = function(){
       var api = $('#group_list_table').dataTable().api();
       $('#repo_group_count').text(api.page.info().recordsDisplay);
     };
 
    // repo group list
    $('#group_list_table').DataTable({
       data: ${c.data|n},
       dom: 'rtp',
       pageLength: ${c.visual.admin_grid_items},
       order: [[ 0, "asc" ]],
       columns: [
          { data: {"_": "name",
                   "sort": "name_raw"}, title: "${_('Name')}", className: "td-componentname" },
          { data: 'menu', "bSortable": false, className: "quick_repo_menu" },
          { data: {"_": "desc",
                   "sort": "desc"}, title: "${_('Description')}", className: "td-description" },
          { data: {"_": "last_change",
                   "sort": "last_change_raw",
                   "type": Number}, title: "${_('Last Change')}", className: "td-time" },
          { data: {"_": "top_level_repos",
                   "sort": "top_level_repos"}, title: "${_('Number of top level repositories')}" },
          { data: {"_": "owner",
                   "sort": "owner"}, title: "${_('Owner')}", className: "td-user" },
          { data: {"_": "action",
                   "sort": "action"}, title: "${_('Action')}", className: "td-action" }
       ],
       language: {
           paginate: DEFAULT_GRID_PAGINATION,
           emptyTable: _gettext("No repository groups available yet.")
       },
       "initComplete": function( settings, json ) {
           get_datatable_count();
           quick_repo_menu();
       }
     });
 
      // update the counter when doing search
     $('#group_list_table').on( 'search.dt', function (e,settings) {
       get_datatable_count();
     });
 
     // filter, filter both grids
     $('#q_filter').on( 'keyup', function () {
 
       var repo_group_api = $('#group_list_table').dataTable().api();
       repo_group_api
         .columns(0)
         .search(this.value)
         .draw();
     });
 
     // refilter table if page load via back button
     $("#q_filter").trigger('keyup');
 });
 </script>
 </%def>
 

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.url('repo_groups')}">${_('Repository groups')}</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>
   </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.url('repo_groups')}">${_('Repository groups')}</a></li>
+      <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.url(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 -->

rhodecode/templates/base/perms_summary.mako

@@ -1,268 +1,268 b''
 ## snippet for displaying permissions overview for users
 ## usage:
 ##    <%namespace name="p" file="/base/perms_summary.mako"/>
 ##    ${p.perms_summary(c.perm_user.permissions)}
 
 <%def name="perms_summary(permissions, show_all=False, actions=True, side_link=None)">
 <div id="perms" class="table fields">
   %for section in sorted(permissions.keys()):
   <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${section.replace("_"," ").capitalize()}</h3>
         % if side_link:
             <div class="pull-right">
                 <a href="${side_link}">${_('in JSON format')}</a>
             </div>
         % endif
     </div>
     <div class="panel-body">
       <div class="perms_section_head field">
         <div class="radios">
           %if section != 'global':
               <span class="permissions_boxes">
               <span class="desc">${_('show')}: </span>
               ${h.checkbox('perms_filter_none_%s' % section, 'none', 'checked', class_='perm_filter filter_%s' % section, section=section, perm_type='none')}   <label for="${'perms_filter_none_%s' % section}"><span class="perm_tag none">${_('none')}</span></label>
               ${h.checkbox('perms_filter_read_%s' % section, 'read', 'checked', class_='perm_filter filter_%s' % section, section=section, perm_type='read')}   <label for="${'perms_filter_read_%s' % section}"><span class="perm_tag read">${_('read')}</span></label>
               ${h.checkbox('perms_filter_write_%s' % section, 'write', 'checked', class_='perm_filter filter_%s' % section, section=section, perm_type='write')} <label for="${'perms_filter_write_%s' % section}"> <span class="perm_tag write">${_('write')}</span></label>
               ${h.checkbox('perms_filter_admin_%s' % section, 'admin', 'checked', class_='perm_filter filter_%s' % section, section=section, perm_type='admin')} <label for="${'perms_filter_admin_%s' % section}"><span class="perm_tag admin">${_('admin')}</span></label>
               </span>
           %endif
         </div>
       </div>
       <div class="field">
         %if not permissions[section]:
             <p class="empty_data help-block">${_('No permissions defined')}</p>
         %else:
         <div id='tbl_list_wrap_${section}'>
          <table id="tbl_list_${section}" class="rctable">
           ## global permission box
           %if section == 'global':
             <thead>
                 <tr>
                 <th colspan="2" class="left">${_('Permission')}</th>
                 %if actions:
                 <th colspan="2">${_('Edit Permission')}</th>
                 %endif
             </thead>
             <tbody>
 
             <%
               def get_section_perms(prefix, opts):
                   _selected = []
                   for op in opts:
                       if op.startswith(prefix) and not op.startswith('hg.create.write_on_repogroup'):
                           _selected.append(op)
                   admin = 'hg.admin' in opts
                   _selected_vals = [x.partition(prefix)[-1] for x in _selected]
                   return admin, _selected_vals, _selected
             %>
 
             <%def name="glob(lbl, val, val_lbl=None, edit_url=None, edit_global_url=None)">
               <tr>
                 <td class="td-tags">
                     ${lbl}
                 </td>
                 <td class="td-tags">
                     %if val[0]:
                       %if not val_lbl:
                           ## super admin case
                           True
                       %else:
                           <span class="perm_tag admin">${val_lbl}.admin</span>
                       %endif
                     %else:
                       %if not val_lbl:
                           ${
                              {'false': False,
                              'true': True,
                              'none': False,
                              'repository': True}.get(val[1][0] if 0 < len(val[1]) else 'false')
                           }
                       %else:
                           <span class="perm_tag ${val[1][0]}">${val_lbl}.${val[1][0]}</span>
                       %endif
                     %endif
                 </td>
                 %if actions:
 
                     % if edit_url or edit_global_url:
 
                         <td class="td-action">
                             % if edit_url:
                             <a href="${edit_url}">${_('edit')}</a>
                             % else:
                                 -
                             % endif
                         </td>
 
                         <td class="td-action">
                             % if edit_global_url:
                             <a href="${edit_global_url}">${_('edit global')}</a>
                             % else:
                                 -
                             % endif
                         </td>
 
                     % else:
                         <td class="td-action"></td>
                         <td class="td-action">
                             <a href="${h.route_path('admin_permissions_global')}">${_('edit global')}</a>
                         <td class="td-action">
                     % endif
 
                 %endif
               </tr>
             </%def>
 
            ${glob(_('Repository default permission'), get_section_perms('repository.', permissions[section]), 'repository',
                 edit_url=None, edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('Repository group default permission'), get_section_perms('group.', permissions[section]), 'group',
                 edit_url=None, edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('User group default permission'), get_section_perms('usergroup.', permissions[section]), 'usergroup',
                 edit_url=None, edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('Super admin'), get_section_perms('hg.admin', permissions[section]),
                 edit_url=h.route_path('user_edit', user_id=c.user.user_id, _anchor='admin'), edit_global_url=None)}
 
            ${glob(_('Inherit permissions'), get_section_perms('hg.inherit_default_perms.', permissions[section]),
                 edit_url=h.route_path('user_edit_global_perms', user_id=c.user.user_id), edit_global_url=None)}
 
            ${glob(_('Create repositories'), get_section_perms('hg.create.', permissions[section]),
                 edit_url=h.route_path('user_edit_global_perms', user_id=c.user.user_id), edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('Fork repositories'), get_section_perms('hg.fork.', permissions[section]),
                 edit_url=h.route_path('user_edit_global_perms', user_id=c.user.user_id), edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('Create repository groups'), get_section_perms('hg.repogroup.create.', permissions[section]),
                 edit_url=h.route_path('user_edit_global_perms', user_id=c.user.user_id), edit_global_url=h.route_path('admin_permissions_object'))}
 
            ${glob(_('Create user groups'), get_section_perms('hg.usergroup.create.', permissions[section]),
                 edit_url=h.route_path('user_edit_global_perms', user_id=c.user.user_id), edit_global_url=h.route_path('admin_permissions_object'))}
 
            </tbody>
           %else:
            ## none/read/write/admin permissions on groups/repos etc
             <thead>
                 <tr>
                 <th>${_('Name')}</th>
                 <th>${_('Permission')}</th>
                 %if actions:
                 <th>${_('Edit Permission')}</th>
                 %endif
             </thead>
             <tbody class="section_${section}">
             <%
                 def sorter(permissions):
                     def custom_sorter(item):
                        ## read/write/admin
                        section = item[1].split('.')[-1]
                        section_importance = {'none': u'0',
                                              'read': u'1',
                                              'write':u'2',
                                              'admin':u'3'}.get(section)
                        ## sort by group importance+name
                        return section_importance+item[0]
                     return sorted(permissions, key=custom_sorter)
             %>
             %for k, section_perm in sorter(permissions[section].items()):
                 %if section_perm.split('.')[-1] != 'none' or show_all:
                 <tr class="perm_row ${'%s_%s' % (section, section_perm.split('.')[-1])}">
                     <td class="td-name">
                         %if section == 'repositories':
                             <a href="${h.route_path('repo_summary',repo_name=k)}">${k}</a>
                         %elif section == 'repositories_groups':
                             <a href="${h.route_path('repo_group_home', repo_group_name=k)}">${k}</a>
                         %elif section == 'user_groups':
                             ##<a href="${h.route_path('edit_user_group',user_group_id=k)}">${k}</a>
                             ${k}
                         %endif
                     </td>
                     <td class="td-tags">
                       %if hasattr(permissions[section], 'perm_origin_stack'):
                          <div>
                          %for i, (perm, origin) in enumerate(reversed(permissions[section].perm_origin_stack[k])):
 
                          % if i > 0:
                              <div style="color: #979797">
                              <i class="icon-arrow_up"></i>
                                  ${_('overridden by')}
                              <i class="icon-arrow_up"></i>
                              </div>
                          % endif
 
                          <div>
                              <span class="${i > 0 and 'perm_overriden' or ''} perm_tag ${perm.split('.')[-1]}">
                               ${perm} (${origin})
                              </span>
                          </div>
 
                          %endfor
                          </div>
                       %else:
                          <span class="perm_tag ${section_perm.split('.')[-1]}">${section_perm}</span>
                       %endif
                     </td>
                     %if actions:
                     <td class="td-action">
                         %if section == 'repositories':
                             <a href="${h.route_path('edit_repo_perms',repo_name=k,_anchor='permissions_manage')}">${_('edit')}</a>
                         %elif section == 'repositories_groups':
-                            <a href="${h.url('edit_repo_group_perms',group_name=k,anchor='permissions_manage')}">${_('edit')}</a>
+                            <a href="${h.route_path('edit_repo_group_perms',repo_group_name=k,_anchor='permissions_manage')}">${_('edit')}</a>
                         %elif section == 'user_groups':
                             ##<a href="${h.route_path('edit_user_group',user_group_id=k)}">${_('edit')}</a>
                         %endif
                     </td>
                     %endif
                 </tr>
                 %endif
             %endfor
 
             <tr id="empty_${section}" class="noborder" style="display:none;">
               <td colspan="6">${_('No permission defined')}</td>
             </tr>
 
             </tbody>
           %endif
          </table>
         </div>
         %endif
       </div>
     </div>
   </div>
   %endfor
 </div>
 
 <script>
     $(document).ready(function(){
         var show_empty = function(section){
             var visible = $('.section_{0} tr.perm_row:visible'.format(section)).length;
             if(visible == 0){
                 $('#empty_{0}'.format(section)).show();
             }
             else{
                 $('#empty_{0}'.format(section)).hide();
             }
         };
         $('.perm_filter').on('change', function(e){
             var self = this;
             var section = $(this).attr('section');
 
             var opts = {};
             var elems = $('.filter_' + section).each(function(el){
                 var perm_type = $(this).attr('perm_type');
                 var checked = this.checked;
                 opts[perm_type] = checked;
                 if(checked){
                     $('.'+section+'_'+perm_type).show();
                 }
                 else{
                     $('.'+section+'_'+perm_type).hide();
                 }
             });
             show_empty(section);
         })
     })
 </script>
 </%def>

rhodecode/templates/data_table/_dt_elements.mako

@@ -1,377 +1,377 b''
 ## DATA TABLE RE USABLE ELEMENTS
 ## usage:
 ## <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 <%namespace name="base" file="/base/base.mako"/>
 
 <%def name="metatags_help()">
     <table>
         <%
             example_tags = [
                 ('state','[stable]'),
                 ('state','[stale]'),
                 ('state','[featured]'),
                 ('state','[dev]'),
                 ('state','[dead]'),
                 ('state','[deprecated]'),
 
                 ('label','[personal]'),
                 ('generic','[v2.0.0]'),
 
                 ('lang','[lang =&gt; JavaScript]'),
                 ('license','[license =&gt; LicenseName]'),
 
                 ('ref','[requires =&gt; RepoName]'),
                 ('ref','[recommends =&gt; GroupName]'),
                 ('ref','[conflicts =&gt; SomeName]'),
                 ('ref','[base =&gt; SomeName]'),
                 ('url','[url =&gt; [linkName](https://rhodecode.com)]'),
                 ('see','[see =&gt; http://rhodecode.com]'),
             ]
         %>
         % for tag_type, tag in example_tags:
             <tr>
                 <td>${tag|n}</td>
                 <td>${h.style_metatag(tag_type, tag)|n}</td>
             </tr>
         % endfor
     </table>
 </%def>
 
 ## REPOSITORY RENDERERS
 <%def name="quick_menu(repo_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a title="${_('Summary')}" href="${h.route_path('repo_summary',repo_name=repo_name)}">
          <span>${_('Summary')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Changelog')}" href="${h.route_path('repo_changelog',repo_name=repo_name)}">
          <span>${_('Changelog')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Files')}" href="${h.route_path('repo_files:default_commit',repo_name=repo_name)}">
          <span>${_('Files')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Fork')}" href="${h.route_path('repo_fork_new',repo_name=repo_name)}">
          <span>${_('Fork')}</span>
          </a>
       </li>
     </ul>
   </div>
 </%def>
 
 <%def name="repo_name(name,rtype,rstate,private,fork_of,short_name=False,admin=False)">
     <%
     def get_name(name,short_name=short_name):
       if short_name:
         return name.split('/')[-1]
       else:
         return name
     %>
   <div class="${'repo_state_pending' if rstate == 'repo_state_pending' else ''} truncate">
     ##NAME
     <a href="${h.route_path('edit_repo',repo_name=name) if admin else h.route_path('repo_summary',repo_name=name)}">
 
     ##TYPE OF REPO
     %if h.is_hg(rtype):
         <span title="${_('Mercurial repository')}"><i class="icon-hg" style="font-size: 14px;"></i></span>
     %elif h.is_git(rtype):
         <span title="${_('Git repository')}"><i class="icon-git" style="font-size: 14px"></i></span>
     %elif h.is_svn(rtype):
         <span title="${_('Subversion repository')}"><i class="icon-svn" style="font-size: 14px"></i></span>
     %endif
 
     ##PRIVATE/PUBLIC
     %if private and c.visual.show_private_icon:
       <i class="icon-lock" title="${_('Private repository')}"></i>
     %elif not private and c.visual.show_public_icon:
       <i class="icon-unlock-alt" title="${_('Public repository')}"></i>
     %else:
       <span></span>
     %endif
     ${get_name(name)}
     </a>
     %if fork_of:
       <a href="${h.route_path('repo_summary',repo_name=fork_of.repo_name)}"><i class="icon-code-fork"></i></a>
     %endif
     %if rstate == 'repo_state_pending':
       <span class="creation_in_progress tooltip" title="${_('This repository is being created in a background task')}">
           (${_('creating...')})
       </span>
     %endif
   </div>
 </%def>
 
 <%def name="repo_desc(description, stylify_metatags)">
     <%
     tags, description = h.extract_metatags(description)
     %>
 
     <div class="truncate-wrap">
         % if stylify_metatags:
             % for tag_type, tag in tags:
                 ${h.style_metatag(tag_type, tag)|n}
             % endfor
         % endif
         ${description}
     </div>
 
 </%def>
 
 <%def name="last_change(last_change)">
     ${h.age_component(last_change)}
 </%def>
 
 <%def name="revision(name,rev,tip,author,last_msg)">
   <div>
   %if rev >= 0:
       <code><a title="${h.tooltip('%s:\n\n%s' % (author,last_msg))}" class="tooltip" href="${h.route_path('repo_commit',repo_name=name,commit_id=tip)}">${'r%s:%s' % (rev,h.short_id(tip))}</a></code>
   %else:
       ${_('No commits yet')}
   %endif
   </div>
 </%def>
 
 <%def name="rss(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="atom(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="user_gravatar(email, size=16)">
   <div class="rc-user tooltip" title="${h.tooltip(h.author_string(email))}">
     ${base.gravatar(email, 16)}
   </div>
 </%def>
 
 <%def name="repo_actions(repo_name, super_user=True)">
   <div>
     <div class="grid_edit">
       <a href="${h.route_path('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">
         <i class="icon-pencil"></i>Edit</a>
     </div>
     <div class="grid_delete">
       ${h.secure_form(h.route_path('edit_repo_advanced_delete', repo_name=repo_name), request=request)}
         ${h.submit('remove_%s' % repo_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo_name+"');")}
       ${h.end_form()}
     </div>
   </div>
 </%def>
 
 <%def name="repo_state(repo_state)">
   <div>
     %if repo_state == 'repo_state_pending':
         <div class="tag tag4">${_('Creating')}</div>
     %elif repo_state == 'repo_state_created':
         <div class="tag tag1">${_('Created')}</div>
     %else:
         <div class="tag alert2" title="${h.tooltip(repo_state)}">invalid</div>
     %endif
   </div>
 </%def>
 
 
 ## REPO GROUP RENDERERS
 <%def name="quick_repo_group_menu(repo_group_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">${_('Summary')}</a>
       </li>
 
     </ul>
   </div>
 </%def>
 
 <%def name="repo_group_name(repo_group_name, children_groups=None)">
   <div>
     <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">
     <i class="icon-folder-close" title="${_('Repository group')}" style="font-size: 16px"></i>
       %if children_groups:
           ${h.literal(' &raquo; '.join(children_groups))}
       %else:
           ${repo_group_name}
       %endif
   </a>
   </div>
 </%def>
 
 <%def name="repo_group_desc(description, personal, stylify_metatags)">
 
     <%
     tags, description = h.extract_metatags(description)
     %>
 
     <div class="truncate-wrap">
         % if personal:
             <div class="metatag" tag="personal">${_('personal')}</div>
         % endif
 
         % if stylify_metatags:
             % for tag_type, tag in tags:
                 ${h.style_metatag(tag_type, tag)|n}
             % endfor
         % endif
         ${description}
     </div>
 
 </%def>
 
 <%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">
  <div class="grid_edit">
-    <a href="${h.url('edit_repo_group',group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
+    <a href="${h.route_path('edit_repo_group',repo_group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
-    ${h.secure_form(h.url('delete_repo_group', group_name=repo_group_name),method='delete', request=request)}
+    ${h.secure_form(h.route_path('edit_repo_group_advanced_delete', repo_group_name=repo_group_name), request=request)}
         ${h.submit('remove_%s' % repo_group_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_ungettext('Confirm to delete this group: %s with %s repository','Confirm to delete this group: %s with %s repositories',gr_count) % (repo_group_name, gr_count)+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_actions(user_id, username)">
  <div class="grid_edit">
    <a href="${h.route_path('user_edit',user_id=user_id)}" title="${_('Edit')}">
      <i class="icon-pencil"></i>${_('Edit')}</a>
  </div>
  <div class="grid_delete">
   ${h.secure_form(h.route_path('user_delete', user_id=user_id), request=request)}
     ${h.submit('remove_',_('Delete'),id="remove_user_%s" % user_id, class_="btn btn-link btn-danger",
     onclick="return confirm('"+_('Confirm to delete this user: %s') % username+"');")}
   ${h.end_form()}
  </div>
 </%def>
 
 <%def name="user_group_actions(user_group_id, user_group_name)">
  <div class="grid_edit">
     <a href="${h.route_path('edit_user_group', user_group_id=user_group_id)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
     ${h.secure_form(h.route_path('user_groups_delete', user_group_id=user_group_id), request=request)}
       ${h.submit('remove_',_('Delete'),id="remove_group_%s" % user_group_id, class_="btn btn-link btn-danger",
       onclick="return confirm('"+_('Confirm to delete this user group: %s') % user_group_name+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_name(user_id, username)">
     ${h.link_to(h.person(username, 'username_or_name_or_email'), h.route_path('user_edit', user_id=user_id))}
 </%def>
 
 <%def name="user_profile(username)">
     ${base.gravatar_with_user(username, 16)}
 </%def>
 
 <%def name="user_group_name(user_group_id, user_group_name)">
   <div>
   <a href="${h.route_path('edit_user_group', user_group_id=user_group_id)}">
     <i class="icon-group" title="${_('User group')}"></i> ${user_group_name}</a>
   </div>
 </%def>
 
 
 ## GISTS
 
 <%def name="gist_gravatar(full_contact)">
     <div class="gist_gravatar">
       ${base.gravatar(full_contact, 30)}
     </div>
 </%def>
 
 <%def name="gist_access_id(gist_access_id, full_contact)">
     <div>
       <b>
         <a href="${h.route_path('gist_show', gist_id=gist_access_id)}">gist: ${gist_access_id}</a>
       </b>
     </div>
 </%def>
 
 <%def name="gist_author(full_contact, created_on, expires)">
     ${base.gravatar_with_user(full_contact, 16)}
 </%def>
 
 
 <%def name="gist_created(created_on)">
     <div class="created">
       ${h.age_component(created_on, time_is_local=True)}
     </div>
 </%def>
 
 <%def name="gist_expires(expires)">
     <div class="created">
           %if expires == -1:
             ${_('never')}
           %else:
             ${h.age_component(h.time_to_utcdatetime(expires))}
           %endif
     </div>
 </%def>
 
 <%def name="gist_type(gist_type)">
     %if gist_type != 'public':
       <div class="tag">${_('Private')}</div>
     %endif
 </%def>
 
 <%def name="gist_description(gist_description)">
   ${gist_description}
 </%def>
 
 
 ## PULL REQUESTS GRID RENDERERS
 
 <%def name="pullrequest_target_repo(repo_name)">
     <div class="truncate">
       ${h.link_to(repo_name,h.route_path('repo_summary',repo_name=repo_name))}
     </div>
 </%def>
 <%def name="pullrequest_status(status)">
     <div class="${'flag_status %s' % status} pull-left"></div>
 </%def>
 
 <%def name="pullrequest_title(title, description)">
     ${title} <br/>
     ${h.shorter(description, 40)}
 </%def>
 
 <%def name="pullrequest_comments(comments_nr)">
     <i class="icon-comment"></i> ${comments_nr}
 </%def>
 
 <%def name="pullrequest_name(pull_request_id, target_repo_name, short=False)">
     <a href="${h.route_path('pullrequest_show',repo_name=target_repo_name,pull_request_id=pull_request_id)}">
       % if short:
         #${pull_request_id}
       % else:
         ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
       % endif
     </a>
 </%def>
 
 <%def name="pullrequest_updated_on(updated_on)">
     ${h.age_component(h.time_to_utcdatetime(updated_on))}
 </%def>
 
 <%def name="pullrequest_author(full_contact)">
     ${base.gravatar_with_user(full_contact, 16)}
 </%def>

rhodecode/templates/index_base.mako

@@ -1,173 +1,173 b''
 <%inherit file="/base/base.mako"/>
 
 <%def name="main()">
    <div class="box">
         <!-- box / title -->
         <div class="title">
             <div class="block-left breadcrumbs">
               <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" placeholder="${_('quick filter...')}" value=""/>
               ${self.breadcrumbs()}
               <span id="match_container" style="display:none">&raquo; <span id="match_count">0</span> ${_('matches')}</span>
             </div>
             %if c.rhodecode_user.username != h.DEFAULT_USER:
               <div class="block-right">
                 <%
                     is_admin = h.HasPermissionAny('hg.admin')('can create repos index page')
                     create_repo = h.HasPermissionAny('hg.create.repository')('can create repository index page')
                     create_repo_group = h.HasPermissionAny('hg.repogroup.create.true')('can create repository groups index page')
                     create_user_group = h.HasPermissionAny('hg.usergroup.create.true')('can create user groups index page')
 
                     gr_name = c.repo_group.group_name if c.repo_group else None
                     # create repositories with write permission on group is set to true
                     create_on_write = h.HasPermissionAny('hg.create.write_on_repogroup.true')()
                     group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'group admin index page')
                     group_write = h.HasRepoGroupPermissionAny('group.write')(gr_name, 'can write into group index page')
                 %>
 
                 %if not c.repo_group:
                     ## no repository group context here
                     %if is_admin or create_repo:
                         <a href="${h.route_path('repo_new')}" class="btn btn-small btn-success btn-primary">${_('Add Repository')}</a>
                     %endif
 
                     %if is_admin or create_repo_group:
-                        <a href="${h.url('new_repo_group')}" class="btn btn-small btn-default">${_(u'Add Repository Group')}</a>
+                        <a href="${h.route_path('repo_group_new')}" class="btn btn-small btn-default">${_(u'Add Repository Group')}</a>
                     %endif
                 %else:
                     ##we're inside other repository group other terms apply
                     %if is_admin or group_admin or (group_write and create_on_write):
                         <a href="${h.route_path('repo_new',_query=dict(parent_group=c.repo_group.group_id))}" class="btn btn-small btn-success btn-primary">${_('Add Repository')}</a>
                     %endif
                     %if is_admin or group_admin:
-                        <a href="${h.url('new_repo_group', parent_group=c.repo_group.group_id)}" class="btn btn-small btn-default">${_(u'Add Repository Group')}</a>
+                        <a href="${h.route_path('repo_group_new',_query=dict(parent_group=c.repo_group.group_id))}" class="btn btn-small btn-default">${_(u'Add Repository Group')}</a>
                     %endif
                     %if is_admin or group_admin:
-                        <a href="${h.url('edit_repo_group',group_name=c.repo_group.group_name)}" title="${_('You have admin right to this group, and can edit it')}" class="btn btn-small btn-primary">${_('Edit Repository Group')}</a>
+                        <a href="${h.route_path('edit_repo_group',repo_group_name=c.repo_group.group_name)}" title="${_('You have admin right to this group, and can edit it')}" class="btn btn-small btn-primary">${_('Edit Repository Group')}</a>
                     %endif
                 %endif
               </div>
             %endif
         </div>
         <!-- end box / title -->
         <div class="table">
             <div id="groups_list_wrap">
                 <table id="group_list_table" class="display"></table>
             </div>
         </div>
 
         <div class="table">
             <div id="repos_list_wrap">
                 <table id="repo_list_table" class="display"></table>
             </div>
         </div>
     </div>
     <script>
       $(document).ready(function() {
 
         var get_datatable_count = function() {
           var api = $('#repo_list_table').dataTable().api();
           var pageInfo = api.page.info();
           var repos = pageInfo.recordsDisplay;
           var reposTotal = pageInfo.recordsTotal;
 
           api = $('#group_list_table').dataTable().api();
           pageInfo = api.page.info();
           var repoGroups = pageInfo.recordsDisplay;
           var repoGroupsTotal = pageInfo.recordsTotal;
 
           if (repoGroups !== repoGroupsTotal) {
             $('#match_count').text(repos+repoGroups);
           }
           if (repos !== reposTotal) {
             $('#match_container').show();
           }
           if ($('#q_filter').val() === '') {
             $('#match_container').hide();
           }
         };
 
        // repo group list
        $('#group_list_table').DataTable({
           data: ${c.repo_groups_data|n},
           dom: 'rtp',
           pageLength: ${c.visual.dashboard_items},
           order: [[ 0, "asc" ]],
           columns: [
              { data: {"_": "name",
                       "sort": "name_raw"}, title: "${_('Name')}", className: "td-componentname" },
              { data: 'menu', "bSortable": false, className: "quick_repo_menu" },
              { data: {"_": "desc",
                       "sort": "desc"}, title: "${_('Description')}", className: "td-description" },
              { data: {"_": "last_change",
                       "sort": "last_change_raw",
                       "type": Number}, title: "${_('Last Change')}", className: "td-time" },
              { data: {"_": "owner",
                       "sort": "owner"}, title: "${_('Owner')}", className: "td-user" }
           ],
           language: {
             paginate: DEFAULT_GRID_PAGINATION,
             emptyTable: _gettext("No repository groups available yet.")
           },
           "drawCallback": function( settings, json ) {
               timeagoActivate();
               quick_repo_menu();
           }
         });
 
         // repo list
         $('#repo_list_table').DataTable({
           data: ${c.repos_data|n},
           dom: 'rtp',
           order: [[ 0, "asc" ]],
           pageLength: ${c.visual.dashboard_items},
           columns: [
              { data: {"_": "name",
                       "sort": "name_raw"}, title: "${_('Name')}", className: "truncate-wrap td-componentname" },
              { data: 'menu', "bSortable": false, className: "quick_repo_menu" },
              { data: {"_": "desc",
                       "sort": "desc"}, title: "${_('Description')}", className: "td-description" },
              { data: {"_": "last_change",
                       "sort": "last_change_raw",
                       "type": Number}, title: "${_('Last Change')}", className: "td-time" },
              { data: {"_": "last_changeset",
                       "sort": "last_changeset_raw",
                       "type": Number}, title: "${_('Commit')}", className: "td-hash" },
              { data: {"_": "owner",
                       "sort": "owner"}, title: "${_('Owner')}", className: "td-user" },
           ],
           language: {
               paginate: DEFAULT_GRID_PAGINATION,
               emptyTable: _gettext("No repositories available yet.")
           },
           "drawCallback": function( settings, json ) {
               timeagoActivate();
               quick_repo_menu();
           }
         });
 
         // update the counter when doing search
        $('#repo_list_table, #group_list_table').on( 'search.dt', function (e,settings) {
           get_datatable_count();
         });
 
         // filter, filter both grids
         $('#q_filter').on( 'keyup', function () {
           var repo_api = $('#repo_list_table').dataTable().api();
           repo_api
             .columns( 0 )
             .search( this.value )
             .draw();
 
           var repo_group_api = $('#group_list_table').dataTable().api();
           repo_group_api
             .columns( 0 )
             .search( this.value )
             .draw();
         });
 
         // refilter table if page load via back button
         $("#q_filter").trigger('keyup');
 
       });
     </script>
 </%def>

rhodecode/tests/functional/test_delegated_admin.py

@@ -1,150 +1,152 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 pytest
 
-from rhodecode.tests import TestController, url
+from rhodecode.tests import TestController
 from rhodecode.tests.fixture import Fixture
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
     from rhodecode.apps._base import ADMIN_PREFIX
 
     base_url = {
         'home': '/',
         'repos':
             ADMIN_PREFIX + '/repos',
+        'repo_groups':
+            ADMIN_PREFIX + '/repo_groups',
         'user_groups':
             ADMIN_PREFIX + '/user_groups',
         'user_groups_data':
             ADMIN_PREFIX + '/user_groups_data',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 fixture = Fixture()
 
 
 class TestAdminDelegatedUser(TestController):
 
     def test_regular_user_cannot_see_admin_interfaces(
             self, user_util, xhr_header):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         # check if in home view, such user doesn't see the "admin" menus
         response = self.app.get(route_path('home'))
 
         assert_response = response.assert_response()
 
         assert_response.no_element_exists('li.local-admin-repos')
         assert_response.no_element_exists('li.local-admin-repo-groups')
         assert_response.no_element_exists('li.local-admin-user-groups')
 
         response = self.app.get(route_path('repos'), status=200)
         response.mustcontain('data: []')
 
-        response = self.app.get(url('repo_groups'), status=200)
+        response = self.app.get(route_path('repo_groups'), status=200)
         response.mustcontain('data: []')
 
         response = self.app.get(route_path('user_groups_data'),
                                 status=200, extra_environ=xhr_header)
         assert response.json['data'] == []
 
     def test_regular_user_can_see_admin_interfaces_if_owner(
             self, user_util, xhr_header):
         user = user_util.create_user(password='qweqwe')
         username = user.username
 
         repo = user_util.create_repo(owner=username)
         repo_name = repo.repo_name
 
         repo_group = user_util.create_repo_group(owner=username)
         repo_group_name = repo_group.group_name
 
         user_group = user_util.create_user_group(owner=username)
         user_group_name = user_group.users_group_name
 
         self.log_user(username, 'qweqwe')
         # check if in home view, such user doesn't see the "admin" menus
         response = self.app.get(route_path('home'))
 
         assert_response = response.assert_response()
 
         assert_response.one_element_exists('li.local-admin-repos')
         assert_response.one_element_exists('li.local-admin-repo-groups')
         assert_response.one_element_exists('li.local-admin-user-groups')
 
         # admin interfaces have visible elements
         response = self.app.get(route_path('repos'), status=200)
         response.mustcontain('"name_raw": "{}"'.format(repo_name))
 
-        response = self.app.get(url('repo_groups'), status=200)
+        response = self.app.get(route_path('repo_groups'), status=200)
         response.mustcontain('"name_raw": "{}"'.format(repo_group_name))
 
         response = self.app.get(route_path('user_groups_data'),
                                 extra_environ=xhr_header, status=200)
         response.mustcontain('"name_raw": "{}"'.format(user_group_name))
 
     def test_regular_user_can_see_admin_interfaces_if_admin_perm(
             self, user_util, xhr_header):
         user = user_util.create_user(password='qweqwe')
         username = user.username
 
         repo = user_util.create_repo()
         repo_name = repo.repo_name
 
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
 
         user_group = user_util.create_user_group()
         user_group_name = user_group.users_group_name
 
         user_util.grant_user_permission_to_repo(
             repo, user, 'repository.admin')
         user_util.grant_user_permission_to_repo_group(
             repo_group, user, 'group.admin')
         user_util.grant_user_permission_to_user_group(
             user_group, user, 'usergroup.admin')
 
         self.log_user(username, 'qweqwe')
         # check if in home view, such user doesn't see the "admin" menus
         response = self.app.get(route_path('home'))
 
         assert_response = response.assert_response()
 
         assert_response.one_element_exists('li.local-admin-repos')
         assert_response.one_element_exists('li.local-admin-repo-groups')
         assert_response.one_element_exists('li.local-admin-user-groups')
 
         # admin interfaces have visible elements
         response = self.app.get(route_path('repos'), status=200)
         response.mustcontain('"name_raw": "{}"'.format(repo_name))
 
-        response = self.app.get(url('repo_groups'), status=200)
+        response = self.app.get(route_path('repo_groups'), status=200)
         response.mustcontain('"name_raw": "{}"'.format(repo_group_name))
 
         response = self.app.get(route_path('user_groups_data'),
                                 extra_environ=xhr_header, status=200)
         response.mustcontain('"name_raw": "{}"'.format(user_group_name))

rhodecode/tests/lib/test_utils.py

@@ -1,468 +1,450 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 json
 import multiprocessing
 import os
 
 import mock
 import py
 import pytest
 
 from rhodecode.lib import caching_query
 from rhodecode.lib import utils
 from rhodecode.lib.utils2 import md5
 from rhodecode.model import settings
 from rhodecode.model import db
 from rhodecode.model import meta
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.settings import UiSetting, SettingsModel
 from rhodecode.tests.fixture import Fixture
-from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 
 fixture = Fixture()
 
 
 def extract_hooks(config):
     """Return a dictionary with the hook entries of the given config."""
     hooks = {}
     config_items = config.serialize()
     for section, name, value in config_items:
         if section != 'hooks':
             continue
         hooks[name] = value
 
     return hooks
 
 
 def disable_hooks(request, hooks):
     """Disables the given hooks from the UI settings."""
     session = meta.Session()
 
     model = SettingsModel()
     for hook_key in hooks:
         sett = model.get_ui_by_key(hook_key)
         sett.ui_active = False
         session.add(sett)
 
     # Invalidate cache
     ui_settings = session.query(db.RhodeCodeUi).options(
         caching_query.FromCache('sql_cache_short', 'get_hg_ui_settings'))
     ui_settings.invalidate()
 
     ui_settings = session.query(db.RhodeCodeUi).options(
         caching_query.FromCache(
             'sql_cache_short', 'get_hook_settings', 'get_hook_settings'))
     ui_settings.invalidate()
 
     @request.addfinalizer
     def rollback():
         session.rollback()
 
 
 HOOK_PRE_PUSH = db.RhodeCodeUi.HOOK_PRE_PUSH
 HOOK_PRETX_PUSH = db.RhodeCodeUi.HOOK_PRETX_PUSH
 HOOK_PUSH = db.RhodeCodeUi.HOOK_PUSH
 HOOK_PRE_PULL = db.RhodeCodeUi.HOOK_PRE_PULL
 HOOK_PULL = db.RhodeCodeUi.HOOK_PULL
 HOOK_REPO_SIZE = db.RhodeCodeUi.HOOK_REPO_SIZE
 HOOK_PUSH_KEY = db.RhodeCodeUi.HOOK_PUSH_KEY
 
 HG_HOOKS = frozenset(
     (HOOK_PRE_PULL, HOOK_PULL, HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_PUSH,
      HOOK_REPO_SIZE, HOOK_PUSH_KEY))
 
 
 @pytest.mark.parametrize('disabled_hooks,expected_hooks', [
     ([], HG_HOOKS),
     (HG_HOOKS, []),
 
     ([HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_REPO_SIZE, HOOK_PUSH_KEY], [HOOK_PRE_PULL, HOOK_PULL, HOOK_PUSH]),
 
     # When a pull/push hook is disabled, its pre-pull/push counterpart should
     # be disabled too.
     ([HOOK_PUSH], [HOOK_PRE_PULL, HOOK_PULL, HOOK_REPO_SIZE]),
     ([HOOK_PULL], [HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_PUSH, HOOK_REPO_SIZE,
                    HOOK_PUSH_KEY]),
 ])
 def test_make_db_config_hg_hooks(pylonsapp, request, disabled_hooks,
                                  expected_hooks):
     disable_hooks(request, disabled_hooks)
 
     config = utils.make_db_config()
     hooks = extract_hooks(config)
 
     assert set(hooks.iterkeys()).intersection(HG_HOOKS) == set(expected_hooks)
 
 
 @pytest.mark.parametrize('disabled_hooks,expected_hooks', [
     ([], ['pull', 'push']),
     ([HOOK_PUSH], ['pull']),
     ([HOOK_PULL], ['push']),
     ([HOOK_PULL, HOOK_PUSH], []),
 ])
 def test_get_enabled_hook_classes(disabled_hooks, expected_hooks):
     hook_keys = (HOOK_PUSH, HOOK_PULL)
     ui_settings = [
         ('hooks', key, 'some value', key not in disabled_hooks)
         for key in hook_keys]
 
     result = utils.get_enabled_hook_classes(ui_settings)
     assert sorted(result) == expected_hooks
 
 
 def test_get_filesystem_repos_finds_repos(tmpdir, pylonsapp):
     _stub_git_repo(tmpdir.ensure('repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == [('repo', ('git', tmpdir.join('repo')))]
 
 
 def test_get_filesystem_repos_skips_directories(tmpdir, pylonsapp):
     tmpdir.ensure('not-a-repo', dir=True)
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_directories_with_repos(tmpdir, pylonsapp):
     _stub_git_repo(tmpdir.ensure('subdir/repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_finds_repos_in_subdirectories(tmpdir, pylonsapp):
     _stub_git_repo(tmpdir.ensure('subdir/repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir), recursive=True))
     assert repos == [('subdir/repo', ('git', tmpdir.join('subdir', 'repo')))]
 
 
 def test_get_filesystem_repos_skips_names_starting_with_dot(tmpdir):
     _stub_git_repo(tmpdir.ensure('.repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_files(tmpdir):
     tmpdir.ensure('test-file')
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_removed_repositories(tmpdir):
     removed_repo_name = 'rm__00000000_000000_000000__.stub'
     assert utils.REMOVED_REPO_PAT.match(removed_repo_name)
     _stub_git_repo(tmpdir.ensure(removed_repo_name, dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def _stub_git_repo(repo_path):
     """
     Make `repo_path` look like a Git repository.
     """
     repo_path.ensure('.git', dir=True)
 
 
 @pytest.mark.parametrize('str_class', [str, unicode], ids=['str', 'unicode'])
 def test_get_dirpaths_returns_all_paths(tmpdir, str_class):
     tmpdir.ensure('test-file')
     dirpaths = utils._get_dirpaths(str_class(tmpdir))
     assert dirpaths == ['test-file']
 
 
 def test_get_dirpaths_returns_all_paths_bytes(
         tmpdir, platform_encodes_filenames):
     if platform_encodes_filenames:
         pytest.skip("This platform seems to encode filenames.")
     tmpdir.ensure('repo-a-umlaut-\xe4')
     dirpaths = utils._get_dirpaths(str(tmpdir))
     assert dirpaths == ['repo-a-umlaut-\xe4']
 
 
 def test_get_dirpaths_skips_paths_it_cannot_decode(
         tmpdir, platform_encodes_filenames):
     if platform_encodes_filenames:
         pytest.skip("This platform seems to encode filenames.")
     path_with_latin1 = 'repo-a-umlaut-\xe4'
     tmpdir.ensure(path_with_latin1)
     dirpaths = utils._get_dirpaths(unicode(tmpdir))
     assert dirpaths == []
 
 
 @pytest.fixture(scope='session')
 def platform_encodes_filenames():
     """
     Boolean indicator if the current platform changes filename encodings.
     """
     path_with_latin1 = 'repo-a-umlaut-\xe4'
     tmpdir = py.path.local.mkdtemp()
     tmpdir.ensure(path_with_latin1)
     read_path = tmpdir.listdir()[0].basename
     tmpdir.remove()
     return path_with_latin1 != read_path
 
 
[e-mail]
-def repo_groups(request):
-    session = meta.Session()
-    zombie_group = fixture.create_repo_group('zombie')
-    parent_group = fixture.create_repo_group('parent')
-    child_group = fixture.create_repo_group('parent/child')
-    groups_in_db = session.query(db.RepoGroup).all()
-    assert len(groups_in_db) == 3
-    assert child_group.group_parent_id == parent_group.group_id
-
-    @request.addfinalizer
-    def cleanup():
-        fixture.destroy_repo_group(zombie_group)
-        fixture.destroy_repo_group(child_group)
-        fixture.destroy_repo_group(parent_group)
-
-    return (zombie_group, parent_group, child_group)
 
 
 def test_repo2db_mapper_groups(repo_groups):
     session = meta.Session()
     zombie_group, parent_group, child_group = repo_groups
     zombie_path = os.path.join(
         RepoGroupModel().repos_path, zombie_group.full_path)
     os.rmdir(zombie_path)
 
     # Avoid removing test repos when calling repo2db_mapper
     repo_list = {
         repo.repo_name: 'test' for repo in session.query(db.Repository).all()
     }
     utils.repo2db_mapper(repo_list, remove_obsolete=True)
 
     groups_in_db = session.query(db.RepoGroup).all()
     assert child_group in groups_in_db
     assert parent_group in groups_in_db
     assert zombie_path not in groups_in_db
 
 
 def test_repo2db_mapper_enables_largefiles(backend):
     repo = backend.create_repo()
     repo_list = {repo.repo_name: 'test'}
     with mock.patch('rhodecode.model.db.Repository.scm_instance') as scm_mock:
         with mock.patch.multiple('rhodecode.model.scm.ScmModel',
                                  install_git_hook=mock.DEFAULT,
                                  install_svn_hooks=mock.DEFAULT):
             utils.repo2db_mapper(repo_list, remove_obsolete=False)
             _, kwargs = scm_mock.call_args
             assert kwargs['config'].get('extensions', 'largefiles') == ''
 
 
 @pytest.mark.backends("git", "svn")
 def test_repo2db_mapper_installs_hooks_for_repos_in_db(backend):
     repo = backend.create_repo()
     repo_list = {repo.repo_name: 'test'}
     with mock.patch.object(ScmModel, 'install_hooks') as install_hooks_mock:
         utils.repo2db_mapper(repo_list, remove_obsolete=False)
     install_hooks_mock.assert_called_once_with(
         repo.scm_instance(), repo_type=backend.alias)
 
 
 @pytest.mark.backends("git", "svn")
 def test_repo2db_mapper_installs_hooks_for_newly_added_repos(backend):
     repo = backend.create_repo()
     RepoModel().delete(repo, fs_remove=False)
     meta.Session().commit()
     repo_list = {repo.repo_name: repo.scm_instance()}
     with mock.patch.object(ScmModel, 'install_hooks') as install_hooks_mock:
         utils.repo2db_mapper(repo_list, remove_obsolete=False)
     assert install_hooks_mock.call_count == 1
     install_hooks_args, _ = install_hooks_mock.call_args
     assert install_hooks_args[0].name == repo.repo_name
 
 
 class TestPasswordChanged(object):
     def setup(self):
         self.session = {
             'rhodecode_user': {
                 'password': '0cc175b9c0f1b6a831c399e269772661'
             }
         }
         self.auth_user = mock.Mock()
         self.auth_user.userame = 'test'
         self.auth_user.password = 'abc123'
 
     def test_returns_false_for_default_user(self):
         self.auth_user.username = db.User.DEFAULT_USER
         result = utils.password_changed(self.auth_user, self.session)
         assert result is False
 
     def test_returns_false_if_password_was_not_changed(self):
         self.session['rhodecode_user']['password'] = md5(
             self.auth_user.password)
         result = utils.password_changed(self.auth_user, self.session)
         assert result is False
 
     def test_returns_true_if_password_was_changed(self):
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
     def test_returns_true_if_auth_user_password_is_empty(self):
         self.auth_user.password = None
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
     def test_returns_true_if_session_password_is_empty(self):
         self.session['rhodecode_user'].pop('password')
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
 
 class TestReadOpensourceLicenses(object):
     def test_success(self):
         utils._license_cache = None
         json_data = '''
         {
             "python2.7-pytest-2.7.1": {"UNKNOWN": null},
             "python2.7-Markdown-2.6.2": {
                 "BSD-3-Clause": "http://spdx.org/licenses/BSD-3-Clause"
             }
         }
         '''
         resource_string_patch = mock.patch.object(
             utils.pkg_resources, 'resource_string', return_value=json_data)
         with resource_string_patch:
             result = utils.read_opensource_licenses()
         assert result == json.loads(json_data)
 
     def test_caching(self):
         utils._license_cache = {
             "python2.7-pytest-2.7.1": {
                 "UNKNOWN": None
             },
             "python2.7-Markdown-2.6.2": {
                 "BSD-3-Clause": "http://spdx.org/licenses/BSD-3-Clause"
             }
         }
         resource_patch = mock.patch.object(
             utils.pkg_resources, 'resource_string', side_effect=Exception)
         json_patch = mock.patch.object(
             utils.json, 'loads', side_effect=Exception)
 
         with resource_patch as resource_mock, json_patch as json_mock:
             result = utils.read_opensource_licenses()
 
         assert resource_mock.call_count == 0
         assert json_mock.call_count == 0
         assert result == utils._license_cache
 
     def test_licenses_file_contains_no_unknown_licenses(self):
         utils._license_cache = None
         result = utils.read_opensource_licenses()
         license_names = []
         for licenses in result.values():
             license_names.extend(licenses.keys())
         assert 'UNKNOWN' not in license_names
 
 
 class TestMakeDbConfig(object):
     def test_data_from_config_data_from_db_returned(self):
         test_data = [
             ('section1', 'option1', 'value1'),
             ('section2', 'option2', 'value2'),
             ('section3', 'option3', 'value3'),
         ]
         with mock.patch.object(utils, 'config_data_from_db') as config_mock:
             config_mock.return_value = test_data
             kwargs = {'clear_session': False, 'repo': 'test_repo'}
             result = utils.make_db_config(**kwargs)
         config_mock.assert_called_once_with(**kwargs)
         for section, option, expected_value in test_data:
             value = result.get(section, option)
             assert value == expected_value
 
 
 class TestConfigDataFromDb(object):
     def test_config_data_from_db_returns_active_settings(self):
         test_data = [
             UiSetting('section1', 'option1', 'value1', True),
             UiSetting('section2', 'option2', 'value2', True),
             UiSetting('section3', 'option3', 'value3', False),
         ]
         repo_name = 'test_repo'
 
         model_patch = mock.patch.object(settings, 'VcsSettingsModel')
         hooks_patch = mock.patch.object(
             utils, 'get_enabled_hook_classes',
             return_value=['pull', 'push', 'repo_size'])
         with model_patch as model_mock, hooks_patch:
             instance_mock = mock.Mock()
             model_mock.return_value = instance_mock
             instance_mock.get_ui_settings.return_value = test_data
             result = utils.config_data_from_db(
                 clear_session=False, repo=repo_name)
 
         self._assert_repo_name_passed(model_mock, repo_name)
 
         expected_result = [
             ('section1', 'option1', 'value1'),
             ('section2', 'option2', 'value2'),
         ]
         assert result == expected_result
 
     def _assert_repo_name_passed(self, model_mock, repo_name):
         assert model_mock.call_count == 1
         call_args, call_kwargs = model_mock.call_args
         assert call_kwargs['repo'] == repo_name
 
 
 class TestIsDirWritable(object):
     def test_returns_false_when_not_writable(self):
         with mock.patch('__builtin__.open', side_effect=OSError):
             assert not utils._is_dir_writable('/stub-path')
 
     def test_returns_true_when_writable(self, tmpdir):
         assert utils._is_dir_writable(str(tmpdir))
 
     def test_is_safe_against_race_conditions(self, tmpdir):
         workers = multiprocessing.Pool()
         directories = [str(tmpdir)] * 10
         workers.map(utils._is_dir_writable, directories)
 
 
 class TestGetEnabledHooks(object):
     def test_only_active_hooks_are_enabled(self):
         ui_settings = [
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PUSH, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_REPO_SIZE, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PULL, 'value', False)
         ]
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == ['push', 'repo_size']
 
     def test_all_hooks_are_enabled(self):
         ui_settings = [
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PUSH, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_REPO_SIZE, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PULL, 'value', True)
         ]
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == ['push', 'repo_size', 'pull']
 
     def test_no_enabled_hooks_when_no_hook_settings_are_found(self):
         ui_settings = []
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == []

rhodecode/tests/models/test_repo_groups.py

@@ -1,223 +1,223 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 os
 
 from sqlalchemy.exc import IntegrityError
 import pytest
 
 from rhodecode.tests import TESTS_TMP_PATH
 from rhodecode.tests.fixture import Fixture
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.db import RepoGroup
 from rhodecode.model.meta import Session
 
 
 fixture = Fixture()
 
 
 def _update_group(id_, group_name, desc='desc', parent_id=None):
     form_data = fixture._get_group_create_params(group_name=group_name,
                                                  group_desc=desc,
                                                  group_parent_id=parent_id)
     gr = RepoGroupModel().update(id_, form_data)
     return gr
 
 
 def _update_repo(name, **kwargs):
     form_data = fixture._get_repo_create_params(**kwargs)
     if 'repo_name' not in kwargs:
         form_data['repo_name'] = name
 
     if 'perm_additions' not in kwargs:
         form_data['perm_additions'] = []
     if 'perm_updates' not in kwargs:
         form_data['perm_updates'] = []
     if 'perm_deletions' not in kwargs:
         form_data['perm_deletions'] = []
 
     r = RepoModel().update(name, **form_data)
     return r
 
 
-class TestRepoGroups:
+class TestRepoGroups(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self, request):
         self.g1 = fixture.create_repo_group('test1', skip_if_exists=True)
         self.g2 = fixture.create_repo_group('test2', skip_if_exists=True)
         self.g3 = fixture.create_repo_group('test3', skip_if_exists=True)
         request.addfinalizer(Session.remove)
 
     def __check_path(self, *path):
         """
         Checks the path for existance !
         """
         path = [TESTS_TMP_PATH] + list(path)
         path = os.path.join(*path)
         return os.path.isdir(path)
 
     def __delete_group(self, id_):
         RepoGroupModel().delete(id_)
 
     def test_create_group(self):
         g = fixture.create_repo_group('newGroup')
         Session().commit()
         assert g.full_path == 'newGroup'
 
         assert self.__check_path('newGroup')
 
     def test_create_same_name_group(self):
         with pytest.raises(IntegrityError):
             fixture.create_repo_group('newGroup')
         Session().rollback()
 
     def test_same_subgroup(self):
         sg1 = fixture.create_repo_group('test1/sub1')
         assert sg1.parent_group == self.g1
         assert sg1.full_path == 'test1/sub1'
         assert self.__check_path('test1', 'sub1')
 
         ssg1 = fixture.create_repo_group('test1/sub1/subsub1')
         assert ssg1.parent_group == sg1
         assert ssg1.full_path == 'test1/sub1/subsub1'
         assert self.__check_path('test1', 'sub1', 'subsub1')
 
     def test_remove_group(self):
         sg1 = fixture.create_repo_group('deleteme')
         self.__delete_group(sg1.group_id)
 
         assert RepoGroup.get(sg1.group_id) is None
         assert not self.__check_path('deteteme')
 
         sg1 = fixture.create_repo_group('test1/deleteme')
         self.__delete_group(sg1.group_id)
 
         assert RepoGroup.get(sg1.group_id) is None
         assert not self.__check_path('test1', 'deteteme')
 
     def test_rename_single_group(self):
         sg1 = fixture.create_repo_group('initial')
 
         _update_group(sg1.group_id, 'after')
         assert self.__check_path('after')
         assert RepoGroup.get_by_group_name('initial') is None
 
     def test_update_group_parent(self):
 
         sg1 = fixture.create_repo_group('test1/initial')
 
         _update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)
         assert self.__check_path('test1', 'after')
         assert RepoGroup.get_by_group_name('test1/initial') is None
 
         _update_group(sg1.group_id, 'after', parent_id=self.g3.group_id)
         assert self.__check_path('test3', 'after')
         assert RepoGroup.get_by_group_name('test3/initial') is None
 
         new_sg1 = _update_group(sg1.group_id, 'hello')
         assert self.__check_path('hello')
 
         assert RepoGroup.get_by_group_name('hello') == new_sg1
 
     def test_subgrouping_with_repo(self):
 
         g1 = fixture.create_repo_group('g1')
         g2 = fixture.create_repo_group('g2')
         # create new repo
         r = fixture.create_repo('john')
 
         assert r.repo_name == 'john'
         # put repo into group
         r = _update_repo('john', repo_group=g1.group_id)
         Session().commit()
         assert r.repo_name == 'g1/john'
 
         _update_group(g1.group_id, 'g1', parent_id=g2.group_id)
         assert self.__check_path('g2', 'g1')
 
         # test repo
         assert r.repo_name == RepoGroup.url_sep().join(
             ['g2', 'g1', r.just_name])
 
     def test_move_to_root(self):
         fixture.create_repo_group('t11')
         g2 = fixture.create_repo_group('t11/t22')
 
         assert g2.full_path == 't11/t22'
         assert self.__check_path('t11', 't22')
 
         g2 = _update_group(g2.group_id, 'g22', parent_id=None)
         Session().commit()
 
         assert g2.group_name == 'g22'
         # we moved out group from t1 to '' so it's full path should be 'g2'
         assert g2.full_path == 'g22'
         assert not self.__check_path('t11', 't22')
         assert self.__check_path('g22')
 
     def test_rename_top_level_group_in_nested_setup(self):
         g1 = fixture.create_repo_group('L1')
         g2 = fixture.create_repo_group('L1/L2')
         g3 = fixture.create_repo_group('L1/L2/L3')
 
         r = fixture.create_repo('L1/L2/L3/L3_REPO', repo_group=g3.group_id)
 
         # rename L1 all groups should be now changed
         _update_group(g1.group_id, 'L1_NEW')
         Session().commit()
         assert g1.full_path == 'L1_NEW'
         assert g2.full_path == 'L1_NEW/L2'
         assert g3.full_path == 'L1_NEW/L2/L3'
         assert r.repo_name == 'L1_NEW/L2/L3/L3_REPO'
 
     def test_change_parent_of_top_level_group_in_nested_setup(self):
         g1 = fixture.create_repo_group('R1')
         g2 = fixture.create_repo_group('R1/R2')
         g3 = fixture.create_repo_group('R1/R2/R3')
         g4 = fixture.create_repo_group('R1_NEW')
 
         r = fixture.create_repo('R1/R2/R3/R3_REPO', repo_group=g3.group_id)
         # rename L1 all groups should be now changed
         _update_group(g1.group_id, 'R1', parent_id=g4.group_id)
         Session().commit()
         assert g1.full_path == 'R1_NEW/R1'
         assert g2.full_path == 'R1_NEW/R1/R2'
         assert g3.full_path == 'R1_NEW/R1/R2/R3'
         assert r.repo_name == 'R1_NEW/R1/R2/R3/R3_REPO'
 
     def test_change_parent_of_top_level_group_in_nested_setup_with_rename(
             self):
         g1 = fixture.create_repo_group('X1')
         g2 = fixture.create_repo_group('X1/X2')
         g3 = fixture.create_repo_group('X1/X2/X3')
         g4 = fixture.create_repo_group('X1_NEW')
 
         r = fixture.create_repo('X1/X2/X3/X3_REPO', repo_group=g3.group_id)
 
         # rename L1 all groups should be now changed
         _update_group(g1.group_id, 'X1_PRIM', parent_id=g4.group_id)
         Session().commit()
         assert g1.full_path == 'X1_NEW/X1_PRIM'
         assert g2.full_path == 'X1_NEW/X1_PRIM/X2'
         assert g3.full_path == 'X1_NEW/X1_PRIM/X2/X3'
         assert r.repo_name == 'X1_NEW/X1_PRIM/X2/X3/X3_REPO'

rhodecode/tests/plugin.py

@@ -1,1832 +1,1858 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 collections
 import datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess32
 import time
 import uuid
 import dateutil.tz
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 
 import rhodecode
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
     UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs import create_vcsserver_proxy
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.utils import CustomTestApp, set_anonymous_access, add_test_routes
 from rhodecode.tests.fixture import Fixture
 
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     # Appy the kombu patch early on, needed for test discovery on Python 2.7.11
     from rhodecode.config import patches
     patches.kombu_1_5_1_python_2_7_11()
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.function.backends.args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.tests.other import example_rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = example_rcextensions
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
 @pytest.fixture
 def capture_rcextensions():
     """
     Returns the recorded calls to entry points in rcextensions.
     """
     calls = rhodecode.EXTENSIONS.calls
     calls.clear()
     # Note: At this moment, it is still the empty dict, but that will
     # be filled during the test run and since it is a reference this
     # is enough to make it work.
     return calls
 
 
 @pytest.fixture(scope='session')
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return http_environ(
         http_host_stub=http_host_stub())
 
 
 @pytest.fixture
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'example.com:80'
 
 
 @pytest.fixture
 def http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return http_host_stub().split(':')[0]
 
 
 @pytest.fixture
 def http_environ(http_host_stub):
     """
     HTTP extra environ keys.
 
     User by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         'SERVER_NAME': http_host_only_stub(),
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
         'HTTP_USER_AGENT': 'rc-test-agent',
         'REQUEST_METHOD': 'GET'
     }
 
 
 @pytest.fixture(scope='function')
 def app(request, config_stub, pylonsapp, http_environ):
     app = CustomTestApp(
         pylonsapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     from paste.deploy.loadwsgi import loadcontext, APP
     from rhodecode.config.middleware import (
         sanitize_settings_and_apply_defaults)
     context = loadcontext(APP, 'config:' + pylons_config)
     settings = sanitize_settings_and_apply_defaults(context.config())
     return settings
 
 
 @pytest.fixture(scope='session')
 def db(app_settings):
     """
     Initializes the database connection.
 
     It uses the same settings which are used to create the ``pylonsapp`` or
     ``app`` fixtures.
     """
     from rhodecode.config.utils import initialize_database
     initialize_database(app_settings)
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
 @pytest.fixture
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(
         app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope='function')
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope='function')
 def xhr_header(request):
     return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
 
 
 @pytest.fixture
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, 'is_test', False)
 
 
 @pytest.fixture(scope='class')
 def index_location(request, pylonsapp):
     index_location = pylonsapp.config['app_conf']['search.location']
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope='session', autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption('--keep-tmp-path'):
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = 'test_repo_group_%s' % str(time.time()).replace('.', '')
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = 'test_user_group_%s' % str(time.time()).replace('.', '')
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope='session')
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         'git': utils.extract_git_repo_from_dump,
         'hg': utils.extract_hg_repo_from_dump,
         'svn': utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
     def __call__(self, dump_name, backend_alias, config=None):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             repo = self._create_repo(dump_name, backend_alias, config)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias, config):
         repo_name = '%s-%s' % (backend_alias, dump_name)
         backend_class = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
 
         vcs_repo = backend_class(repo_path, config=config)
         repo2db_mapper({repo_name: vcs_repo})
 
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 @pytest.fixture
 def backend(request, backend_alias, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     backend = Backend(
         alias=backend_alias,
         repo_name=repo_name,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def backend_git(request, pylonsapp, test_repo):
     return backend(request, 'git', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, pylonsapp, test_repo):
     return backend(request, 'hg', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, pylonsapp, test_repo):
     return backend(request, 'svn', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     def create_test_repo(self, key, config=None):
         return self._test_repo_container(key, self.alias, config)
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
 
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
             self.repo_name, repo_type=self.alias, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, self.repo_name)}
             for x in xrange(number_of_commits)]
         self._add_commits_to_repo(repo.scm_instance(), commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name),
             len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 @pytest.fixture
 def vcsbackend(request, backend_alias, tests_tmp_path, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias,
         repo_path=repo_path,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def vcsbackend_git(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_random(vcsbackend_git):
     """
     Use this to express that your tests need "a vcsbackend".
 
     The fixture `vcsbackend` would run the test multiple times for each
     available vcs backend which is a pure waste of time if the test is
     independent of the vcs backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return vcsbackend_git
 
 
 @pytest.fixture
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic')
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
     commit = None
 
     for idx, commit in enumerate(commits):
         message = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture
 def pr_util(backend, request, config_stub):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
 
     @request.addfinalizer
     def cleanup():
         util.cleanup()
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         return [
             (TEST_USER_REGULAR_LOGIN, ['default1'], False),
             (TEST_USER_REGULAR2_LOGIN, ['default2'], False),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request, pull_request.author)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(pylonsapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_regular(pylonsapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_util(request, pylonsapp):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
         self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.repos_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def _sanitize_name(self, name):
         for char in ['[', ']']:
             name = name.replace(char, '_')
         return name
 
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(
             prefix=self._test_name,
             count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(
             group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None,
                     auto_cleanup=True, repo_type='hg'):
         repo_name = "{prefix}_repository_{count}".format(
             prefix=self._test_name,
             count=len(self.repos_ids))
 
         repository = self.fixture.create_repo(
             repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type)
         if auto_cleanup:
             self.repos_ids.append(repository.repo_id)
         return repository
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(
             prefix=self._test_name,
             count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, owner=TEST_USER_ADMIN_LOGIN, members=None,
                           auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(
             prefix=self._test_name,
             count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(
             group_name, cur_user=owner, **kwargs)
 
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(
             self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(
             repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append(
             (repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(
             self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(
             repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append(
             (repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(
             self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(
             repo, user, permission_name)
         self.user_repo_permission_ids.append(
             (repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(
             self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(
             repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append(
             (repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(
             self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(
             target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append(
             (target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(
             self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(
             target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append(
             (target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def _inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repos()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.group_name.split('/')) if first_group else 0)
             second_group_parts = (
                 len(second_group.group_name.split('/')) if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(
             self.repo_group_ids, cmp=_repo_group_compare)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_repos(self):
         sorted_repos_ids = sorted(self.repos_ids)
         for repo_id in sorted_repos_ids:
             self.fixture.destroy_repo(repo_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     VCSServer attaches this information as the attribute `_vcs_server_traceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_vcsserver_remote_traceback(report, call.excinfo.value)
 
 
 def _add_vcsserver_remote_traceback(report, exc):
     vcsserver_traceback = getattr(exc, '_vcs_server_traceback', None)
 
     if vcsserver_traceback:
         section = 'VCSServer remote traceback ' + report.when
         report.sections.append((section, vcsserver_traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 @pytest.fixture(autouse=True)
 def collect_appenlight_stats(request, testrun):
     """
     This fixture reports memory consumtion of single tests.
 
     It gathers data based on `psutil` and sends them to Appenlight. The option
     ``--ae`` has te be used to enable this fixture and the API key for your
     application has to be provided in ``--ae-key``.
     """
     try:
         # cygwin cannot have yet psutil support.
         import psutil
     except ImportError:
         return
 
     if not request.config.getoption('--appenlight'):
         return
     else:
         # Only request the pylonsapp fixture if appenlight tracking is
         # enabled. This will speed up a test run of unit tests by 2 to 3
         # seconds if appenlight is not enabled.
         pylonsapp = request.getfuncargvalue("pylonsapp")
     url = '{}/api/logs'.format(request.config.getoption('--appenlight-url'))
     client = AppenlightClient(
         url=url,
         api_key=request.config.getoption('--appenlight-api-key'),
         namespace=request.node.nodeid,
         request=str(testrun['uuid']),
         testrun=testrun)
 
     client.collect({
         'message': "Starting",
     })
 
     server_and_port = pylonsapp.config['vcs.server']
     protocol = pylonsapp.config['vcs.server.protocol']
     server = create_vcsserver_proxy(server_and_port, protocol)
     with server:
         vcs_pid = server.get_pid()
         server.run_gc()
     vcs_process = psutil.Process(vcs_pid)
     mem = vcs_process.memory_info()
     client.tag_before('vcsserver.rss', mem.rss)
     client.tag_before('vcsserver.vms', mem.vms)
 
     test_process = psutil.Process()
     mem = test_process.memory_info()
     client.tag_before('test.rss', mem.rss)
     client.tag_before('test.vms', mem.vms)
 
     client.tag_before('time', time.time())
 
     @request.addfinalizer
     def send_stats():
         client.tag_after('time', time.time())
         with server:
             gc_stats = server.run_gc()
         for tag, value in gc_stats.items():
             client.tag_after(tag, value)
         mem = vcs_process.memory_info()
         client.tag_after('vcsserver.rss', mem.rss)
         client.tag_after('vcsserver.vms', mem.vms)
 
         mem = test_process.memory_info()
         client.tag_after('test.rss', mem.rss)
         client.tag_after('test.vms', mem.vms)
 
         client.collect({
             'message': "Finished",
         })
         client.send_stats()
 
     return client
 
 
 class AppenlightClient():
 
     url_template = '{url}?protocol_version=0.5'
 
     def __init__(
             self, url, api_key, add_server=True, add_timestamp=True,
             namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault('server', self.server)
         if self.add_timestamp:
             data.setdefault('date', datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault('namespace', self.namespace)
         if self.request:
             data.setdefault('request', self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ('testrun', self.request),
             ('testrun.start', self.testrun['start']),
             ('testrun.timestamp', self.testrun['timestamp']),
             ('test', self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + '.before', value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + '.delta', delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + '.after', value))
         self.collect({
             'message': "Collected tags",
             'tags': tags,
         })
 
         response = requests.post(
             self.url,
             headers={
                 'X-appenlight-api-key': self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print response.headers
             print response.text
             raise Exception('Sending to appenlight failed')
 
 
 @pytest.fixture
 def gist_util(request, pylonsapp):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture
 def settings_util(request):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture
 def no_notifications(request):
     notification_patcher = mock.patch(
         'rhodecode.model.notification.NotificationModel.create')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture(scope='session')
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption('--repeat')
 
 
 @pytest.fixture
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     from rhodecode.lib.base import bootstrap_request
     request = bootstrap_request(scheme='https')
     return request
 
 
 @pytest.fixture
 def context_stub():
     """
     Stub context object.
     """
     context = pyramid.testing.DummyResource()
     return context
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     config = pyramid.testing.setUp(request=request_stub)
     add_test_routes(config)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 @pytest.fixture
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """ Test integration type class """
 
         key = 'test'
         display_name = 'Test integration type'
         description = 'A test integration type for testing'
         icon = 'test_icon_html_image'
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = []  # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title='test string field',
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title='some integer setting',
                 )
             return SettingsSchema()
 
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 @pytest.fixture
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
 @pytest.fixture
 def repo_integration_stub(request, repo_stub, StubIntegrationType,
         stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repo integration',
         repo=repo_stub, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_recursive_integration_stub(request, test_repo_group,
     StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test recursive repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=False)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def global_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def root_repos_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def local_dt_to_utc():
     def _factory(dt):
         return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(
             dateutil.tz.tzutc()).replace(tzinfo=None)
     return _factory
 
 
 @pytest.fixture
 def disable_anonymous_user(request, pylonsapp):
     set_anonymous_access(False)
 
     @request.addfinalizer
     def cleanup():
         set_anonymous_access(True)
+
+
[e-mail]
+def rc_fixture(request):
+    return Fixture()
+
+
[e-mail]
+def repo_groups(request):
+    fixture = Fixture()
+
+    session = Session()
+    zombie_group = fixture.create_repo_group('zombie')
+    parent_group = fixture.create_repo_group('parent')
+    child_group = fixture.create_repo_group('parent/child')
+    groups_in_db = session.query(RepoGroup).all()
+    assert len(groups_in_db) == 3
+    assert child_group.group_parent_id == parent_group.group_id
+
+    @request.addfinalizer
+    def cleanup():
+        fixture.destroy_repo_group(zombie_group)
+        fixture.destroy_repo_group(child_group)
+        fixture.destroy_repo_group(parent_group)
+
+    return zombie_group, parent_group, child_group