further cleanup of UsersGroup

Renaming some names ... but trying not to change API or database scheme.

rhodecode/controllers/admin/users_groups.py

@@ -33,16 +33,16 b' from pylons.controllers.util import abor'
 from pylons.i18n.translation import _
 
 from rhodecode.lib import helpers as h
-from rhodecode.lib.exceptions import UsersGroupsAssignedException
+from rhodecode.lib.exceptions import UserGroupsAssignedException
 from rhodecode.lib.utils2 import safe_unicode, str2bool
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.base import BaseController, render
 
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 
-from rhodecode.model.db import User, UsersGroup, UsersGroupToPerm,\
-    UsersGroupRepoToPerm, UsersGroupRepoGroupToPerm
-from rhodecode.model.forms import UsersGroupForm
+from rhodecode.model.db import User, UserGroup, UserGroupToPerm,\
+    UserGroupRepoToPerm, UserGroupRepoGroupToPerm
+from rhodecode.model.forms import UserGroupForm
 from rhodecode.model.meta import Session
 from rhodecode.lib.utils import action_logger
 from sqlalchemy.orm import joinedload
@@ -67,17 +67,17 b' class UsersGroupsController(BaseControll'
     def index(self, format='html'):
         """GET /users_groups: All items in the collection"""
         # url('users_groups')
-        c.users_groups_list = UsersGroup().query().all()
+        c.users_groups_list = UserGroup().query().all()
         return render('admin/users_groups/users_groups.html')
 
     def create(self):
         """POST /users_groups: Create a new item"""
         # url('users_groups')
 
-        users_group_form = UsersGroupForm()()
+        users_group_form = UserGroupForm()()
         try:
             form_result = users_group_form.to_python(dict(request.POST))
