user-groups: rewrote the app to pyramid

- added new event data with added/removed/changed permissions
- cleanup code and spelling

rhodecode/apps/user_group/__init__.py

@@ -0,0 +1,101 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):
+    """
+    User groups /_admin prefixed routes
+    """
+
+    config.add_route(
+        name='user_group_members_data',
+        pattern='/user_groups/{user_group_id:\d+}/members',
+        user_group_route=True)
+
+    # user groups perms
+    config.add_route(
+        name='edit_user_group_perms_summary',
+        pattern='/user_groups/{user_group_id:\d+}/edit/permissions_summary',
+        user_group_route=True)
+    config.add_route(
+        name='edit_user_group_perms_summary_json',
+        pattern='/user_groups/{user_group_id:\d+}/edit/permissions_summary/json',
+        user_group_route=True)
+
+    # user groups edit
+    config.add_route(
+        name='edit_user_group',
+        pattern='/user_groups/{user_group_id:\d+}/edit',
+        user_group_route=True)
+
+    # user groups update
+    config.add_route(
+        name='user_groups_update',
+        pattern='/user_groups/{user_group_id:\d+}/update',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_global_perms',
+        pattern='/user_groups/{user_group_id:\d+}/edit/global_permissions',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_global_perms_update',
+        pattern='/user_groups/{user_group_id:\d+}/edit/global_permissions/update',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_perms',
+        pattern='/user_groups/{user_group_id:\d+}/edit/permissions',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_perms_update',
+        pattern='/user_groups/{user_group_id:\d+}/edit/permissions/update',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_advanced',
+        pattern='/user_groups/{user_group_id:\d+}/edit/advanced',
+        user_group_route=True)
+
+    config.add_route(
+        name='edit_user_group_advanced_sync',
+        pattern='/user_groups/{user_group_id:\d+}/edit/advanced/sync',
+        user_group_route=True)
+
+    # user groups delete
+    config.add_route(
+        name='user_groups_delete',
+        pattern='/user_groups/{user_group_id:\d+}/delete',
+        user_group_route=True)
+
+
+def includeme(config):
+    # main admin routes
+    config.include(admin_routes, route_prefix=ADMIN_PREFIX)
+
+    # Scan module for configuration decorators.
+    config.scan('.views', ignore='.tests')

rhodecode/apps/user_group/tests/__init__.py

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

rhodecode/apps/user_group/views/__init__.py

@@ -0,0 +1,529 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 peppercorn
+import formencode
+import formencode.htmlfill
+from pyramid.httpexceptions import HTTPFound
+from pyramid.view import view_config
+from pyramid.response import Response
+from pyramid.renderers import render
+
+from rhodecode.lib.exceptions import (
+    RepoGroupAssignmentError, UserGroupAssignedException)
+from rhodecode.model.forms import (
+    UserGroupPermsForm, UserGroupForm, UserIndividualPermissionsForm,
+    UserPermissionsForm)
+from rhodecode.model.permission import PermissionModel
+
+from rhodecode.apps._base import UserGroupAppView
+from rhodecode.lib.auth import (
+    LoginRequired, HasUserGroupPermissionAnyDecorator, CSRFRequired)
+from rhodecode.lib import helpers as h, audit_logger
+from rhodecode.lib.utils2 import str2bool
+from rhodecode.model.db import (
+    joinedload, User, UserGroupRepoToPerm, UserGroupRepoGroupToPerm)
+from rhodecode.model.meta import Session
+from rhodecode.model.user_group import UserGroupModel
+
+log = logging.getLogger(__name__)
+
+
+class UserGroupsView(UserGroupAppView):
+
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+
+        PermissionModel().set_global_permission_choices(
+            c, gettext_translator=self.request.translate)
+
+        self._register_global_c(c)
+        return c
+
+    def _get_perms_summary(self, user_group_id):
+        permissions = {
+            'repositories': {},
+            'repositories_groups': {},
+        }
+        ugroup_repo_perms = UserGroupRepoToPerm.query()\
+            .options(joinedload(UserGroupRepoToPerm.permission))\
+            .options(joinedload(UserGroupRepoToPerm.repository))\
+            .filter(UserGroupRepoToPerm.users_group_id == user_group_id)\
+            .all()
+
+        for gr in ugroup_repo_perms:
+            permissions['repositories'][gr.repository.repo_name]  \
+                = gr.permission.permission_name
+
+        ugroup_group_perms = UserGroupRepoGroupToPerm.query()\
+            .options(joinedload(UserGroupRepoGroupToPerm.permission))\
+            .options(joinedload(UserGroupRepoGroupToPerm.group))\
+            .filter(UserGroupRepoGroupToPerm.users_group_id == user_group_id)\
+            .all()
+
+        for gr in ugroup_group_perms:
+            permissions['repositories_groups'][gr.group.group_name] \
+                = gr.permission.permission_name
+        return permissions
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='user_group_members_data', request_method='GET',
+        renderer='json_ext', xhr=True)
+    def user_group_members(self):
+        """
+        Return members of given user group
+        """
+        user_group = self.db_user_group
+        group_members_obj = sorted((x.user for x in user_group.members),
+                                   key=lambda u: u.username.lower())
+
+        group_members = [
+            {
+                'id': user.user_id,
+                'first_name': user.first_name,
+                'last_name': user.last_name,
+                'username': user.username,
+                'icon_link': h.gravatar_url(user.email, 30),
+                'value_display': h.person(user.email),
+                'value': user.username,
+                'value_type': 'user',
+                'active': user.active,
+            }
+            for user in group_members_obj
+        ]
+
+        return {
+            'members': group_members
+        }
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group_perms_summary', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_perms_summary(self):
+        c = self.load_default_context()
+        c.user_group = self.db_user_group
+        c.active = 'perms_summary'
+        c.permissions = self._get_perms_summary(c.user_group.users_group_id)
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group_perms_summary_json', request_method='GET',
+        renderer='json_ext')
+    def user_group_perms_summary_json(self):
+        self.load_default_context()
+        user_group = self.db_user_group
+        return self._get_perms_summary(user_group.users_group_id)
+
+    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 = 'usergroup.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
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='user_groups_update', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_update(self):
+        _ = self.request.translate
+
+        user_group = self.db_user_group
+        user_group_id = user_group.users_group_id
+
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.group_members_obj = [x.user for x in c.user_group.members]
+        c.group_members_obj.sort(key=lambda u: u.username.lower())
+        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
+        c.active = 'settings'
+
+        users_group_form = UserGroupForm(
+            edit=True, old_data=c.user_group.get_dict(), allow_disabled=True)()
+
+        old_values = c.user_group.get_api_data()
+        user_group_name = self.request.POST.get('users_group_name')
+        try:
+            form_result = users_group_form.to_python(self.request.POST)
+            pstruct = peppercorn.parse(self.request.POST.items())
+            form_result['users_group_members'] = pstruct['user_group_members']
+
+            user_group, added_members, removed_members = \
+                UserGroupModel().update(c.user_group, form_result)
+            updated_user_group = form_result['users_group_name']
+
+            audit_logger.store_web(
+                'user_group.edit', action_data={'old_data': old_values},
+                user=self._rhodecode_user)
+
+            # TODO(marcink): use added/removed to set user_group.edit.member.add
+
+            h.flash(_('Updated user group %s') % updated_user_group,
+                    category='success')
+            Session().commit()
+        except formencode.Invalid as errors:
+            defaults = errors.value
+            e = errors.error_dict or {}
+
+            data = render(
+                'rhodecode:templates/admin/user_groups/user_group_edit.mako',
+                self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=defaults,
+                errors=e,
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+
+        except Exception:
+            log.exception("Exception during update of user group")
+            h.flash(_('Error occurred during update of user group %s')
+                    % user_group_name, category='error')
+
+        raise HTTPFound(
+            h.route_path('edit_user_group', user_group_id=user_group_id))
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='user_groups_delete', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_delete(self):
+        _ = self.request.translate
+        user_group = self.db_user_group
+
+        self.load_default_context()
+        force = str2bool(self.request.POST.get('force'))
+
+        old_values = user_group.get_api_data()
+        try:
+            UserGroupModel().delete(user_group, force=force)
+            audit_logger.store_web(
+                'user.delete', action_data={'old_data': old_values},
+                user=self._rhodecode_user)
+            Session().commit()
+            h.flash(_('Successfully deleted user group'), category='success')
+        except UserGroupAssignedException as e:
+            h.flash(str(e), category='error')
+        except Exception:
+            log.exception("Exception during deletion of user group")
+            h.flash(_('An error occurred during deletion of user group'),
+                    category='error')
+        raise HTTPFound(h.route_path('user_groups'))
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_edit(self):
+        user_group = self.db_user_group
+
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.group_members_obj = [x.user for x in c.user_group.members]
+        c.group_members_obj.sort(key=lambda u: u.username.lower())
+        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
+
+        c.active = 'settings'
+
+        defaults = user_group.get_dict()
+        # fill owner
+        if user_group.user:
+            defaults.update({'user': user_group.user.username})
+        else:
+            replacement_user = User.get_first_super_admin().username
+            defaults.update({'user': replacement_user})
+
+        data = render(
+            'rhodecode:templates/admin/user_groups/user_group_edit.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()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group_perms', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_edit_perms(self):
+        user_group = self.db_user_group
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.active = 'perms'
+
+        defaults = {}
+        # fill user group users
+        for p in c.user_group.user_user_group_to_perm:
+            defaults.update({'u_perm_%s' % p.user.user_id:
+                             p.permission.permission_name})
+
+        for p in c.user_group.user_group_user_group_to_perm:
+            defaults.update({'g_perm_%s' % p.user_group.users_group_id:
+                             p.permission.permission_name})
+
+        data = render(
+            'rhodecode:templates/admin/user_groups/user_group_edit.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()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_user_group_perms_update', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_update_perms(self):
+        """
+        grant permission for given user group
+        """
+        _ = self.request.translate
+
+        user_group = self.db_user_group
+        user_group_id = user_group.users_group_id
+        c = self.load_default_context()
+        c.user_group = user_group
+        form = UserGroupPermsForm()().to_python(self.request.POST)
+
+        if not self._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_user_group_perms',
+                                 user_group_id=user_group_id))
+
+        try:
+            changes = UserGroupModel().update_permissions(
+                user_group_id,
+                form['perm_additions'], form['perm_updates'],
+                form['perm_deletions'])
+
+        except RepoGroupAssignmentError:
+            h.flash(_('Target group cannot be the same'), category='error')
+            raise HTTPFound(
+                h.route_path('edit_user_group_perms',
+                             user_group_id=user_group_id))
+
+        action_data = {
+            'added': changes['added'],
+            'updated': changes['updated'],
+            'deleted': changes['deleted'],
+        }
+        audit_logger.store_web(
+            'user_group.edit.permissions', action_data=action_data,
+            user=self._rhodecode_user)
+
+        Session().commit()
+        h.flash(_('User Group permissions updated'), category='success')
+        raise HTTPFound(
+            h.route_path('edit_user_group_perms', user_group_id=user_group_id))
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group_global_perms', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_global_perms_edit(self):
+        user_group = self.db_user_group
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.active = 'global_perms'
+
+        c.default_user = User.get_default_user()
+        defaults = c.user_group.get_dict()
+        defaults.update(c.default_user.get_default_perms(suffix='_inherited'))
+        defaults.update(c.user_group.get_default_perms())
+
+        data = render(
+            'rhodecode:templates/admin/user_groups/user_group_edit.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()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_user_group_global_perms_update', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_global_perms_update(self):
+        _ = self.request.translate
+        user_group = self.db_user_group
+        user_group_id = self.db_user_group.users_group_id
+
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.active = 'global_perms'
+
+        try:
+            # first stage that verifies the checkbox
+            _form = UserIndividualPermissionsForm()
+            form_result = _form.to_python(dict(self.request.POST))
+            inherit_perms = form_result['inherit_default_permissions']
+            user_group.inherit_default_permissions = inherit_perms
+            Session().add(user_group)
+
+            if not inherit_perms:
+                # only update the individual ones if we un check the flag
+                _form = UserPermissionsForm(
+                    [x[0] for x in c.repo_create_choices],
+                    [x[0] for x in c.repo_create_on_write_choices],
+                    [x[0] for x in c.repo_group_create_choices],
+                    [x[0] for x in c.user_group_create_choices],
+                    [x[0] for x in c.fork_choices],
+                    [x[0] for x in c.inherit_default_permission_choices])()
+
+                form_result = _form.to_python(dict(self.request.POST))
+                form_result.update(
+                    {'perm_user_group_id': user_group.users_group_id})
+
+                PermissionModel().update_user_group_permissions(form_result)
+
+            Session().commit()
+            h.flash(_('User Group global permissions updated successfully'),
+                    category='success')
+
+        except formencode.Invalid as errors:
+            defaults = errors.value
+
+            data = render(
+                'rhodecode:templates/admin/user_groups/user_group_edit.mako',
+                self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=defaults,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+        except Exception:
+            log.exception("Exception during permissions saving")
+            h.flash(_('An error occurred during permissions saving'),
+                    category='error')
+
+        raise HTTPFound(
+            h.route_path('edit_user_group_global_perms',
+                         user_group_id=user_group_id))
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @view_config(
+        route_name='edit_user_group_advanced', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_edit_advanced(self):
+        user_group = self.db_user_group
+
+        c = self.load_default_context()
+        c.user_group = user_group
+        c.active = 'advanced'
+        c.group_members_obj = sorted(
+            (x.user for x in c.user_group.members),
+            key=lambda u: u.username.lower())
+
+        c.group_to_repos = sorted(
+            (x.repository for x in c.user_group.users_group_repo_to_perm),
+            key=lambda u: u.repo_name.lower())
+
+        c.group_to_repo_groups = sorted(
+            (x.group for x in c.user_group.users_group_repo_group_to_perm),
+            key=lambda u: u.group_name.lower())
+
+        c.group_to_review_rules = sorted(
+            (x.users_group for x in c.user_group.user_group_review_rules),
+            key=lambda u: u.users_group_name.lower())
+
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='edit_user_group_advanced_sync', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
+    def user_group_edit_advanced_set_synchronization(self):
+        _ = self.request.translate
+        user_group = self.db_user_group
+        user_group_id = user_group.users_group_id
+
+        existing = user_group.group_data.get('extern_type')
+
+        if existing:
+            new_state = user_group.group_data
+            new_state['extern_type'] = None
+        else:
+            new_state = user_group.group_data
+            new_state['extern_type'] = 'manual'
+            new_state['extern_type_set_by'] = self._rhodecode_user.username
+
+        try:
+            user_group.group_data = new_state
+            Session().add(user_group)
+            Session().commit()
+
+            h.flash(_('User Group synchronization updated successfully'),
+                    category='success')
+        except Exception:
+            log.exception("Exception during sync settings saving")
+            h.flash(_('An error occurred during synchronization update'),
+                    category='error')
+
+        raise HTTPFound(
+            h.route_path('edit_user_group_advanced',
+                         user_group_id=user_group_id))

rhodecode/apps/_base/__init__.py

@@ -29,6 +29,7 b' from rhodecode.lib.utils2 import StrictA'
 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.db import User
 from rhodecode.model.scm import ScmModel
 
@@ -259,6 +260,13 b' class RepoGroupAppView(BaseAppView):'
         self.db_repo_group_name = self.db_repo_group.group_name
 
 
+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 DataGridAppView(object):
     """
     Common class to have re-usable grid rendering components
@@ -462,6 +470,33 b' class RepoGroupRoutePredicate(object):'
         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_name_match = user_group_model.get(
+            user_group_id, cache=True)
+
+        if by_name_match:
+            # register this as request object we can re-use later
+            request.db_user_group = by_name_match
+            return True
+
+        return False
+
+
 def includeme(config):
     config.add_route_predicate(
         'repo_route', RepoRoutePredicate)
@@ -469,3 +504,5 b' def includeme(config):'
         'repo_accepted_types', RepoTypeRoutePredicate)
     config.add_route_predicate(
         'repo_group_route', RepoGroupRoutePredicate)
+    config.add_route_predicate(
+        'user_group_route', UserGroupRoutePredicate)

rhodecode/apps/admin/__init__.py

@@ -180,7 +180,7 b' def admin_routes(config):'
         name='edit_user_perms_summary_json',
         pattern='/users/{user_id:\d+}/edit/permissions_summary/json')
 
-    # user groups management
+    # user user groups management
     config.add_route(
         name='edit_user_groups_management',
         pattern='/users/{user_id:\d+}/edit/groups_management')
@@ -194,7 +194,7 b' def admin_routes(config):'
         name='edit_user_audit_logs',
         pattern='/users/{user_id:\d+}/edit/audit')
 
-    # user groups admin
+    # user-groups admin
     config.add_route(
         name='user_groups',
         pattern='/user_groups')
@@ -204,16 +204,12 b' def admin_routes(config):'
         pattern='/user_groups_data')
 
     config.add_route(
-        name='user_group_members_data',
-        pattern='/user_groups/{user_group_id:\d+}/members')
+        name='user_groups_new',
+        pattern='/user_groups/new')
 
-    # user groups perms
     config.add_route(
-        name='edit_user_group_perms_summary',
-        pattern='/user_groups/{user_group_id:\d+}/edit/permissions_summary')
-    config.add_route(
-        name='edit_user_group_perms_summary_json',
-        pattern='/user_groups/{user_group_id:\d+}/edit/permissions_summary/json')
+        name='user_groups_create',
+        pattern='/user_groups/create')
 
     # repos admin
     config.add_route(

rhodecode/apps/admin/tests/test_admin_user_groups.py

@@ -38,6 +38,9 b' def route_path(name, params=None, **kwar'
         'user_groups': ADMIN_PREFIX + '/user_groups',
         'user_groups_data': ADMIN_PREFIX + '/user_groups_data',
         'user_group_members_data': ADMIN_PREFIX + '/user_groups/{user_group_id}/members',
+        'user_groups_new': ADMIN_PREFIX + '/user_groups/new',
+        'user_groups_create': ADMIN_PREFIX + '/user_groups/create',
+        'edit_user_group': ADMIN_PREFIX + '/user_groups/{user_group_id}/edit',
     }[name].format(**kwargs)
 
     if params:
@@ -107,7 +110,61 b' class TestAdminUserGroupsView(TestContro'
         members = [u.user_id for u in User.get_all()]
         ug = user_util.create_user_group(members=members)
         response = self.app.get(
-            route_path('user_group_members_data', user_group_id=ug.users_group_id),
+            route_path('user_group_members_data',
+                       user_group_id=ug.users_group_id),
             extra_environ=xhr_header)
 
         assert len(response.json['members']) == len(members)
+
+    def test_creation_page(self):
+        self.log_user()
+        self.app.get(route_path('user_groups_new'), status=200)
+
+    def test_create(self):
+        from rhodecode.lib import helpers as h
+
+        self.log_user()
+        users_group_name = 'test_user_group'
+        response = self.app.post(route_path('user_groups_create'), {
+            'users_group_name': users_group_name,
+            'user_group_description': 'DESC',
+            'active': True,
+            'csrf_token': self.csrf_token})
+
+        user_group_id = UserGroup.get_by_group_name(
+            users_group_name).users_group_id
+
+        user_group_link = h.link_to(
+            users_group_name,
+            route_path('edit_user_group', user_group_id=user_group_id))
+
+        assert_session_flash(
+            response,
+            'Created user group %s' % user_group_link)
+
+        fixture.destroy_user_group(users_group_name)
+
+    def test_create_with_empty_name(self):
+        self.log_user()
+
+        response = self.app.post(route_path('user_groups_create'), {
+            'users_group_name': '',
+            'user_group_description': 'DESC',
+            'active': True,
+            'csrf_token': self.csrf_token}, status=200)
+
+        response.mustcontain('Please enter a value')
+
+    def test_create_duplicate(self, user_util):
+        self.log_user()
+
+        user_group = user_util.create_user_group()
+        duplicate_name = user_group.users_group_name
+        response = self.app.post(route_path('user_groups_create'), {
+            'users_group_name': duplicate_name,
+            'user_group_description': 'DESC',
+            'active': True,
+            'csrf_token': self.csrf_token}, status=200)
+
+        response.mustcontain(
+            'User group `{}` already exists'.format(user_group.users_group_name))

rhodecode/apps/admin/views/user_groups.py

@@ -20,22 +20,28 b''
 
 import logging
 
+import formencode
+import formencode.htmlfill
+
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
-
-from rhodecode.model.scm import UserGroupList
+from pyramid.response import Response
+from pyramid.renderers import render
 
 from rhodecode.apps._base import BaseAppView, DataGridAppView
 from rhodecode.lib.auth import (
-    LoginRequired, NotAnonymous,
-    HasUserGroupPermissionAnyDecorator)
-from rhodecode.lib import helpers as h
+    LoginRequired, NotAnonymous, CSRFRequired, HasPermissionAnyDecorator)
+from rhodecode.lib import helpers as h, audit_logger
 from rhodecode.lib.utils import PartialRenderer
 from rhodecode.lib.utils2 import safe_unicode
+
+from rhodecode.model.forms import UserGroupForm
+from rhodecode.model.permission import PermissionModel
+from rhodecode.model.scm import UserGroupList
 from rhodecode.model.db import (
-    joinedload, or_, count, User, UserGroup, UserGroupMember,
-    UserGroupRepoToPerm, UserGroupRepoGroupToPerm)
+    or_, count, User, UserGroup, UserGroupMember)
 from rhodecode.model.meta import Session
+from rhodecode.model.user_group import UserGroupModel
 
 log = logging.getLogger(__name__)
 
@@ -44,6 +50,10 b' class AdminUserGroupsView(BaseAppView, D'
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
+
+        PermissionModel().set_global_permission_choices(
+            c, gettext_translator=self.request.translate)
+
         self._register_global_c(c)
         return c
 
@@ -168,89 +178,70 b' class AdminUserGroupsView(BaseAppView, D'
         return data
 
     @LoginRequired()
-    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
     @view_config(
-        route_name='user_group_members_data', request_method='GET',
-        renderer='json_ext', xhr=True)
-    def user_group_members(self):
-        """
-        Return members of given user group
-        """
-        user_group_id = self.request.matchdict['user_group_id']
-        user_group = UserGroup.get_or_404(user_group_id)
-        group_members_obj = sorted((x.user for x in user_group.members),
-                                   key=lambda u: u.username.lower())
-
-        group_members = [
-            {
-                'id': user.user_id,
-                'first_name': user.first_name,
-                'last_name': user.last_name,
-                'username': user.username,
-                'icon_link': h.gravatar_url(user.email, 30),
-                'value_display': h.person(user.email),
-                'value': user.username,
-                'value_type': 'user',
-                'active': user.active,
-            }
-            for user in group_members_obj
-        ]
-
-        return {
-            'members': group_members
-        }
-
-    def _get_perms_summary(self, user_group_id):
-        permissions = {
-            'repositories': {},
-            'repositories_groups': {},
-        }
-        ugroup_repo_perms = UserGroupRepoToPerm.query()\
-            .options(joinedload(UserGroupRepoToPerm.permission))\
-            .options(joinedload(UserGroupRepoToPerm.repository))\
-            .filter(UserGroupRepoToPerm.users_group_id == user_group_id)\
-            .all()
-
-        for gr in ugroup_repo_perms:
-            permissions['repositories'][gr.repository.repo_name]  \
-                = gr.permission.permission_name
-
-        ugroup_group_perms = UserGroupRepoGroupToPerm.query()\
-            .options(joinedload(UserGroupRepoGroupToPerm.permission))\
-            .options(joinedload(UserGroupRepoGroupToPerm.group))\
-            .filter(UserGroupRepoGroupToPerm.users_group_id == user_group_id)\
-            .all()
-
-        for gr in ugroup_group_perms:
-            permissions['repositories_groups'][gr.group.group_name] \
-                = gr.permission.permission_name
-        return permissions
-
-    @LoginRequired()
-    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
-    @view_config(
-        route_name='edit_user_group_perms_summary', request_method='GET',
-        renderer='rhodecode:templates/admin/user_groups/user_group_edit.mako')
-    def user_group_perms_summary(self):
+        route_name='user_groups_new', request_method='GET',
+        renderer='rhodecode:templates/admin/user_groups/user_group_add.mako')
+    def user_groups_new(self):
         c = self.load_default_context()
-
-        user_group_id = self.request.matchdict.get('user_group_id')
-        c.user_group = UserGroup.get_or_404(user_group_id)
-
-        c.active = 'perms_summary'
-
-        c.permissions = self._get_perms_summary(c.user_group.users_group_id)
         return self._get_template_context(c)
 
     @LoginRequired()
-    @HasUserGroupPermissionAnyDecorator('usergroup.admin')
+    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
+    @CSRFRequired()
     @view_config(
-        route_name='edit_user_group_perms_summary_json', request_method='GET',
-        renderer='json_ext')
-    def user_group_perms_summary_json(self):
-        self.load_default_context()
+        route_name='user_groups_create', request_method='POST',
+        renderer='rhodecode:templates/admin/user_groups/user_group_add.mako')
+    def user_groups_create(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        users_group_form = UserGroupForm()()
+
+        user_group_name = self.request.POST.get('users_group_name')
+        try:
+            form_result = users_group_form.to_python(dict(self.request.POST))
+            user_group = UserGroupModel().create(
+                name=form_result['users_group_name'],
+                description=form_result['user_group_description'],
+                owner=self._rhodecode_user.user_id,
+                active=form_result['users_group_active'])
+            Session().flush()
+            creation_data = user_group.get_api_data()
+            user_group_name = form_result['users_group_name']
+
+            audit_logger.store_web(
+                'user_group.create', action_data={'data': creation_data},
+                user=self._rhodecode_user)
 
-        user_group_id = self.request.matchdict.get('user_group_id')
-        user_group = UserGroup.get_or_404(user_group_id)
+            user_group_link = h.link_to(
+                h.escape(user_group_name),
+                h.route_path(
+                    'edit_user_group', user_group_id=user_group.users_group_id))
+            h.flash(h.literal(_('Created user group %(user_group_link)s')
+                              % {'user_group_link': user_group_link}),
+                    category='success')
+            Session().commit()
+            user_group_id = user_group.users_group_id
+        except formencode.Invalid as errors:
 
-        return self._get_perms_summary(user_group.users_group_id)
+            data = render(
+                'rhodecode:templates/admin/user_groups/user_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 creating user group")
+            h.flash(_('Error occurred during creation of user group %s') \
+                    % user_group_name, category='error')
+            raise HTTPFound(h.route_path('user_groups_new'))
+
+        raise HTTPFound(
+            h.route_path('edit_user_group', user_group_id=user_group_id))

rhodecode/apps/user_group/tests/test_user_groups.py

@@ -21,98 +21,83 b''
 import pytest
 
 from rhodecode.tests import (
-    TestController, url, assert_session_flash, link_to, TEST_USER_ADMIN_LOGIN)
-from rhodecode.model.db import User, UserGroup
+    TestController, assert_session_flash, TEST_USER_ADMIN_LOGIN)
+from rhodecode.model.db import UserGroup
 from rhodecode.model.meta import Session
 from rhodecode.tests.fixture import Fixture
 
-TEST_USER_GROUP = 'admins_test'
-
 fixture = Fixture()
 
 
-class TestAdminUsersGroupsController(TestController):
-
-    def test_create(self):
-        self.log_user()
-        users_group_name = TEST_USER_GROUP
-        response = self.app.post(url('users_groups'), {
-            'users_group_name': users_group_name,
-            'user_group_description': 'DESC',
-            'active': True,
-            'csrf_token': self.csrf_token})
+def route_path(name, params=None, **kwargs):
+    import urllib
+    from rhodecode.apps._base import ADMIN_PREFIX
 
-        user_group_link = link_to(
-            users_group_name,
-            url('edit_users_group',
-                user_group_id=UserGroup.get_by_group_name(
-                    users_group_name).users_group_id))
-        assert_session_flash(
-            response,
-            'Created user group %s' % user_group_link)
+    base_url = {
+        'user_groups': ADMIN_PREFIX + '/user_groups',
+        'user_groups_data': ADMIN_PREFIX + '/user_groups_data',
+        'user_group_members_data': ADMIN_PREFIX + '/user_groups/{user_group_id}/members',
+        'user_groups_new': ADMIN_PREFIX + '/user_groups/new',
+        'user_groups_create': ADMIN_PREFIX + '/user_groups/create',
+        'edit_user_group': ADMIN_PREFIX + '/user_groups/{user_group_id}/edit',
+        'edit_user_group_advanced_sync': ADMIN_PREFIX + '/user_groups/{user_group_id}/edit/advanced/sync',
+        'edit_user_group_global_perms_update': ADMIN_PREFIX + '/user_groups/{user_group_id}/edit/global_permissions/update',
+        'user_groups_update': ADMIN_PREFIX + '/user_groups/{user_group_id}/update',
+        'user_groups_delete': ADMIN_PREFIX + '/user_groups/{user_group_id}/delete',
 
-    def test_set_synchronization(self):
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
+class TestUserGroupsView(TestController):
+
+    def test_set_synchronization(self, user_util):
         self.log_user()
-        users_group_name = TEST_USER_GROUP + 'sync'
-        response = self.app.post(url('users_groups'), {
-            'users_group_name': users_group_name,
-            'user_group_description': 'DESC',
-            'active': True,
-            'csrf_token': self.csrf_token})
+        user_group_name = user_util.create_user_group().users_group_name
 
         group = Session().query(UserGroup).filter(
-            UserGroup.users_group_name == users_group_name).one()
+            UserGroup.users_group_name == user_group_name).one()
 
         assert group.group_data.get('extern_type') is None
 
         # enable
         self.app.post(
-            url('edit_user_group_advanced_sync', user_group_id=group.users_group_id),
+            route_path('edit_user_group_advanced_sync',
+                       user_group_id=group.users_group_id),
             params={'csrf_token': self.csrf_token}, status=302)
 
         group = Session().query(UserGroup).filter(
-            UserGroup.users_group_name == users_group_name).one()
+            UserGroup.users_group_name == user_group_name).one()
         assert group.group_data.get('extern_type') == 'manual'
         assert group.group_data.get('extern_type_set_by') == TEST_USER_ADMIN_LOGIN
 
         # disable
         self.app.post(
-            url('edit_user_group_advanced_sync',
+            route_path('edit_user_group_advanced_sync',
                 user_group_id=group.users_group_id),
             params={'csrf_token': self.csrf_token}, status=302)
 
         group = Session().query(UserGroup).filter(
-            UserGroup.users_group_name == users_group_name).one()
+            UserGroup.users_group_name == user_group_name).one()
         assert group.group_data.get('extern_type') is None
         assert group.group_data.get('extern_type_set_by') == TEST_USER_ADMIN_LOGIN
 
-    def test_delete(self):
+    def test_delete_user_group(self, user_util):
         self.log_user()
-        users_group_name = TEST_USER_GROUP + 'another'
-        response = self.app.post(url('users_groups'), {
-            'users_group_name': users_group_name,
-            'user_group_description': 'DESC',
-            'active': True,
-            'csrf_token': self.csrf_token})
-
-        user_group_link = link_to(
-            users_group_name,
-            url('edit_users_group',
-                user_group_id=UserGroup.get_by_group_name(
-                    users_group_name).users_group_id))
-        assert_session_flash(
-            response,
-            'Created user group %s' % user_group_link)
+        user_group_id = user_util.create_user_group().users_group_id
 
         group = Session().query(UserGroup).filter(
-            UserGroup.users_group_name == users_group_name).one()
+            UserGroup.users_group_id == user_group_id).one()
 
         self.app.post(
-            url('delete_users_group', user_group_id=group.users_group_id),
-            params={'_method': 'delete', 'csrf_token': self.csrf_token})
+            route_path('user_groups_delete', user_group_id=group.users_group_id),
+            params={'csrf_token': self.csrf_token})
 
         group = Session().query(UserGroup).filter(
-            UserGroup.users_group_name == users_group_name).scalar()
+            UserGroup.users_group_id == user_group_id).scalar()
 
         assert group is None
 
@@ -122,26 +107,16 b' class TestAdminUsersGroupsController(Tes'
         ('hg.create.XXX', 'hg.create.write_on_repogroup.true', 'hg.usergroup.create.true', 'hg.repogroup.create.true', 'hg.fork.repository', 'hg.inherit_default_perms.false', False, True),
         ('', '', '', '', '', '', True, False),
     ])
-    def test_global_perms_on_group(
+    def test_global_permissions_on_user_group(
             self, repo_create, repo_create_write, user_group_create,
             repo_group_create, fork_create, expect_error, expect_form_error,
-            inherit_default_permissions):
-        self.log_user()
-        users_group_name = TEST_USER_GROUP + 'another2'
-        response = self.app.post(url('users_groups'),
-                                 {'users_group_name': users_group_name,
-                                  'user_group_description': 'DESC',
-                                  'active': True,
-                                  'csrf_token': self.csrf_token})
+            inherit_default_permissions, user_util):
 
-        ug = UserGroup.get_by_group_name(users_group_name)
-        user_group_link = link_to(
-            users_group_name,
-            url('edit_users_group', user_group_id=ug.users_group_id))
-        assert_session_flash(
-            response,
-            'Created user group %s' % user_group_link)
-        response.follow()
+        self.log_user()
+        user_group = user_util.create_user_group()
+
+        user_group_name = user_group.users_group_name
+        user_group_id = user_group.users_group_id
 
         # ENABLE REPO CREATE ON A GROUP
         perm_params = {
@@ -153,12 +128,11 b' class TestAdminUsersGroupsController(Tes'
             'default_fork_create': fork_create,
             'default_inherit_default_permissions': inherit_default_permissions,
 
-            '_method': 'put',
             'csrf_token': self.csrf_token,
         }
         response = self.app.post(
-            url('edit_user_group_global_perms',
-                user_group_id=ug.users_group_id),
+            route_path('edit_user_group_global_perms_update',
+                       user_group_id=user_group_id),
             params=perm_params)
 
         if expect_form_error:
@@ -169,21 +143,76 b' class TestAdminUsersGroupsController(Tes'
                 msg = 'An error occurred during permissions saving'
             else:
                 msg = 'User Group global permissions updated successfully'
-                ug = UserGroup.get_by_group_name(users_group_name)
-                del perm_params['_method']
+                ug = UserGroup.get_by_group_name(user_group_name)
                 del perm_params['csrf_token']
                 del perm_params['inherit_default_permissions']
                 assert perm_params == ug.get_default_perms()
             assert_session_flash(response, msg)
 
-        fixture.destroy_user_group(users_group_name)
-
-    def test_edit_autocomplete(self):
+    def test_edit_view(self, user_util):
         self.log_user()
-        ug = fixture.create_user_group(TEST_USER_GROUP, skip_if_exists=True)
-        response = self.app.get(
-            url('edit_users_group', user_group_id=ug.users_group_id))
-        fixture.destroy_user_group(TEST_USER_GROUP)
+
+        user_group = user_util.create_user_group()
+        self.app.get(
+            route_path('edit_user_group',
+                       user_group_id=user_group.users_group_id),
+            status=200)
+
+    def test_update_user_group(self, user_util):
+        user = self.log_user()
+
+        user_group = user_util.create_user_group()
+        users_group_id = user_group.users_group_id
+        new_name = user_group.users_group_name + '_CHANGE'
+
+        params = [
+            ('users_group_active', False),
+            ('user_group_description', 'DESC'),
+            ('users_group_name', new_name),
+            ('user', user['username']),
+            ('csrf_token', self.csrf_token),
+            ('__start__', 'user_group_members:sequence'),
+            ('__start__', 'member:mapping'),
+            ('member_user_id', user['user_id']),
+            ('type', 'existing'),
+            ('__end__', 'member:mapping'),
+            ('__end__', 'user_group_members:sequence'),
+        ]
+
+        self.app.post(
+            route_path('user_groups_update',
+                       user_group_id=users_group_id),
+            params=params,
+            status=302)
+
+        user_group = UserGroup.get(users_group_id)
+        assert user_group
+
+        assert user_group.users_group_name == new_name
+        assert user_group.user_group_description == 'DESC'
+        assert user_group.users_group_active == False
+
+    def test_update_user_group_name_conflicts(self, user_util):
+        self.log_user()
+        user_group_old = user_util.create_user_group()
+        new_name = user_group_old.users_group_name
+
+        user_group = user_util.create_user_group()
+
+        params = dict(
+            users_group_active=False,
+            user_group_description='DESC',
+            users_group_name=new_name,
+            csrf_token=self.csrf_token)
+
+        response = self.app.post(
+            route_path('user_groups_update',
+                       user_group_id=user_group.users_group_id),
+            params=params,
+            status=200)
+
+        response.mustcontain('User group `{}` already exists'.format(
+            new_name))
 
     def test_update_members_from_user_ids(self, user_regular):
         uid = user_regular.user_id
@@ -197,7 +226,6 b' class TestAdminUsersGroupsController(Tes'
 
         form_data = [
             ('csrf_token', self.csrf_token),
-            ('_method', 'put'),
             ('user', username),
             ('users_group_name', 'changed_name'),
             ('users_group_active', expected_active_state),
@@ -211,7 +239,8 b' class TestAdminUsersGroupsController(Tes'
             ('__end__', 'user_group_members:sequence'),
         ]
         ugid = user_group.users_group_id
-        self.app.post(url('update_users_group', user_group_id=ugid), form_data)
+        self.app.post(
+            route_path('user_groups_update', user_group_id=ugid), form_data)
 
         user_group = UserGroup.get(ugid)
         assert user_group

rhodecode/config/middleware.py

@@ -296,6 +296,7 b' def includeme(config):'
     config.include('rhodecode.apps.journal')
     config.include('rhodecode.apps.repository')
     config.include('rhodecode.apps.repo_group')
+    config.include('rhodecode.apps.user_group')
     config.include('rhodecode.apps.search')
     config.include('rhodecode.apps.user_profile')
     config.include('rhodecode.apps.my_account')

rhodecode/config/routing.py

@@ -254,44 +254,6 b' def make_map(config):'
         m.connect('edit_user_global_perms', '/users/{user_id}/edit/global_permissions',
                   action='update_global_perms', conditions={'method': ['PUT']})
 
-    # ADMIN USER GROUPS REST ROUTES
-    with rmap.submapper(path_prefix=ADMIN_PREFIX,
-                        controller='admin/user_groups') as m:
-        m.connect('users_groups', '/user_groups',
-                  action='create', conditions={'method': ['POST']})
-        m.connect('new_users_group', '/user_groups/new',
-                  action='new', conditions={'method': ['GET']})
-        m.connect('update_users_group', '/user_groups/{user_group_id}',
-                  action='update', conditions={'method': ['PUT']})
-        m.connect('delete_users_group', '/user_groups/{user_group_id}',
-                  action='delete', conditions={'method': ['DELETE']})
-        m.connect('edit_users_group', '/user_groups/{user_group_id}/edit',
-                  action='edit', conditions={'method': ['GET']},
-                  function=check_user_group)
-
-        # EXTRAS USER GROUP ROUTES
-        m.connect('edit_user_group_global_perms',
-                  '/user_groups/{user_group_id}/edit/global_permissions',
-                  action='edit_global_perms', conditions={'method': ['GET']})
-        m.connect('edit_user_group_global_perms',
-                  '/user_groups/{user_group_id}/edit/global_permissions',
-                  action='update_global_perms', conditions={'method': ['PUT']})
-
-        m.connect('edit_user_group_perms',
-                  '/user_groups/{user_group_id}/edit/permissions',
-                  action='edit_perms', conditions={'method': ['GET']})
-        m.connect('edit_user_group_perms',
-                  '/user_groups/{user_group_id}/edit/permissions',
-                  action='update_perms', conditions={'method': ['PUT']})
-
-        m.connect('edit_user_group_advanced',
-                  '/user_groups/{user_group_id}/edit/advanced',
-                  action='edit_advanced', conditions={'method': ['GET']})
-
-        m.connect('edit_user_group_advanced_sync',
-                  '/user_groups/{user_group_id}/edit/advanced/sync',
-                  action='edit_advanced_set_synchronization', conditions={'method': ['POST']})
-
     # ADMIN DEFAULTS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/defaults') as m:

rhodecode/lib/auth.py

@@ -1305,7 +1305,7 b' def get_csrf_token(session=None, force_n'
     return session.get(csrf_token_key)
 
 
-def get_request(perm_class):
+def get_request(perm_class_instance):
     from pyramid.threadlocal import get_current_request
     pyramid_request = get_current_request()
     if not pyramid_request:

rhodecode/lib/dbmigrate/schema/db_1_2_0.py

@@ -378,7 +378,6 b' class UserGroup(Base, BaseModel):'
                                           "get_user_%s" % group_name))
         return gr.scalar()
 
-
     @classmethod
     def get(cls, users_group_id, cache=False):
         users_group = cls.query()
@@ -390,13 +389,13 b' class UserGroup(Base, BaseModel):'
     @classmethod
     def create(cls, form_data):
         try:
-            new_users_group = cls()
+            new_user_group = cls()
             for k, v in form_data.items():
-                setattr(new_users_group, k, v)
+                setattr(new_user_group, k, v)
 
-            Session.add(new_users_group)
+            Session.add(new_user_group)
             Session.commit()
-            return new_users_group
+            return new_user_group
         except:
             log.error(traceback.format_exc())
             Session.rollback()

rhodecode/lib/utils.py

@@ -136,22 +136,29 b' def get_repo_group_slug(request):'
 
 
 def get_user_group_slug(request):
-    if isinstance(request, Request) and getattr(request, 'matchdict', None):
-        # pyramid
-        _group = request.matchdict.get('user_group_id')
-    else:
-        _group = request.environ['pylons.routes_dict'].get('user_group_id')
+    _user_group = ''
+    if isinstance(request, Request):
+
+        if hasattr(request, 'db_user_group'):
+            _user_group = request.db_user_group.users_group_name
+        elif getattr(request, 'matchdict', None):
+            # pyramid
+            _user_group = request.matchdict.get('user_group_id')
 
-    try:
-        _group = UserGroup.get(_group)
-        if _group:
-            _group = _group.users_group_name
-    except Exception:
-        log.exception('Failed to get user group by id')
-        # catch all failures here
-        return None
+            try:
+                _user_group = UserGroup.get(_user_group)
+                if _user_group:
+                    _user_group = _user_group.users_group_name
+            except Exception:
+                log.exception('Failed to get user group by id')
+                # catch all failures here
+                return None
 
-    return _group
+    # TODO(marcink): remove after pylons migration...
+    if not _user_group:
+        _user_group = request.environ['pylons.routes_dict'].get('user_group_id')
+
+    return _user_group
 
 
 def get_filesystem_repos(path, recursive=False, skip_removed_repos=True):

rhodecode/model/repo_permission.py

@@ -68,8 +68,8 b' class RepositoryPermissionModel(BaseMode'
                 .filter(UserGroupRepoToPerm.repository == repository) \
                 .scalar()
 
-    def update_users_group_permission(self, repository, users_group,
-                                      permission):
+    def update_user_group_permission(self, repository, users_group,
+                                     permission):
         permission = Permission.get_by_key(permission)
         current = self.get_users_group_permission(repository, users_group)
         if current:
@@ -96,7 +96,7 b' class RepositoryPermissionModel(BaseMode'
     def update_or_delete_users_group_permission(self, repository, user_group,
                                               permission):
         if permission:
-            self.update_users_group_permission(repository, user_group,
+            self.update_user_group_permission(repository, user_group,
                                                permission)
         else:
             self.delete_users_group_permission(repository, user_group)

rhodecode/model/user_group.py

@@ -18,12 +18,6 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-
-"""
-user group model for RhodeCode
-"""
-
-
 import logging
 import traceback
 
@@ -67,8 +61,10 b' class UserGroupModel(BaseModel):'
         user_group_to_perm.user_id = def_user.user_id
         return user_group_to_perm
 
-    def update_permissions(self, user_group, perm_additions=None, perm_updates=None,
-                           perm_deletions=None, check_perms=True, cur_user=None):
+    def update_permissions(
+            self, user_group, perm_additions=None, perm_updates=None,
+            perm_deletions=None, check_perms=True, cur_user=None):
+
         from rhodecode.lib.auth import HasUserGroupPermissionAny
         if not perm_additions:
             perm_additions = []
@@ -79,10 +75,16 b' class UserGroupModel(BaseModel):'
 
         req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')
 
+        changes = {
+            'added': [],
+            'updated': [],
+            'deleted': []
+        }
         # 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 existing one
                 self.grant_user_permission(
                     user_group=user_group, user=member_id, perm=perm
@@ -90,38 +92,49 b' class UserGroupModel(BaseModel):'
             else:
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
-                if not check_perms or HasUserGroupPermissionAny(*req_perms)(member_name, user=cur_user):
+                if not check_perms or HasUserGroupPermissionAny(
+                        *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
-                        target_user_group=user_group, user_group=member_id, perm=perm
-                    )
+                        target_user_group=user_group, user_group=member_id, perm=perm)
+
+            changes['updated'].append({'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
                 self.grant_user_permission(
-                    user_group=user_group, user=member_id, perm=perm
-                )
+                    user_group=user_group, user=member_id, perm=perm)
             else:
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
-                if not check_perms or HasUserGroupPermissionAny(*req_perms)(member_name, user=cur_user):
+                if not check_perms or HasUserGroupPermissionAny(
+                        *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
-                        target_user_group=user_group, user_group=member_id, perm=perm
-                    )
+                        target_user_group=user_group, user_group=member_id, perm=perm)
+
+            changes['added'].append({'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
                 self.revoke_user_permission(user_group=user_group, user=member_id)
             else:
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
-                if not check_perms or HasUserGroupPermissionAny(*req_perms)(member_name, user=cur_user):
+                if not check_perms or HasUserGroupPermissionAny(
+                        *req_perms)(member_name, user=cur_user):
                     self.revoke_user_group_permission(
-                        target_user_group=user_group, user_group=member_id
-                    )
+                        target_user_group=user_group, user_group=member_id)
+
+            changes['deleted'].append({'type': member_type, 'id': member_id,
+                                       'name': member_name, 'new_perm': perm})
+        return changes
 
     def get(self, user_group_id, cache=False):
         return UserGroup.get(user_group_id)
@@ -247,6 +260,9 b' class UserGroupModel(BaseModel):'
         :param force:
         """
         user_group = self._get_user_group(user_group)
+        if not user_group:
+            return
+
         try:
             # check if this group is not assigned to repo
             assigned_to_repo = [x.repository for x in UserGroupRepoToPerm.query()\
@@ -527,7 +543,6 b' class UserGroupModel(BaseModel):'
         This method changes user group assignment
         :param user:  User
         :param groups: array of UserGroupModel
-        :return:
         """
         user = self._get_user(user)
         log.debug('Changing user(%s) assignment to groups(%s)', user, groups)
@@ -542,11 +557,14 b' class UserGroupModel(BaseModel):'
         groups_to_add = groups - current_groups
 
         for gr in groups_to_remove:
-            log.debug('Removing user %s from user group %s', user.username, gr.users_group_name)
+            log.debug('Removing user %s from user group %s',
+                      user.username, gr.users_group_name)
             self.remove_user_from_group(gr.users_group_name, user.username)
         for gr in groups_to_add:
-            log.debug('Adding user %s to user group %s', user.username, gr.users_group_name)
-            UserGroupModel().add_user_to_group(gr.users_group_name, user.username)
+            log.debug('Adding user %s to user group %s',
+                      user.username, gr.users_group_name)
+            UserGroupModel().add_user_to_group(
+                gr.users_group_name, user.username)
 
     def _serialize_user_group(self, user_group):
         import rhodecode.lib.helpers as h
@@ -617,7 +635,3 b' class UserGroupModel(BaseModel):'
                 'owner_icon': h.gravatar_url(user_group.user.email, 30)}
             }
         return data
-
-
-
-

rhodecode/model/validators.py

@@ -221,7 +221,7 b' def ValidUserGroup(edit=False, old_data='
     class _validator(formencode.validators.FancyValidator):
         messages = {
             'invalid_group': _(u'Invalid user group name'),
-            'group_exist': _(u'User group "%(usergroup)s" already exists'),
+            'group_exist': _(u'User group `%(usergroup)s` already exists'),
             'invalid_usergroup_name':
                 _(u'user group name may only contain alphanumeric '
                   u'characters underscores, periods or dashes and must begin '

rhodecode/public/js/rhodecode/routes.js

@@ -81,9 +81,8 b' function registerRCRoutes() {'
     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_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('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', []);
@@ -210,6 +209,18 b' function registerRCRoutes() {'
     pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_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']);

rhodecode/templates/admin/repo_groups/repo_group_edit_perms.mako

@@ -96,7 +96,7 b''
                     <td class="td-componentname">
                         <i class="icon-group" ></i>
                         %if h.HasPermissionAny('hg.admin')():
-                         <a href="${h.url('edit_users_group',user_group_id=_user_group.users_group_id)}">
+                         <a href="${h.route_path('edit_user_group',user_group_id=_user_group.users_group_id)}">
                              ${_user_group.users_group_name}
                          </a>
                         %else:

rhodecode/templates/admin/repos/repo_edit_permissions.mako

@@ -85,7 +85,7 b''
                     <td class="td-componentname">
                         <i class="icon-group" ></i>
                         %if h.HasPermissionAny('hg.admin')():
-                         <a href="${h.url('edit_users_group',user_group_id=_user_group.users_group_id)}">
+                         <a href="${h.route_path('edit_user_group',user_group_id=_user_group.users_group_id)}">
                              ${_user_group.users_group_name}
                          </a>
                         %else:

rhodecode/templates/admin/user_groups/user_group_add.mako

@@ -10,7 +10,7 b''
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('User groups'),h.url('users_groups'))}
+    ${h.link_to(_('User groups'),h.route_path('user_groups'))}
     &raquo;
     ${_('Add User Group')}
 </%def>
@@ -26,7 +26,7 b''
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
-    ${h.secure_form(h.url('users_groups'))}
+    ${h.secure_form(h.route_path('user_groups_create'), method='POST', request=request)}
     <div class="form">
         <!-- fields -->
         <div class="fields">

rhodecode/templates/admin/user_groups/user_group_edit.mako

@@ -11,7 +11,7 b''
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
-    ${h.link_to(_('User Groups'),h.url('users_groups'))}
+    ${h.link_to(_('User Groups'),h.route_path('user_groups'))}
     &raquo;
     ${c.user_group.users_group_name}
 </%def>
@@ -30,10 +30,10 b''
   <div class="sidebar-col-wrapper">
     <div class="sidebar">
         <ul class="nav nav-pills nav-stacked">
-          <li class="${'active' if c.active=='settings' else ''}"><a href="${h.url('edit_users_group', user_group_id=c.user_group.users_group_id)}">${_('Settings')}</a></li>
-          <li class="${'active' if c.active=='perms' else ''}"><a href="${h.url('edit_user_group_perms', user_group_id=c.user_group.users_group_id)}">${_('Permissions')}</a></li>
-          <li class="${'active' if c.active=='advanced' else ''}"><a href="${h.url('edit_user_group_advanced', user_group_id=c.user_group.users_group_id)}">${_('Advanced')}</a></li>
-          <li class="${'active' if c.active=='global_perms' else ''}"><a href="${h.url('edit_user_group_global_perms', user_group_id=c.user_group.users_group_id)}">${_('Global permissions')}</a></li>
+          <li class="${'active' if c.active=='settings' else ''}"><a href="${h.route_path('edit_user_group', user_group_id=c.user_group.users_group_id)}">${_('Settings')}</a></li>
+          <li class="${'active' if c.active=='perms' else ''}"><a href="${h.route_path('edit_user_group_perms', user_group_id=c.user_group.users_group_id)}">${_('Permissions')}</a></li>
+          <li class="${'active' if c.active=='advanced' else ''}"><a href="${h.route_path('edit_user_group_advanced', user_group_id=c.user_group.users_group_id)}">${_('Advanced')}</a></li>
+          <li class="${'active' if c.active=='global_perms' else ''}"><a href="${h.route_path('edit_user_group_global_perms', user_group_id=c.user_group.users_group_id)}">${_('Global permissions')}</a></li>
           <li class="${'active' if c.active=='perms_summary' else ''}"><a href="${h.route_path('edit_user_group_perms_summary', user_group_id=c.user_group.users_group_id)}">${_('Permissions summary')}</a></li>
         </ul>
     </div>

rhodecode/templates/admin/user_groups/user_group_edit_advanced.mako

@@ -44,7 +44,7 b''
         % endif
 
         <div>
-        ${h.secure_form(h.url('edit_user_group_advanced_sync', user_group_id=c.user_group.users_group_id), method='post')}
+        ${h.secure_form(h.route_path('edit_user_group_advanced_sync', user_group_id=c.user_group.users_group_id), method='POST', request=request)}
             <div class="field">
                 <button class="btn btn-default" type="submit">
                     %if sync_type:
@@ -72,7 +72,7 b''
         <h3 class="panel-title">${_('Delete User Group')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('delete_users_group', user_group_id=c.user_group.users_group_id),method='delete')}
+        ${h.secure_form(h.route_path('user_groups_delete', user_group_id=c.user_group.users_group_id), method='POST', request=request)}
             ${h.hidden('force', 1)}
             <button class="btn btn-small btn-danger" type="submit"
                     onclick="return confirm('${_('Confirm to delete user group `%(ugroup)s` with all permission assignments') % {'ugroup': c.user_group.users_group_name}}');">

rhodecode/templates/admin/user_groups/user_group_edit_global_perms.mako

@@ -1,3 +1,3 b''
 <%namespace name="dpb" file="/base/default_perms_box.mako"/>
-${dpb.default_perms_box(h.url('edit_user_group_global_perms', user_group_id=c.user_group.users_group_id))}
+${dpb.default_perms_box(form_url=h.route_path('edit_user_group_global_perms_update', user_group_id=c.user_group.users_group_id))}
 

rhodecode/templates/admin/user_groups/user_group_edit_perms.mako

@@ -5,7 +5,7 b''
         <h3 class="panel-title">${_('User Group Permissions')}</h3>
     </div>
     <div class="panel-body">
-        ${h.secure_form(h.url('edit_user_group_perms', user_group_id=c.user_group.users_group_id),method='put')}
+        ${h.secure_form(h.route_path('edit_user_group_perms_update', user_group_id=c.user_group.users_group_id), method='POST', request=request)}
         <table id="permissions_manage" class="rctable permissions">
             <tr>
                 <th class="td-radio">${_('None')}</th>
@@ -96,7 +96,7 b''
                     <td class="td-user">
                         <i class="icon-group" ></i>
                         %if h.HasPermissionAny('hg.admin')():
-                         <a href="${h.url('edit_users_group',user_group_id=_user_group.users_group_id)}">
+                         <a href="${h.route_path('edit_user_group',user_group_id=_user_group.users_group_id)}">
                              ${_user_group.users_group_name}
                          </a>
                         %else:

rhodecode/templates/admin/user_groups/user_group_edit_settings.mako

@@ -6,7 +6,7 b''
         <h3 class="panel-title">${_('User Group: %s') % c.user_group.users_group_name}</h3>
     </div>
     <div class="panel-body">
-    ${h.secure_form(h.url('update_users_group', user_group_id=c.user_group.users_group_id),method='put', id='edit_users_group')}
+    ${h.secure_form(h.route_path('user_groups_update', user_group_id=c.user_group.users_group_id), id='edit_user_group', method='POST', request=request)}
         <div class="form">
             <!-- fields -->
                 <div class="fields">

rhodecode/templates/admin/user_groups/user_groups.mako

@@ -25,7 +25,7 b''
         <ul class="links">
         %if h.HasPermissionAny('hg.admin', 'hg.usergroup.create.true')():
           <li>
-            <a href="${h.url('new_users_group')}" class="btn btn-small btn-success">${_(u'Add User Group')}</a>
+            <a href="${h.route_path('user_groups_new')}" class="btn btn-small btn-success">${_(u'Add User Group')}</a>
           </li>
         %endif
         </ul>

rhodecode/templates/base/base.mako

@@ -76,7 +76,7 b''
       <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('users')}">${_('Users')}</a></li>
-      <li><a href="${h.url('users_groups')}">${_('User groups')}</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>
@@ -151,7 +151,7 b''
       <li class="local-admin-repo-groups"><a href="${h.url('repo_groups')}">${_('Repository groups')}</a></li>
    %endif
    %if user_groups:
-      <li class="local-admin-user-groups"><a href="${h.url('users_groups')}">${_('User groups')}</a></li>
+      <li class="local-admin-user-groups"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
    %endif
   </ul>
 </%def>

rhodecode/templates/base/default_perms_box.mako

@@ -94,7 +94,7 b''
 </%def>
 
 <%def name="default_perms_box(form_url)">
-  ${h.secure_form(form_url, method='put')}
+  ${h.secure_form(form_url, method='POST', request=request)}
     <div class="form">
       <div class="fields">
         <div class="field panel panel-default panel-body">

rhodecode/templates/base/perms_summary.mako

@@ -175,7 +175,7 b''
                         %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.url('edit_users_group',user_group_id=k)}">${k}</a>
+                            ##<a href="${h.route_path('edit_user_group',user_group_id=k)}">${k}</a>
                             ${k}
                         %endif
                     </td>
@@ -211,7 +211,7 b''
                         %elif section == 'repositories_groups':
                             <a href="${h.url('edit_repo_group_perms',group_name=k,anchor='permissions_manage')}">${_('edit')}</a>
                         %elif section == 'user_groups':
-                            ##<a href="${h.url('edit_users_group',user_group_id=k)}">${_('edit')}</a>
+                            ##<a href="${h.route_path('edit_user_group',user_group_id=k)}">${_('edit')}</a>
                         %endif
                     </td>
                     %endif

rhodecode/templates/data_table/_dt_elements.mako

@@ -200,10 +200,10 b''
 
 <%def name="user_group_actions(user_group_id, user_group_name)">
  <div class="grid_edit">
-    <a href="${h.url('edit_users_group', user_group_id=user_group_id)}" title="${_('Edit')}">Edit</a>
+    <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.url('delete_users_group', user_group_id=user_group_id),method='delete')}
+    ${h.secure_form(h.route_path('user_groups_delete', user_group_id=user_group_id), method='POST', 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()}
@@ -221,7 +221,7 b''
 
 <%def name="user_group_name(user_group_id, user_group_name)">
   <div>
-  <a href="${h.url('edit_users_group', user_group_id=user_group_id)}">
+  <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>

rhodecode/templates/debug_style/forms.html

@@ -260,12 +260,6 b''
                   </div>
               </fieldset>
   
-            <script>
-                $(document).ready(function(){
-                    MultiSelectWidget('users_group_members2','available_members', 'edit_users_group');
-                })
-            </script>
-
           <div class="buttons">
             <input type="submit" value="Save" id="example_save" class="btn">
             <input type="reset" value="Reset" id="example_reset" class="btn">