-            UsersGroupModel().create(name=form_result['users_group_name'],
+            UserGroupModel().create(name=form_result['users_group_name'],
                                      active=form_result['users_group_active'])
             gr = form_result['users_group_name']
             action_logger(self.rhodecode_user,
@@ -110,20 +110,20 b' class UsersGroupsController(BaseControll'
             'repositories_groups': {}
         }
 
-        ugroup_repo_perms = UsersGroupRepoToPerm.query()\
-            .options(joinedload(UsersGroupRepoToPerm.permission))\
-            .options(joinedload(UsersGroupRepoToPerm.repository))\
-            .filter(UsersGroupRepoToPerm.users_group_id == id)\
+        ugroup_repo_perms = UserGroupRepoToPerm.query()\
+            .options(joinedload(UserGroupRepoToPerm.permission))\
+            .options(joinedload(UserGroupRepoToPerm.repository))\
+            .filter(UserGroupRepoToPerm.users_group_id == id)\
             .all()
 
         for gr in ugroup_repo_perms:
             c.users_group.permissions['repositories'][gr.repository.repo_name]  \
                 = gr.permission.permission_name
 
-        ugroup_group_perms = UsersGroupRepoGroupToPerm.query()\
-            .options(joinedload(UsersGroupRepoGroupToPerm.permission))\
-            .options(joinedload(UsersGroupRepoGroupToPerm.group))\
-            .filter(UsersGroupRepoGroupToPerm.users_group_id == id)\
+        ugroup_group_perms = UserGroupRepoGroupToPerm.query()\
+            .options(joinedload(UserGroupRepoGroupToPerm.permission))\
+            .options(joinedload(UserGroupRepoGroupToPerm.group))\
+            .filter(UserGroupRepoGroupToPerm.users_group_id == id)\
             .all()
 
         for gr in ugroup_group_perms:
@@ -145,18 +145,18 b' class UsersGroupsController(BaseControll'
         #           method='put')
         # url('users_group', id=ID)
 
-        c.users_group = UsersGroup.get_or_404(id)
+        c.users_group = UserGroup.get_or_404(id)
         self._load_data(id)
 
         available_members = [safe_unicode(x[0]) for x in c.available_members]
 
-        users_group_form = UsersGroupForm(edit=True,
+        users_group_form = UserGroupForm(edit=True,
                                           old_data=c.users_group.get_dict(),
                                           available_members=available_members)()
 
         try:
             form_result = users_group_form.to_python(request.POST)
-            UsersGroupModel().update(c.users_group, form_result)
+            UserGroupModel().update(c.users_group, form_result)
             gr = form_result['users_group_name']
             action_logger(self.rhodecode_user,
                           'admin_updated_users_group:%s' % gr,
@@ -164,7 +164,7 b' class UsersGroupsController(BaseControll'
             h.flash(_('updated user group %s') % gr, category='success')
             Session().commit()
         except formencode.Invalid, errors:
-            ug_model = UsersGroupModel()
+            ug_model = UserGroupModel()
             defaults = errors.value
             e = errors.error_dict or {}
             defaults.update({
@@ -196,12 +196,12 b' class UsersGroupsController(BaseControll'
         #    h.form(url('users_group', id=ID),
         #           method='delete')
         # url('users_group', id=ID)
-        usr_gr = UsersGroup.get_or_404(id)
+        usr_gr = UserGroup.get_or_404(id)
         try:
-            UsersGroupModel().delete(usr_gr)
+            UserGroupModel().delete(usr_gr)
             Session().commit()
             h.flash(_('successfully deleted user group'), category='success')
-        except UsersGroupsAssignedException, e:
+        except UserGroupsAssignedException, e:
             h.flash(e, category='error')
         except Exception:
             log.error(traceback.format_exc())
@@ -217,10 +217,10 b' class UsersGroupsController(BaseControll'
         """GET /users_groups/id/edit: Form to edit an existing item"""
         # url('edit_users_group', id=ID)
 
-        c.users_group = UsersGroup.get_or_404(id)
+        c.users_group = UserGroup.get_or_404(id)
         self._load_data(id)
 
-        ug_model = UsersGroupModel()
+        ug_model = UserGroupModel()
         defaults = c.users_group.get_dict()
         defaults.update({
             'create_repo_perm': ug_model.has_perm(c.users_group,
@@ -240,36 +240,36 b' class UsersGroupsController(BaseControll'
         """PUT /users_perm/id: Update an existing item"""
         # url('users_group_perm', id=ID, method='put')
 
-        users_group = UsersGroup.get_or_404(id)
+        users_group = UserGroup.get_or_404(id)
         grant_create_perm = str2bool(request.POST.get('create_repo_perm'))
         grant_fork_perm = str2bool(request.POST.get('fork_repo_perm'))
         inherit_perms = str2bool(request.POST.get('inherit_default_permissions'))
 
-        usersgroup_model = UsersGroupModel()
+        usergroup_model = UserGroupModel()
 
         try:
             users_group.inherit_default_permissions = inherit_perms
             Session().add(users_group)
 
             if grant_create_perm:
-                usersgroup_model.revoke_perm(id, 'hg.create.none')
-                usersgroup_model.grant_perm(id, 'hg.create.repository')
+                usergroup_model.revoke_perm(id, 'hg.create.none')
+                usergroup_model.grant_perm(id, 'hg.create.repository')
                 h.flash(_("Granted 'repository create' permission to user group"),
                         category='success')
             else:
-                usersgroup_model.revoke_perm(id, 'hg.create.repository')
-                usersgroup_model.grant_perm(id, 'hg.create.none')
+                usergroup_model.revoke_perm(id, 'hg.create.repository')
+                usergroup_model.grant_perm(id, 'hg.create.none')
                 h.flash(_("Revoked 'repository create' permission to user group"),
                         category='success')
 
             if grant_fork_perm:
-                usersgroup_model.revoke_perm(id, 'hg.fork.none')
-                usersgroup_model.grant_perm(id, 'hg.fork.repository')
+                usergroup_model.revoke_perm(id, 'hg.fork.none')
+                usergroup_model.grant_perm(id, 'hg.fork.repository')
                 h.flash(_("Granted 'repository fork' permission to user group"),
                         category='success')
             else:
-                usersgroup_model.revoke_perm(id, 'hg.fork.repository')
-                usersgroup_model.grant_perm(id, 'hg.fork.none')
+                usergroup_model.revoke_perm(id, 'hg.fork.repository')
+                usergroup_model.grant_perm(id, 'hg.fork.none')
                 h.flash(_("Revoked 'repository fork' permission to user group"),
                         category='success')
 

rhodecode/controllers/api/api.py

@@ -38,7 +38,7 b' from rhodecode.model.meta import Session'
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.db import Repository, RhodeCodeSetting, UserIpMap
 
@@ -125,7 +125,7 b' def get_users_group_or_error(usersgroupi'
 
     :param userid:
     """
-    users_group = UsersGroupModel().get_group(usersgroupid)
+    users_group = UserGroupModel().get_group(usersgroupid)
     if users_group is None:
         raise JSONRPCError('user group `%s` does not exist' % usersgroupid)
     return users_group
@@ -474,7 +474,7 b' class ApiController(JSONRPCController):'
         """
 
         result = []
-        for users_group in UsersGroupModel().get_all():
+        for users_group in UserGroupModel().get_all():
             result.append(users_group.get_api_data())
         return result
 
@@ -488,12 +488,12 b' class ApiController(JSONRPCController):'
         :param active:
         """
 
-        if UsersGroupModel().get_by_name(group_name):
+        if UserGroupModel().get_by_name(group_name):
             raise JSONRPCError("user group `%s` already exist" % group_name)
 
         try:
             active = Optional.extract(active)
-            ug = UsersGroupModel().create(name=group_name, active=active)
+            ug = UserGroupModel().create(name=group_name, active=active)
             Session().commit()
             return dict(
                 msg='created new user group `%s`' % group_name,
@@ -516,7 +516,7 b' class ApiController(JSONRPCController):'
         users_group = get_users_group_or_error(usersgroupid)
 
         try:
-            ugm = UsersGroupModel().add_user_to_group(users_group, user)
+            ugm = UserGroupModel().add_user_to_group(users_group, user)
             success = True if ugm != True else False
             msg = 'added member `%s` to user group `%s`' % (
                         user.username, users_group.users_group_name
@@ -549,7 +549,7 b' class ApiController(JSONRPCController):'
         users_group = get_users_group_or_error(usersgroupid)
 
         try:
-            success = UsersGroupModel().remove_user_from_group(users_group,
+            success = UserGroupModel().remove_user_from_group(users_group,
                                                                user)
             msg = 'removed member `%s` from user group `%s`' % (
                         user.username, users_group.users_group_name

rhodecode/lib/dbmigrate/schema/db_1_2_0.py

@@ -41,7 +41,7 b' from rhodecode.lib.vcs.utils.lazy import'
 
 from rhodecode.lib.utils2 import str2bool, safe_str, get_changeset_safe, \
     generate_api_key, safe_unicode
-from rhodecode.lib.exceptions import UsersGroupsAssignedException
+from rhodecode.lib.exceptions import UserGroupsAssignedException
 from rhodecode.lib.compat import json
 
 from rhodecode.model.meta import Base, Session
@@ -282,7 +282,7 b' class User(Base, BaseModel):'
     user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     @property
     def full_contact(self):
@@ -361,7 +361,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = {'extend_existing':True}
 
@@ -369,7 +369,7 b' class UsersGroup(Base, BaseModel):'
     users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
 
     def __repr__(self):
         return '<userGroup(%s)>' % (self.users_group_name)
@@ -425,7 +425,7 b' class UsersGroup(Base, BaseModel):'
                     if v:
                         v = [v] if isinstance(v, basestring) else v
                         for u_id in set(v):
-                            member = UsersGroupMember(users_group_id, u_id)
+                            member = UserGroupMember(users_group_id, u_id)
                             members_list.append(member)
                     setattr(users_group, 'members', members_list)
                 setattr(users_group, k, v)
@@ -442,12 +442,12 b' class UsersGroup(Base, BaseModel):'
         try:
 
             # check if this group is not assigned to repo
-            assigned_groups = UsersGroupRepoToPerm.query()\
-                .filter(UsersGroupRepoToPerm.users_group_id ==
+            assigned_groups = UserGroupRepoToPerm.query()\
+                .filter(UserGroupRepoToPerm.users_group_id ==
                         users_group_id).all()
 
             if assigned_groups:
-                raise UsersGroupsAssignedException('RepoGroup assigned to %s' %
+                raise UserGroupsAssignedException('RepoGroup assigned to %s' %
                                                    assigned_groups)
 
             users_group = cls.get(users_group_id, cache=False)
@@ -458,7 +458,7 b' class UsersGroup(Base, BaseModel):'
             Session.rollback()
             raise
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = {'extend_existing':True}
 
@@ -467,7 +467,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -475,7 +475,7 b' class UsersGroupMember(Base, BaseModel):'
 
     @staticmethod
     def add_user_to_group(group, user):
-        ugm = UsersGroupMember()
+        ugm = UserGroupMember()
         ugm.users_group = group
         ugm.user = user
         Session.add(ugm)
@@ -505,7 +505,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')
@@ -909,7 +909,7 b' class UserToPerm(Base, BaseModel):'
         except:
             Session.rollback()
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True})
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
@@ -917,21 +917,21 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
     def __repr__(self):
         return '<userGroup:%s => %s >' % (self.users_group, self.repository)
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = {'extend_existing':True}
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 

rhodecode/lib/dbmigrate/schema/db_1_3_0.py

@@ -305,7 +305,7 b' class User(Base, BaseModel):'
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
@@ -423,7 +423,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository', cascade='')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine':'InnoDB',
@@ -434,9 +434,9 b' class UsersGroup(Base, BaseModel):'
     users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
-    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')
-    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
 
     def __unicode__(self):
         return u'<userGroup(%s)>' % (self.users_group_name)
@@ -465,7 +465,7 b' class UsersGroup(Base, BaseModel):'
         return users_group.get(users_group_id)
 
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine':'InnoDB',
@@ -477,7 +477,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -510,7 +510,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')
@@ -749,7 +749,7 b' class RepoGroup(Base, BaseModel):'
     group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
 
     parent_group = relationship('RepoGroup', remote_side=group_id)
 
@@ -946,7 +946,7 b' class UserToPerm(Base, BaseModel):'
     permission = relationship('Permission', lazy='joined')
 
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
@@ -958,7 +958,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
@@ -975,7 +975,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
         return u'<userGroup:%s => %s >' % (self.users_group, self.repository)
 
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
@@ -986,7 +986,7 b' class UsersGroupToPerm(Base, BaseModel):'
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
@@ -1008,7 +1008,7 b' class UserRepoGroupToPerm(Base, BaseMode'
     permission = relationship('Permission')
 
 
-class UsersGroupRepoGroupToPerm(Base, BaseModel):
+class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
@@ -1021,7 +1021,7 b' class UsersGroupRepoGroupToPerm(Base, Ba'
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 

rhodecode/lib/dbmigrate/schema/db_1_4_0.py

@@ -322,7 +322,7 b' class User(Base, BaseModel):'
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
@@ -521,7 +521,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository', cascade='')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -533,9 +533,9 b' class UsersGroup(Base, BaseModel):'
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
-    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')
-    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
 
     def __unicode__(self):
         return u'<userGroup(%s)>' % (self.users_group_name)
@@ -575,7 +575,7 b' class UsersGroup(Base, BaseModel):'
         return data
 
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -587,7 +587,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -625,7 +625,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing',
@@ -1013,7 +1013,7 b' class RepoGroup(Base, BaseModel):'
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
 
     parent_group = relationship('RepoGroup', remote_side=group_id)
 
@@ -1277,7 +1277,7 b' class UserToPerm(Base, BaseModel):'
     permission = relationship('Permission', lazy='joined')
 
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
@@ -1289,7 +1289,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
@@ -1306,7 +1306,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
         return u'<userGroup:%s => %s >' % (self.users_group, self.repository)
 
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
@@ -1317,7 +1317,7 b' class UsersGroupToPerm(Base, BaseModel):'
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
@@ -1339,7 +1339,7 b' class UserRepoGroupToPerm(Base, BaseMode'
     permission = relationship('Permission')
 
 
-class UsersGroupRepoGroupToPerm(Base, BaseModel):
+class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
@@ -1352,7 +1352,7 b' class UsersGroupRepoGroupToPerm(Base, Ba'
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 

rhodecode/lib/dbmigrate/schema/db_1_5_0.py

@@ -341,7 +341,7 b' class User(Base, BaseModel):'
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
@@ -541,7 +541,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository', cascade='')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -553,9 +553,9 b' class UsersGroup(Base, BaseModel):'
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
-    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')
-    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
 
     def __unicode__(self):
         return u'<userGroup(%s)>' % (self.users_group_name)
@@ -595,7 +595,7 b' class UsersGroup(Base, BaseModel):'
         return data
 
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -607,7 +607,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -645,7 +645,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing',
@@ -1033,7 +1033,7 b' class RepoGroup(Base, BaseModel):'
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
 
     parent_group = relationship('RepoGroup', remote_side=group_id)
 
@@ -1297,7 +1297,7 b' class UserToPerm(Base, BaseModel):'
     permission = relationship('Permission', lazy='joined')
 
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
@@ -1309,7 +1309,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
@@ -1326,7 +1326,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
         return u'<userGroup:%s => %s >' % (self.users_group, self.repository)
 
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
@@ -1337,7 +1337,7 b' class UsersGroupToPerm(Base, BaseModel):'
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
@@ -1359,7 +1359,7 b' class UserRepoGroupToPerm(Base, BaseMode'
     permission = relationship('Permission')
 
 
-class UsersGroupRepoGroupToPerm(Base, BaseModel):
+class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
@@ -1372,7 +1372,7 b' class UsersGroupRepoGroupToPerm(Base, Ba'
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 

rhodecode/lib/dbmigrate/schema/db_1_5_2.py

@@ -341,7 +341,7 b' class User(Base, BaseModel):'
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
@@ -575,7 +575,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository', cascade='')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -587,9 +587,9 b' class UsersGroup(Base, BaseModel):'
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
-    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')
-    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
 
     def __unicode__(self):
         return u'<userGroup(%s)>' % (self.users_group_name)
@@ -629,7 +629,7 b' class UsersGroup(Base, BaseModel):'
         return data
 
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -641,7 +641,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -680,7 +680,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing',
@@ -1139,7 +1139,7 b' class RepoGroup(Base, BaseModel):'
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
 
     parent_group = relationship('RepoGroup', remote_side=group_id)
 
@@ -1403,7 +1403,7 b' class UserToPerm(Base, BaseModel):'
     permission = relationship('Permission', lazy='joined')
 
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
@@ -1415,7 +1415,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
@@ -1432,7 +1432,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
         return u'<userGroup:%s => %s >' % (self.users_group, self.repository)
 
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
@@ -1443,7 +1443,7 b' class UsersGroupToPerm(Base, BaseModel):'
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
@@ -1465,7 +1465,7 b' class UserRepoGroupToPerm(Base, BaseMode'
     permission = relationship('Permission')
 
 
-class UsersGroupRepoGroupToPerm(Base, BaseModel):
+class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
@@ -1478,7 +1478,7 b' class UsersGroupRepoGroupToPerm(Base, Ba'
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 

rhodecode/lib/dbmigrate/versions/003_version_1_2_0.py

@@ -34,26 +34,26 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Add table `users_groups`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroup
-    UsersGroup().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserGroup
+    UserGroup().__table__.create()
 
     #==========================================================================
     # Add table `users_groups_members`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupMember
-    UsersGroupMember().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserGroupMember
+    UserGroupMember().__table__.create()
 
     #==========================================================================
     # Add table `users_group_repo_to_perm`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupRepoToPerm
-    UsersGroupRepoToPerm().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserGroupRepoToPerm
+    UserGroupRepoToPerm().__table__.create()
 
     #==========================================================================
     # Add table `users_group_to_perm`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupToPerm
-    UsersGroupToPerm().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserGroupToPerm
+    UserGroupToPerm().__table__.create()
 
     #==========================================================================
     # Upgrade of `users` table

rhodecode/lib/dbmigrate/versions/004_version_1_3_0.py

@@ -21,8 +21,8 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Add table `users_group_repo_group_to_perm`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroupRepoGroupToPerm
-    UsersGroupRepoGroupToPerm().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserGroupRepoGroupToPerm
+    UserGroupRepoGroupToPerm().__table__.create()
 
     #==========================================================================
     # Add table `changeset_comments`
@@ -45,8 +45,8 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Add unique to table `users_group_to_perm`
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroupToPerm
-    tbl = UsersGroupToPerm().__table__
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserGroupToPerm
+    tbl = UserGroupToPerm().__table__
     cons = UniqueConstraint('users_group_id', 'permission_id', table=tbl)
     cons.create()
 

rhodecode/lib/dbmigrate/versions/006_version_1_4_0.py

@@ -74,8 +74,8 b' def upgrade(migrate_engine):'
     #==========================================================================
     # USERS GROUP TABLE
     #==========================================================================
-    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroup
-    tbl = UsersGroup.__table__
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserGroup
+    tbl = UserGroup.__table__
     # add inherit_default_permission column
     gr_inherit_default_permissions = Column(
                                     "users_group_inherit_default_permissions",

rhodecode/lib/exceptions.py

@@ -50,7 +50,7 b' class UserOwnsReposException(Exception):'
     pass
 
 
-class UsersGroupsAssignedException(Exception):
+class UserGroupsAssignedException(Exception):
     pass
 
 

rhodecode/model/db.py

@@ -341,7 +341,7 b' class User(Base, BaseModel):'
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
 
-    group_member = relationship('UsersGroupMember', cascade='all')
+    group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
@@ -604,7 +604,7 b' class UserLog(Base, BaseModel):'
     repository = relationship('Repository', cascade='')
 
 
-class UsersGroup(Base, BaseModel):
+class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -616,9 +616,9 b' class UsersGroup(Base, BaseModel):'
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
 
-    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
-    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')
-    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
 
     def __unicode__(self):
         return u'<userGroup(%s)>' % (self.users_group_name)
@@ -658,7 +658,7 b' class UsersGroup(Base, BaseModel):'
         return data
 
 
-class UsersGroupMember(Base, BaseModel):
+class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
@@ -670,7 +670,7 b' class UsersGroupMember(Base, BaseModel):'
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
@@ -747,7 +747,7 b' class Repository(Base, BaseModel):'
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('RepoGroup')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing',
@@ -1227,7 +1227,7 b' class RepoGroup(Base, BaseModel):'
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
-    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
 
     parent_group = relationship('RepoGroup', remote_side=group_id)
 
@@ -1490,7 +1490,7 b' class UserToPerm(Base, BaseModel):'
     permission = relationship('Permission', lazy='joined')
 
 
-class UsersGroupRepoToPerm(Base, BaseModel):
+class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
@@ -1502,7 +1502,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
@@ -1519,7 +1519,7 b' class UsersGroupRepoToPerm(Base, BaseMod'
         return u'<userGroup:%s => %s >' % (self.users_group, self.repository)
 
 
-class UsersGroupToPerm(Base, BaseModel):
+class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
@@ -1530,7 +1530,7 b' class UsersGroupToPerm(Base, BaseModel):'
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
@@ -1552,7 +1552,7 b' class UserRepoGroupToPerm(Base, BaseMode'
     permission = relationship('Permission')
 
 
-class UsersGroupRepoGroupToPerm(Base, BaseModel):
+class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
@@ -1565,7 +1565,7 b' class UsersGroupRepoGroupToPerm(Base, Ba'
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
-    users_group = relationship('UsersGroup')
+    users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 

rhodecode/model/forms.py

@@ -94,14 +94,14 b' def UserForm(edit=False, old_data={}):'
     return _UserForm
 
 
-def UsersGroupForm(edit=False, old_data={}, available_members=[]):
-    class _UsersGroupForm(formencode.Schema):
+def UserGroupForm(edit=False, old_data={}, available_members=[]):
+    class _UserGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         users_group_name = All(
             v.UnicodeString(strip=True, min=1, not_empty=True),
-            v.ValidUsersGroup(edit, old_data)
+            v.ValidUserGroup(edit, old_data)
         )
 
         users_group_active = v.StringBoolean(if_missing=False)
@@ -112,7 +112,7 b' def UsersGroupForm(edit=False, old_data='
                 if_missing=None, not_empty=False
             )
 
-    return _UsersGroupForm
+    return _UserGroupForm
 
 
 def ReposGroupForm(edit=False, old_data={}, available_groups=[],

rhodecode/model/repo.py

@@ -38,7 +38,7 b' from rhodecode.lib.hooks import log_crea'
 
 from rhodecode.model import BaseModel
 from rhodecode.model.db import Repository, UserRepoToPerm, User, Permission, \
-    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, RepoGroup,\
+    Statistics, UserGroup, UserGroupRepoToPerm, RhodeCodeUi, RepoGroup,\
     RhodeCodeSetting, RepositoryField
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import HasRepoPermissionAny
@@ -54,8 +54,8 b' class RepoModel(BaseModel):'
     URL_SEPARATOR = Repository.url_sep()
 
     def __get_users_group(self, users_group):
-        return self._get_instance(UsersGroup, users_group,
-                                  callback=UsersGroup.get_by_group_name)
+        return self._get_instance(UserGroup, users_group,
+                                  callback=UserGroup.get_by_group_name)
 
     def _get_repos_group(self, repos_group):
         return self._get_instance(RepoGroup, repos_group,
@@ -120,8 +120,8 b' class RepoModel(BaseModel):'
         )
 
     def get_users_groups_js(self):
-        users_groups = self.sa.query(UsersGroup)\
-            .filter(UsersGroup.users_group_active == True).all()
+        users_groups = self.sa.query(UserGroup)\
+            .filter(UserGroup.users_group_active == True).all()
 
         return json.dumps([
             {
@@ -415,15 +415,15 b' class RepoModel(BaseModel):'
                     repo = fork_of
                     user_perms = UserRepoToPerm.query()\
                         .filter(UserRepoToPerm.repository == repo).all()
-                    group_perms = UsersGroupRepoToPerm.query()\
-                        .filter(UsersGroupRepoToPerm.repository == repo).all()
+                    group_perms = UserGroupRepoToPerm.query()\
+                        .filter(UserGroupRepoToPerm.repository == repo).all()
 
                     for perm in user_perms:
                         UserRepoToPerm.create(perm.user, new_repo,
                                               perm.permission)
 
                     for perm in group_perms:
-                        UsersGroupRepoToPerm.create(perm.users_group, new_repo,
+                        UserGroupRepoToPerm.create(perm.users_group, new_repo,
                                                     perm.permission)
                 else:
                     _create_default_perms()
@@ -562,14 +562,14 b' class RepoModel(BaseModel):'
         permission = self._get_perm(perm)
 
         # check if we have that permission already
-        obj = self.sa.query(UsersGroupRepoToPerm)\
-            .filter(UsersGroupRepoToPerm.users_group == group_name)\
-            .filter(UsersGroupRepoToPerm.repository == repo)\
+        obj = self.sa.query(UserGroupRepoToPerm)\
+            .filter(UserGroupRepoToPerm.users_group == group_name)\
+            .filter(UserGroupRepoToPerm.repository == repo)\
             .scalar()
 
         if obj is None:
             # create new
-            obj = UsersGroupRepoToPerm()
+            obj = UserGroupRepoToPerm()
 
         obj.repository = repo
         obj.users_group = group_name
@@ -588,9 +588,9 b' class RepoModel(BaseModel):'
         repo = self._get_repo(repo)
         group_name = self.__get_users_group(group_name)
 
-        obj = self.sa.query(UsersGroupRepoToPerm)\
-            .filter(UsersGroupRepoToPerm.repository == repo)\
-            .filter(UsersGroupRepoToPerm.users_group == group_name)\
+        obj = self.sa.query(UserGroupRepoToPerm)\
+            .filter(UserGroupRepoToPerm.repository == repo)\
+            .filter(UserGroupRepoToPerm.users_group == group_name)\
             .scalar()
         if obj:
             self.sa.delete(obj)

rhodecode/model/repo_permission.py

@@ -26,7 +26,7 b''
 
 import logging
 from rhodecode.model import BaseModel
-from rhodecode.model.db import UserRepoToPerm, UsersGroupRepoToPerm, \
+from rhodecode.model.db import UserRepoToPerm, UserGroupRepoToPerm, \
     Permission
 
 log = logging.getLogger(__name__)
@@ -64,9 +64,9 b' class RepositoryPermissionModel(BaseMode'
             self.sa.delete(current)
 
     def get_users_group_permission(self, repository, users_group):
-        return UsersGroupRepoToPerm.query() \
-                .filter(UsersGroupRepoToPerm.users_group == users_group) \
-                .filter(UsersGroupRepoToPerm.repository == repository) \
+        return UserGroupRepoToPerm.query() \
+                .filter(UserGroupRepoToPerm.users_group == users_group) \
+                .filter(UserGroupRepoToPerm.repository == repository) \
                 .scalar()
 
     def update_users_group_permission(self, repository, users_group,
@@ -77,7 +77,7 b' class RepositoryPermissionModel(BaseMode'
             if not current.permission is permission:
                 current.permission = permission
         else:
-            p = UsersGroupRepoToPerm()
+            p = UserGroupRepoToPerm()
             p.users_group = users_group
             p.repository = repository
             p.permission = permission

rhodecode/model/repos_group.py

@@ -33,7 +33,7 b' from rhodecode.lib.utils2 import LazyPro'
 
 from rhodecode.model import BaseModel
 from rhodecode.model.db import RepoGroup, RhodeCodeUi, UserRepoGroupToPerm, \
-    User, Permission, UsersGroupRepoGroupToPerm, UsersGroup, Repository
+    User, Permission, UserGroupRepoGroupToPerm, UserGroup, Repository
 
 log = logging.getLogger(__name__)
 
@@ -43,8 +43,8 b' class ReposGroupModel(BaseModel):'
     cls = RepoGroup
 
     def __get_users_group(self, users_group):
-        return self._get_instance(UsersGroup, users_group,
-                                  callback=UsersGroup.get_by_group_name)
+        return self._get_instance(UserGroup, users_group,
+                                  callback=UserGroup.get_by_group_name)
 
     def _get_repos_group(self, repos_group):
         return self._get_instance(RepoGroup, repos_group,
@@ -390,14 +390,14 b' class ReposGroupModel(BaseModel):'
         permission = self._get_perm(perm)
 
         # check if we have that permission already
-        obj = self.sa.query(UsersGroupRepoGroupToPerm)\
-            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\
-            .filter(UsersGroupRepoGroupToPerm.users_group == group_name)\
+        obj = self.sa.query(UserGroupRepoGroupToPerm)\
+            .filter(UserGroupRepoGroupToPerm.group == repos_group)\
+            .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
 
         if obj is None:
             # create new
-            obj = UsersGroupRepoGroupToPerm()
+            obj = UserGroupRepoGroupToPerm()
 
         obj.group = repos_group
         obj.users_group = group_name
@@ -417,9 +417,9 b' class ReposGroupModel(BaseModel):'
         repos_group = self._get_repos_group(repos_group)
         group_name = self.__get_users_group(group_name)
 
-        obj = self.sa.query(UsersGroupRepoGroupToPerm)\
-            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\
-            .filter(UsersGroupRepoGroupToPerm.users_group == group_name)\
+        obj = self.sa.query(UserGroupRepoGroupToPerm)\
+            .filter(UserGroupRepoGroupToPerm.group == repos_group)\
+            .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
         if obj:
             self.sa.delete(obj)

rhodecode/model/user.py

@@ -37,8 +37,8 b' from rhodecode.lib.utils2 import safe_un'
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.model import BaseModel
 from rhodecode.model.db import User, UserRepoToPerm, Repository, Permission, \
-    UserToPerm, UsersGroupRepoToPerm, UsersGroupToPerm, UsersGroupMember, \
-    Notification, RepoGroup, UserRepoGroupToPerm, UsersGroupRepoGroupToPerm, \
+    UserToPerm, UserGroupRepoToPerm, UserGroupToPerm, UserGroupMember, \
+    Notification, RepoGroup, UserRepoGroupToPerm, UserGroupRepoGroupToPerm, \
     UserEmailMap, UserIpMap
 from rhodecode.lib.exceptions import DefaultUserException, \
     UserOwnsReposException
@@ -513,12 +513,12 b' class UserModel(BaseModel):'
 
         # USER GROUPS comes first
         # user group global permissions
-        user_perms_from_users_groups = self.sa.query(UsersGroupToPerm)\
-            .options(joinedload(UsersGroupToPerm.permission))\
-            .join((UsersGroupMember, UsersGroupToPerm.users_group_id ==
-                   UsersGroupMember.users_group_id))\
-            .filter(UsersGroupMember.user_id == uid)\
-            .order_by(UsersGroupToPerm.users_group_id)\
+        user_perms_from_users_groups = self.sa.query(UserGroupToPerm)\
+            .options(joinedload(UserGroupToPerm.permission))\
+            .join((UserGroupMember, UserGroupToPerm.users_group_id ==
+                   UserGroupMember.users_group_id))\
+            .filter(UserGroupMember.user_id == uid)\
+            .order_by(UserGroupToPerm.users_group_id)\
             .all()
         #need to group here by groups since user can be in more than one group
         _grouped = [[x, list(y)] for x, y in
@@ -561,19 +561,19 b' class UserModel(BaseModel):'
 
         # user group for repositories permissions
         user_repo_perms_from_users_groups = \
-         self.sa.query(UsersGroupRepoToPerm, Permission, Repository,)\
-            .join((Repository, UsersGroupRepoToPerm.repository_id ==
+         self.sa.query(UserGroupRepoToPerm, Permission, Repository,)\
+            .join((Repository, UserGroupRepoToPerm.repository_id ==
                    Repository.repo_id))\
-            .join((Permission, UsersGroupRepoToPerm.permission_id ==
+            .join((Permission, UserGroupRepoToPerm.permission_id ==
                    Permission.permission_id))\
-            .join((UsersGroupMember, UsersGroupRepoToPerm.users_group_id ==
-                   UsersGroupMember.users_group_id))\
-            .filter(UsersGroupMember.user_id == uid)\
+            .join((UserGroupMember, UserGroupRepoToPerm.users_group_id ==
+                   UserGroupMember.users_group_id))\
+            .filter(UserGroupMember.user_id == uid)\
             .all()
 
         multiple_counter = collections.defaultdict(int)
         for perm in user_repo_perms_from_users_groups:
-            r_k = perm.UsersGroupRepoToPerm.repository.repo_name
+            r_k = perm.UserGroupRepoToPerm.repository.repo_name
             multiple_counter[r_k] += 1
             p = perm.Permission.permission_name
             cur_perm = user.permissions[RK][r_k]
@@ -619,18 +619,18 b' class UserModel(BaseModel):'
         #======================================================================
         # user group for repo groups permissions
         user_repo_group_perms_from_users_groups = \
-         self.sa.query(UsersGroupRepoGroupToPerm, Permission, RepoGroup)\
-         .join((RepoGroup, UsersGroupRepoGroupToPerm.group_id == RepoGroup.group_id))\
-         .join((Permission, UsersGroupRepoGroupToPerm.permission_id
+         self.sa.query(UserGroupRepoGroupToPerm, Permission, RepoGroup)\
+         .join((RepoGroup, UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id))\
+         .join((Permission, UserGroupRepoGroupToPerm.permission_id
                 == Permission.permission_id))\
-         .join((UsersGroupMember, UsersGroupRepoGroupToPerm.users_group_id
-                == UsersGroupMember.users_group_id))\
-         .filter(UsersGroupMember.user_id == uid)\
+         .join((UserGroupMember, UserGroupRepoGroupToPerm.users_group_id
+                == UserGroupMember.users_group_id))\
+         .filter(UserGroupMember.user_id == uid)\
          .all()
 
         multiple_counter = collections.defaultdict(int)
         for perm in user_repo_group_perms_from_users_groups:
-            g_k = perm.UsersGroupRepoGroupToPerm.group.group_name
+            g_k = perm.UserGroupRepoGroupToPerm.group.group_name
             multiple_counter[g_k] += 1
             p = perm.Permission.permission_name
             cur_perm = user.permissions[GK][g_k]

rhodecode/model/users_group.py

@@ -28,33 +28,33 b' import logging'
 import traceback
 
 from rhodecode.model import BaseModel
-from rhodecode.model.db import UsersGroupMember, UsersGroup,\
-    UsersGroupRepoToPerm, Permission, UsersGroupToPerm, User
-from rhodecode.lib.exceptions import UsersGroupsAssignedException
+from rhodecode.model.db import UserGroupMember, UserGroup,\
+    UserGroupRepoToPerm, Permission, UserGroupToPerm, User
+from rhodecode.lib.exceptions import UserGroupsAssignedException
 
 log = logging.getLogger(__name__)
 
 
-class UsersGroupModel(BaseModel):
+class UserGroupModel(BaseModel):
 
-    cls = UsersGroup
+    cls = UserGroup
 
     def __get_users_group(self, users_group):
-        return self._get_instance(UsersGroup, users_group,
-                                  callback=UsersGroup.get_by_group_name)
+        return self._get_instance(UserGroup, users_group,
+                                  callback=UserGroup.get_by_group_name)
 
     def get(self, users_group_id, cache=False):
-        return UsersGroup.get(users_group_id)
+        return UserGroup.get(users_group_id)
 
     def get_group(self, users_group):
         return self.__get_users_group(users_group)
 
     def get_by_name(self, name, cache=False, case_insensitive=False):
-        return UsersGroup.get_by_group_name(name, cache, case_insensitive)
+        return UserGroup.get_by_group_name(name, cache, case_insensitive)
 
     def create(self, name, active=True):
         try:
-            new = UsersGroup()
+            new = UserGroup()
             new.users_group_name = name
             new.users_group_active = active
             self.sa.add(new)
@@ -76,7 +76,7 b' class UsersGroupModel(BaseModel):'
                     if v:
                         v = [v] if isinstance(v, basestring) else v
                         for u_id in set(v):
-                            member = UsersGroupMember(users_group.users_group_id, u_id)
+                            member = UserGroupMember(users_group.users_group_id, u_id)
                             members_list.append(member)
                     setattr(users_group, 'members', members_list)
                 setattr(users_group, k, v)
@@ -99,11 +99,11 b' class UsersGroupModel(BaseModel):'
             users_group = self.__get_users_group(users_group)
 
             # check if this group is not assigned to repo
-            assigned_groups = UsersGroupRepoToPerm.query()\
-                .filter(UsersGroupRepoToPerm.users_group == users_group).all()
+            assigned_groups = UserGroupRepoToPerm.query()\
+                .filter(UserGroupRepoToPerm.users_group == users_group).all()
 
             if assigned_groups and force is False:
-                raise UsersGroupsAssignedException('RepoGroup assigned to %s' %
+                raise UserGroupsAssignedException('RepoGroup assigned to %s' %
                                                    assigned_groups)
 
             self.sa.delete(users_group)
@@ -121,7 +121,7 b' class UsersGroupModel(BaseModel):'
                 return True
 
         try:
-            users_group_member = UsersGroupMember()
+            users_group_member = UserGroupMember()
             users_group_member.user = user
             users_group_member.users_group = users_group
 
@@ -160,23 +160,23 b' class UsersGroupModel(BaseModel):'
         users_group = self.__get_users_group(users_group)
         perm = self._get_perm(perm)
 
-        return UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == users_group)\
-            .filter(UsersGroupToPerm.permission == perm).scalar() is not None
+        return UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == users_group)\
+            .filter(UserGroupToPerm.permission == perm).scalar() is not None
 
     def grant_perm(self, users_group, perm):
         users_group = self.__get_users_group(users_group)
         perm = self._get_perm(perm)
 
         # if this permission is already granted skip it
-        _perm = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == users_group)\
-            .filter(UsersGroupToPerm.permission == perm)\
+        _perm = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == users_group)\
+            .filter(UserGroupToPerm.permission == perm)\
             .scalar()
         if _perm:
             return
 
-        new = UsersGroupToPerm()
+        new = UserGroupToPerm()
         new.users_group = users_group
         new.permission = perm
         self.sa.add(new)
@@ -185,8 +185,8 b' class UsersGroupModel(BaseModel):'
         users_group = self.__get_users_group(users_group)
         perm = self._get_perm(perm)
 
-        obj = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == users_group)\
-            .filter(UsersGroupToPerm.permission == perm).scalar()
+        obj = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == users_group)\
+            .filter(UserGroupToPerm.permission == perm).scalar()
         if obj:
             self.sa.delete(obj)

rhodecode/model/validators.py

@@ -16,7 +16,7 b' from formencode.validators import ('
 from rhodecode.lib.compat import OrderedSet
 from rhodecode.lib import ipaddr
 from rhodecode.lib.utils import repo_name_slug
-from rhodecode.model.db import RepoGroup, Repository, UsersGroup, User,\
+from rhodecode.model.db import RepoGroup, Repository, UserGroup, User,\
     ChangesetStatus
 from rhodecode.lib.exceptions import LdapImportError
 from rhodecode.config.routing import ADMIN_PREFIX
@@ -129,13 +129,13 b' def ValidRepoUser():'
     return _validator
 
 
-def ValidUsersGroup(edit=False, old_data={}):
+def ValidUserGroup(edit=False, old_data={}):
     class _validator(formencode.validators.FancyValidator):
         messages = {
             'invalid_group': _(u'Invalid user group name'),
-            'group_exist': _(u'User group "%(usersgroup)s" already exists'),
-            'invalid_usersgroup_name':
-                _(u'user group name may only contain  alphanumeric '
+            'group_exist': _(u'User group "%(usergroup)s" already exists'),
+            'invalid_usergroup_name':
+                _(u'user group name may only contain alphanumeric '
                   'characters underscores, periods or dashes and must begin '
                   'with alphanumeric character')
         }
@@ -150,19 +150,19 b' def ValidUsersGroup(edit=False, old_data'
             old_ugname = None
             if edit:
                 old_id = old_data.get('users_group_id')
-                old_ugname = UsersGroup.get(old_id).users_group_name
+                old_ugname = UserGroup.get(old_id).users_group_name
 
             if old_ugname != value or not edit:
-                is_existing_group = UsersGroup.get_by_group_name(value,
+                is_existing_group = UserGroup.get_by_group_name(value,
                                                         case_insensitive=True)
                 if is_existing_group:
-                    msg = M(self, 'group_exist', state, usersgroup=value)
+                    msg = M(self, 'group_exist', state, usergroup=value)
                     raise formencode.Invalid(msg, value, state,
                         error_dict=dict(users_group_name=msg)
                     )
 
             if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
-                msg = M(self, 'invalid_usersgroup_name', state)
+                msg = M(self, 'invalid_usergroup_name', state)
                 raise formencode.Invalid(msg, value, state,
                     error_dict=dict(users_group_name=msg)
                 )
@@ -604,9 +604,9 b" def ValidPerms(type_='repo'):"
                             .filter(User.active == True)\
                             .filter(User.username == k).one()
                     if t is 'users_group':
-                        self.user_db = UsersGroup.query()\
-                            .filter(UsersGroup.users_group_active == True)\
-                            .filter(UsersGroup.users_group_name == k).one()
+                        self.user_db = UserGroup.query()\
+                            .filter(UserGroup.users_group_active == True)\
+                            .filter(UserGroup.users_group_name == k).one()
 
                 except Exception:
                     log.exception('Updated permission failed')

rhodecode/public/js/rhodecode.js

@@ -1301,7 +1301,7 b' var MembersAutoComplete = function (divi'
             return matches;
         };
 
-    // Define a custom search function for the DataSource of usersGroups
+    // Define a custom search function for the DataSource of userGroups
     var matchGroups = function (sQuery) {
             // Case insensitive matching
             var query = sQuery.toLowerCase();
@@ -1719,7 +1719,7 b' var PullRequestAutoComplete = function ('
             return matches;
         };
 
-    // Define a custom search function for the DataSource of usersGroups
+    // Define a custom search function for the DataSource of userGroups
     var matchGroups = function (sQuery) {
             // Case insensitive matching
             var query = sQuery.toLowerCase();

rhodecode/templates/admin/repos/repo_edit_perms.html

@@ -54,7 +54,7 b''
                 %endif
             </td>
             <td>
-                <span class="delete_icon action_button" onclick="ajaxActionUsersGroup(${g2p.users_group.users_group_id},'${'id%s'%id(g2p.users_group.users_group_name)}')">
+                <span class="delete_icon action_button" onclick="ajaxActionUserGroup(${g2p.users_group.users_group_id},'${'id%s'%id(g2p.users_group.users_group_name)}')">
                 ${_('revoke')}
                 </span>
             </td>
@@ -101,7 +101,7 b' function ajaxActionUser(user_id, field_i'
     var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, callback, postData);
 };
 
-function ajaxActionUsersGroup(users_group_id,field_id){
+function ajaxActionUserGroup(users_group_id,field_id){
     var sUrl = "${h.url('delete_repo_users_group',repo_name=c.repo_name)}";
     var callback = {
         success:function(o){

rhodecode/templates/admin/repos_groups/repos_group_edit_perms.html

@@ -51,7 +51,7 b''
                 <img class="perm-gravatar" src="${h.url('/images/icons/group.png')}"/>${g2p.users_group.users_group_name}
             </td>
             <td>
-                <span class="delete_icon action_button" onclick="ajaxActionUsersGroup(${g2p.users_group.users_group_id},'${'id%s'%id(g2p.users_group.users_group_name)}')">
+                <span class="delete_icon action_button" onclick="ajaxActionUserGroup(${g2p.users_group.users_group_id},'${'id%s'%id(g2p.users_group.users_group_name)}')">
                 ${_('revoke')}
                 </span>
             </td>
@@ -105,7 +105,7 b' function ajaxActionUser(user_id, field_i'
     var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, callback, postData);
 };
 
-function ajaxActionUsersGroup(users_group_id,field_id){
+function ajaxActionUserGroup(users_group_id,field_id){
     var sUrl = "${h.url('delete_repos_group_users_group_perm',group_name=c.repos_group.group_name)}";
     var callback = {
         success:function(o){

rhodecode/templates/admin/users_groups/users_group_edit.html

@@ -8,7 +8,7 b''
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
-    ${h.link_to(_('UsersGroups'),h.url('users_groups'))}
+    ${h.link_to(_('UserGroups'),h.url('users_groups'))}
     &raquo;
     ${_('edit')} "${c.users_group.users_group_name}"
 </%def>

rhodecode/tests/api/api_base.py

@@ -6,7 +6,7 b' from rhodecode.tests import *'
 from rhodecode.lib.compat import json
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.user import UserModel
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
@@ -43,19 +43,19 b' def api_call(test_obj, params):'
     return response
 
 
-TEST_USERS_GROUP = 'test_users_group'
+TEST_USER_GROUP = 'test_users_group'
 
 
-def make_users_group(name=TEST_USERS_GROUP):
-    gr = UsersGroupModel().create(name=name)
-    UsersGroupModel().add_user_to_group(users_group=gr,
+def make_users_group(name=TEST_USER_GROUP):
+    gr = UserGroupModel().create(name=name)
+    UserGroupModel().add_user_to_group(users_group=gr,
                                         user=TEST_USER_ADMIN_LOGIN)
     Session().commit()
     return gr
 
 
-def destroy_users_group(name=TEST_USERS_GROUP):
-    UsersGroupModel().delete(users_group=name, force=True)
+def destroy_users_group(name=TEST_USER_GROUP):
+    UserGroupModel().delete(users_group=name, force=True)
     Session().commit()
 
 
@@ -999,10 +999,10 b' class BaseTestApi(object):'
 
     def test_api_get_users_group(self):
         id_, params = _build_data(self.apikey, 'get_users_group',
-                                  usersgroupid=TEST_USERS_GROUP)
+                                  usersgroupid=TEST_USER_GROUP)
         response = api_call(self, params)
 
-        users_group = UsersGroupModel().get_group(TEST_USERS_GROUP)
+        users_group = UserGroupModel().get_group(TEST_USER_GROUP)
         members = []
         for user in users_group.members:
             user = user.user
@@ -1021,13 +1021,13 b' class BaseTestApi(object):'
         response = api_call(self, params)
 
         expected = []
-        for gr_name in [TEST_USERS_GROUP, 'test_users_group2']:
-            users_group = UsersGroupModel().get_group(gr_name)
+        for gr_name in [TEST_USER_GROUP, 'test_users_group2']:
+            users_group = UserGroupModel().get_group(gr_name)
             ret = users_group.get_api_data()
             expected.append(ret)
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group='test_users_group2')
+        UserGroupModel().delete(users_group='test_users_group2')
         Session().commit()
 
     def test_api_create_users_group(self):
@@ -1038,7 +1038,7 b' class BaseTestApi(object):'
 
         ret = {
             'msg': 'created new user group `%s`' % group_name,
-            'users_group': jsonify(UsersGroupModel()\
+            'users_group': jsonify(UserGroupModel()\
                                    .get_by_name(group_name)\
                                    .get_api_data())
         }
@@ -1049,13 +1049,13 b' class BaseTestApi(object):'
 
     def test_api_get_users_group_that_exist(self):
         id_, params = _build_data(self.apikey, 'create_users_group',
-                                  group_name=TEST_USERS_GROUP)
+                                  group_name=TEST_USER_GROUP)
         response = api_call(self, params)
 
-        expected = "user group `%s` already exist" % TEST_USERS_GROUP
+        expected = "user group `%s` already exist" % TEST_USER_GROUP
         self._compare_error(id_, expected, given=response.body)
 
-    @mock.patch.object(UsersGroupModel, 'create', crash)
+    @mock.patch.object(UserGroupModel, 'create', crash)
     def test_api_get_users_group_exception_occurred(self):
         group_name = 'exception_happens'
         id_, params = _build_data(self.apikey, 'create_users_group',
@@ -1067,7 +1067,7 b' class BaseTestApi(object):'
 
     def test_api_add_user_to_users_group(self):
         gr_name = 'test_group'
-        UsersGroupModel().create(gr_name)
+        UserGroupModel().create(gr_name)
         Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
@@ -1081,7 +1081,7 b' class BaseTestApi(object):'
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     def test_api_add_user_to_users_group_that_doesnt_exist(self):
@@ -1093,10 +1093,10 b' class BaseTestApi(object):'
         expected = 'user group `%s` does not exist' % 'false-group'
         self._compare_error(id_, expected, given=response.body)
 
-    @mock.patch.object(UsersGroupModel, 'add_user_to_group', crash)
+    @mock.patch.object(UserGroupModel, 'add_user_to_group', crash)
     def test_api_add_user_to_users_group_exception_occurred(self):
         gr_name = 'test_group'
-        UsersGroupModel().create(gr_name)
+        UserGroupModel().create(gr_name)
         Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
@@ -1106,13 +1106,13 b' class BaseTestApi(object):'
         expected = 'failed to add member to user group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     def test_api_remove_user_from_users_group(self):
         gr_name = 'test_group_3'
-        gr = UsersGroupModel().create(gr_name)
-        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
+        gr = UserGroupModel().create(gr_name)
+        UserGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
@@ -1126,14 +1126,14 b' class BaseTestApi(object):'
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
-    @mock.patch.object(UsersGroupModel, 'remove_user_from_group', crash)
+    @mock.patch.object(UserGroupModel, 'remove_user_from_group', crash)
     def test_api_remove_user_from_users_group_exception_occurred(self):
         gr_name = 'test_group_3'
-        gr = UsersGroupModel().create(gr_name)
-        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
+        gr = UserGroupModel().create(gr_name)
+        UserGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
@@ -1143,7 +1143,7 b' class BaseTestApi(object):'
         expected = 'failed to remove member from user group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     @parameterized.expand([('none', 'repository.none'),
@@ -1224,13 +1224,13 b' class BaseTestApi(object):'
     def test_api_grant_users_group_permission(self, name, perm):
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
         ret = {
             'msg': 'Granted perm: `%s` for user group: `%s` in repo: `%s`' % (
-                perm, TEST_USERS_GROUP, self.REPO
+                perm, TEST_USER_GROUP, self.REPO
             ),
             'success': True
         }
@@ -1241,7 +1241,7 b' class BaseTestApi(object):'
         perm = 'haha.no.permission'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
@@ -1253,28 +1253,28 b' class BaseTestApi(object):'
         perm = 'repository.read'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
         expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (
-                    TEST_USERS_GROUP, self.REPO
+                    TEST_USER_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_revoke_users_group_permission(self):
         RepoModel().grant_users_group_permission(repo=self.REPO,
-                                                 group_name=TEST_USERS_GROUP,
+                                                 group_name=TEST_USER_GROUP,
                                                  perm='repository.read')
         Session().commit()
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,)
+                                  usersgroupid=TEST_USER_GROUP,)
         response = api_call(self, params)
 
         expected = {
             'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (
-                TEST_USERS_GROUP, self.REPO
+                TEST_USER_GROUP, self.REPO
             ),
             'success': True
         }
@@ -1285,10 +1285,10 b' class BaseTestApi(object):'
 
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,)
+                                  usersgroupid=TEST_USER_GROUP,)
         response = api_call(self, params)
 
         expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (
-                    TEST_USERS_GROUP, self.REPO
+                    TEST_USER_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)

rhodecode/tests/functional/test_admin_users_groups.py

@@ -1,7 +1,7 b''
 from rhodecode.tests import *
-from rhodecode.model.db import UsersGroup, UsersGroupToPerm, Permission
+from rhodecode.model.db import UserGroup, UserGroupToPerm, Permission
 
-TEST_USERS_GROUP = 'admins_test'
+TEST_USER_GROUP = 'admins_test'
 
 
 class TestAdminUsersGroupsController(TestController):
@@ -15,14 +15,14 b' class TestAdminUsersGroupsController(Tes'
 
     def test_create(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP
+        users_group_name = TEST_USER_GROUP
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active':True})
         response.follow()
 
         self.checkSessionFlash(response,
-                               'created user group %s' % TEST_USERS_GROUP)
+                               'created user group %s' % TEST_USER_GROUP)
 
     def test_new(self):
         response = self.app.get(url('new_users_group'))
@@ -39,7 +39,7 b' class TestAdminUsersGroupsController(Tes'
 
     def test_delete(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another'
+        users_group_name = TEST_USER_GROUP + 'another'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name':users_group_name,
                                   'active':True})
@@ -48,27 +48,27 b' class TestAdminUsersGroupsController(Tes'
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
 
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).one()
 
         response = self.app.delete(url('users_group', id=gr.users_group_id))
 
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
 
     def test_enable_repository_read_on_group(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another2'
+        users_group_name = TEST_USER_GROUP + 'another2'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active': True})
         response.follow()
 
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
         ## ENABLE REPO CREATE ON A GROUP
@@ -76,13 +76,13 b' class TestAdminUsersGroupsController(Tes'
                                  {'create_repo_perm': True})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.repository')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -95,13 +95,13 b' class TestAdminUsersGroupsController(Tes'
                                     {})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
@@ -110,18 +110,18 b' class TestAdminUsersGroupsController(Tes'
         )
 
         # DELETE !
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         ugid = ug.users_group_id
         response = self.app.delete(url('users_group', id=ug.users_group_id))
         response = response.follow()
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
         p = Permission.get_by_key('hg.create.repository')
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group_id == ugid).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
         self.assertEqual(
@@ -131,13 +131,13 b' class TestAdminUsersGroupsController(Tes'
 
     def test_enable_repository_fork_on_group(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another2'
+        users_group_name = TEST_USER_GROUP + 'another2'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active': True})
         response.follow()
 
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
         ## ENABLE REPO CREATE ON A GROUP
@@ -145,13 +145,13 b' class TestAdminUsersGroupsController(Tes'
                                  {'fork_repo_perm': True})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.repository')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -164,13 +164,13 b' class TestAdminUsersGroupsController(Tes'
                                     {})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -179,18 +179,18 b' class TestAdminUsersGroupsController(Tes'
         )
 
         # DELETE !
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         ugid = ug.users_group_id
         response = self.app.delete(url('users_group', id=ug.users_group_id))
         response = response.follow()
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
         p = Permission.get_by_key('hg.fork.repository')
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group_id == ugid).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
         self.assertEqual(

rhodecode/tests/models/test_permissions.py

@@ -4,11 +4,11 b' from rhodecode.tests import *'
 from rhodecode.tests.models.common import _make_group
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.db import RepoGroup, User, UsersGroupRepoGroupToPerm
+from rhodecode.model.db import RepoGroup, User, UserGroupRepoGroupToPerm
 from rhodecode.model.user import UserModel
 
 from rhodecode.model.meta import Session
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.lib.auth import AuthUser
 from rhodecode.tests.api.api_base import create_repo
 
@@ -51,7 +51,7 b' class TestPermissions(unittest.TestCase)'
             ReposGroupModel().delete(self.g2.group_id)
 
         if hasattr(self, 'ug1'):
-            UsersGroupModel().delete(self.ug1, force=True)
+            UserGroupModel().delete(self.ug1, force=True)
 
         Session().commit()
 
@@ -124,10 +124,10 b' class TestPermissions(unittest.TestCase)'
 
     def test_propagated_permission_from_users_group_by_explicit_perms_exist(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
 
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm = 'repository.none'
@@ -158,10 +158,10 b' class TestPermissions(unittest.TestCase)'
 
     def test_propagated_permission_from_users_group(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
 
-        UsersGroupModel().add_user_to_group(self.ug1, self.u3)
+        UserGroupModel().add_user_to_group(self.ug1, self.u3)
 
         # grant perm for group this should override default permission from user
         new_perm_gr = 'repository.write'
@@ -183,9 +183,9 b' class TestPermissions(unittest.TestCase)'
 
     def test_propagated_permission_from_users_group_lower_weight(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm_h = 'repository.write'
@@ -299,13 +299,13 b' class TestPermissions(unittest.TestCase)'
                                                 user=self.anon,
                                                 perm='group.none')
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
         Session().commit()
 
         # check if user is in the group
-        membrs = [x.user_id for x in UsersGroupModel().get(self.ug1.users_group_id).members]
+        membrs = [x.user_id for x in UserGroupModel().get(self.ug1.users_group_id).members]
         self.assertEqual(membrs, [self.u1.user_id])
         # add some user to that group
 
@@ -324,9 +324,9 b' class TestPermissions(unittest.TestCase)'
                                                        perm='group.read')
         Session().commit()
         # check if the
-        obj = Session().query(UsersGroupRepoGroupToPerm)\
-            .filter(UsersGroupRepoGroupToPerm.group == self.g1)\
-            .filter(UsersGroupRepoGroupToPerm.users_group == self.ug1)\
+        obj = Session().query(UserGroupRepoGroupToPerm)\
+            .filter(UserGroupRepoGroupToPerm.group == self.g1)\
+            .filter(UserGroupRepoGroupToPerm.users_group == self.ug1)\
             .scalar()
         self.assertEqual(obj.permission.permission_name, 'group.read')
 
@@ -440,9 +440,9 b' class TestPermissions(unittest.TestCase)'
         self.assertEqual(u1_auth.permissions['repositories']['myownrepo'],
                          'repository.admin')
         #set his permission as user group, he should still be admin
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
         RepoModel().grant_users_group_permission(repo, group_name=self.ug1,
                                                  perm='repository.none')
 

rhodecode/tests/models/test_users.py

@@ -1,12 +1,12 b''
 import unittest
 from rhodecode.tests import *
 
-from rhodecode.model.db import User, UsersGroup, UsersGroupMember, UserEmailMap,\
+from rhodecode.model.db import User, UserGroup, UserGroupMember, UserEmailMap,\
     Permission
 from rhodecode.model.user import UserModel
 
 from rhodecode.model.meta import Session
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 
 
 class TestUser(unittest.TestCase):
@@ -23,18 +23,18 b' class TestUser(unittest.TestCase):'
         self.assertEqual(User.get_by_username(u'test_user'), usr)
 
         # make user group
-        users_group = UsersGroupModel().create('some_example_group')
+        users_group = UserGroupModel().create('some_example_group')
         Session().commit()
 
-        UsersGroupModel().add_user_to_group(users_group, usr)
+        UserGroupModel().add_user_to_group(users_group, usr)
         Session().commit()
 
-        self.assertEqual(UsersGroup.get(users_group.users_group_id), users_group)
-        self.assertEqual(UsersGroupMember.query().count(), 1)
+        self.assertEqual(UserGroup.get(users_group.users_group_id), users_group)
+        self.assertEqual(UserGroupMember.query().count(), 1)
         UserModel().delete(usr.user_id)
         Session().commit()
 
-        self.assertEqual(UsersGroupMember.query().all(), [])
+        self.assertEqual(UserGroupMember.query().all(), [])
 
     def test_additonal_email_as_main(self):
         usr = UserModel().create_or_update(username=u'test_user',

rhodecode/tests/models/test_users_group_permissions_on_groups.py

@@ -10,7 +10,7 b' from rhodecode.model.meta import Session'
 from nose.tools import with_setup
 from rhodecode.tests.models.common import _create_project_tree, check_tree_perms, \
     _get_perms, _check_expected_count, expected_count, _destroy_project_tree
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 
 
@@ -40,10 +40,10 b' def setup_module():'
     Session().commit()
     test_u2_id = test_u2.user_id
 
-    gr1 = UsersGroupModel().create(name='perms_group_1')
+    gr1 = UserGroupModel().create(name='perms_group_1')
     Session().commit()
     test_u2_gr_id = gr1.users_group_id
-    UsersGroupModel().add_user_to_group(gr1, user=test_u2_id)
+    UserGroupModel().add_user_to_group(gr1, user=test_u2_id)
     Session().commit()
 
     _get_repo_perms = functools.partial(_get_perms, key='repositories',

rhodecode/tests/test_validators.py

@@ -5,7 +5,7 b' import formencode'
 from rhodecode.tests import *
 
 from rhodecode.model import validators as v
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repos_group import ReposGroupModel
@@ -51,25 +51,25 b' class TestReposGroups(unittest.TestCase)'
         self.assertEqual(TEST_USER_ADMIN_LOGIN,
                          validator.to_python(TEST_USER_ADMIN_LOGIN))
 
-    def test_ValidUsersGroup(self):
-        validator = v.ValidUsersGroup()
+    def test_ValidUserGroup(self):
+        validator = v.ValidUserGroup()
         self.assertRaises(formencode.Invalid, validator.to_python, 'default')
         self.assertRaises(formencode.Invalid, validator.to_python, '.,')
 
-        gr = UsersGroupModel().create('test')
-        gr2 = UsersGroupModel().create('tes2')
+        gr = UserGroupModel().create('test')
+        gr2 = UserGroupModel().create('tes2')
         Session.commit()
         self.assertRaises(formencode.Invalid, validator.to_python, 'test')
         assert gr.users_group_id != None
-        validator = v.ValidUsersGroup(edit=True,
+        validator = v.ValidUserGroup(edit=True,
                                     old_data={'users_group_id':
                                               gr2.users_group_id})
 
         self.assertRaises(formencode.Invalid, validator.to_python, 'test')
         self.assertRaises(formencode.Invalid, validator.to_python, 'TesT')
         self.assertRaises(formencode.Invalid, validator.to_python, 'TEST')
-        UsersGroupModel().delete(gr)
-        UsersGroupModel().delete(gr2)
+        UserGroupModel().delete(gr)
+        UserGroupModel().delete(gr2)
         Session.commit()
 
     def test_ValidReposGroup(self):