Merge with upstream

rhodecode/model/repo_permission.py

@@ -0,0 +1,63 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.model.users_group
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    repository permission model for RhodeCode
+
+    :created_on: Oct 1, 2011
+    :author: nvinot
+    :copyright: (C) 2011-2011 Nicolas Vinot <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+from rhodecode.model.db import BaseModel, RepoToPerm, Permission
+from rhodecode.model.meta import Session
+
+log = logging.getLogger( __name__ )
+
+class RepositoryPermissionModel( BaseModel ):
+    def getUserPermission( self, repository, user ):
+        return RepoToPerm.query() \
+                .filter( RepoToPerm.user == user ) \
+                .filter( RepoToPerm.repository == repository ) \
+                .scalar()
+
+    def updateUserPermission( self, repository, user, permission ):
+        permission = Permission.get_by_key( permission )
+        current = self.getUserPermission( repository, user )
+        if current:
+            if not current.permission is permission:
+                current.permission = permission
+        else:
+            p = RepoToPerm()
+            p.user = user
+            p.repository = repository
+            p.permission = permission
+            Session.add( p )
+        Session.commit()
+
+    def deleteUserPermission( self, repository, user ):
+        current = self.getUserPermission( repository, user )
+        if current:
+            Session.delete( current )
+            Session.commit()
+
+    def updateOrDeleteUserPermission( self, repository, user, permission ):
+        if permission:
+            self.updateUserPermission( repository, user, permission )
+        else:
+            self.deleteUserPermission( repository, user )

rhodecode/model/users_group.py

@@ -0,0 +1,89 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.model.users_group
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    users group model for RhodeCode
+
+    :created_on: Oct 1, 2011
+    :author: nvinot
+    :copyright: (C) 2011-2011 Nicolas Vinot <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+import traceback
+
+from rhodecode.model import BaseModel
+from rhodecode.model.caching_query import FromCache
+from rhodecode.model.db import UsersGroupMember, UsersGroup
+
+log = logging.getLogger( __name__ )
+
+class UsersGroupModel( BaseModel ):
+
+    def get( self, users_group_id, cache = False ):
+        users_group = UsersGroup.query()
+        if cache:
+            users_group = users_group.options( FromCache( "sql_cache_short",
+                                          "get_users_group_%s" % users_group_id ) )
+        return users_group.get( users_group_id )
+
+    def get_by_name( self, name, cache = False, case_insensitive = False ):
+        users_group = UsersGroup.query()
+        if case_insensitive:
+            users_group = users_group.filter( UsersGroup.users_group_name.ilike( name ) )
+        else:
+            users_group = users_group.filter( UsersGroup.users_group_name == name )
+        if cache:
+            users_group = users_group.options( FromCache( "sql_cache_short",
+                                          "get_users_group_%s" % name ) )
+        return users_group.scalar()
+
+    def create( self, form_data ):
+        try:
+            new_users_group = UsersGroup()
+            for k, v in form_data.items():
+                setattr( new_users_group, k, v )
+
+            self.sa.add( new_users_group )
+            self.sa.commit()
+            return new_users_group
+        except:
+            log.error( traceback.format_exc() )
+            self.sa.rollback()
+            raise
+
+    def add_user_to_group( self, users_group, user ):
+        for m in users_group.members:
+            u = m.user
+            if u.user_id == user.user_id:
+                return m
+
+        try:
+            users_group_member = UsersGroupMember()
+            users_group_member.user = user
+            users_group_member.users_group = users_group
+
+            users_group.members.append( users_group_member )
+            user.group_member.append( users_group_member )
+
+            self.sa.add( users_group_member )
+            self.sa.commit()
+            return users_group_member
+        except:
+            log.error( traceback.format_exc() )
+            self.sa.rollback()
+            raise

rhodecode/controllers/api/api.py

@@ -2,10 +2,17 b' import traceback'
 import logging
 
 from rhodecode.controllers.api import JSONRPCController, JSONRPCError
-from rhodecode.lib.auth import HasPermissionAllDecorator
+from rhodecode.lib.auth import HasPermissionAllDecorator, HasPermissionAnyDecorator
 from rhodecode.model.scm import ScmModel
 
-from rhodecode.model.db import User, UsersGroup, Repository
+from rhodecode.model.db import User, UsersGroup, Group, Repository
+from rhodecode.model.repo import RepoModel
+from rhodecode.model.user import UserModel
+from rhodecode.model.repo_permission import RepositoryPermissionModel
+from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model import users_group
+from rhodecode.model.repos_group import ReposGroupModel
+from sqlalchemy.orm.exc import NoResultFound
 
 log = logging.getLogger(__name__)
 
@@ -45,54 +52,322 b' class ApiController(JSONRPCController):'
         except Exception:
             raise JSONRPCError('Unable to pull changes from "%s"' % repo)
 
+    @HasPermissionAllDecorator( 'hg.admin' )
+    def get_user( self, apiuser, username ):
+        """"
+        Get a user by username
+
+        :param apiuser
+        :param username
+        """
+
+        user = User.get_by_username( username )
+        if not user:
+            return None
+
+        return dict( id = user.user_id,
+                        username = user.username,
+                        firstname = user.name,
+                        lastname = user.lastname,
+                        email = user.email,
+                        active = user.active,
+                        admin = user.admin,
+                        ldap = user.ldap_dn )
 
     @HasPermissionAllDecorator('hg.admin')
-    def create_user(self, apiuser, username, password, active, admin, name, 
-                    lastname, email):
+    def get_users( self, apiuser ):
+        """"
+        Get all users
+
+        :param apiuser
         """
-        Creates new user
+
+        result = []
+        for user in User.getAll():
+            result.append( dict( id = user.user_id,
+                                username = user.username,
+                                firstname = user.name,
+                                lastname = user.lastname,
+                                email = user.email,
+                                active = user.active,
+                                admin = user.admin,
+                                ldap = user.ldap_dn ) )
+        return result
+
+    @HasPermissionAllDecorator( 'hg.admin' )
+    def create_user( self, apiuser, username, password, firstname,
+                    lastname, email, active = True, admin = False, ldap_dn = None ):
+        """
+        Create new user
         
         :param apiuser:
         :param username:
         :param password:
-        :param active:
-        :param admin:
         :param name:
         :param lastname:
         :param email:
+        :param active:
+        :param admin:
+        :param ldap_dn:
         """
         
+        if self.get_user( apiuser, username ):
+            raise JSONRPCError( "user %s already exist" % username )
+
+        try:
         form_data = dict(username=username,
                          password=password,
                          active=active,
                          admin=admin,
-                         name=name,
+                             name = firstname,
                          lastname=lastname,
-                         email=email)
-        try:
-            u = User.create(form_data)
-            return {'id':u.user_id,
-                    'msg':'created new user %s' % name}
+                             email = email,
+                             ldap_dn = ldap_dn )
+            UserModel().create_ldap( username, password, ldap_dn, form_data )
+            return dict( msg = 'created new user %s' % username )
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to create user %s' % name)
-
+            raise JSONRPCError( 'failed to create user %s' % username )
 
     @HasPermissionAllDecorator('hg.admin')
-    def create_users_group(self, apiuser, name, active):
+    def get_users_group( self, apiuser, group_name ):
+        """"
+        Get users group by name
+
+        :param apiuser
+        :param group_name
+        """
+
+        users_group = UsersGroup.get_by_group_name( group_name )
+        if not users_group:
+            return None
+
+        members = []
+        for user in users_group.members:
+            user = user.user
+            members.append( dict( id = user.user_id,
+                            username = user.username,
+                            firstname = user.name,
+                            lastname = user.lastname,
+                            email = user.email,
+                            active = user.active,
+                            admin = user.admin,
+                            ldap = user.ldap_dn ) )
+
+        return dict( id = users_group.users_group_id,
+                    name = users_group.users_group_name,
+                    active = users_group.users_group_active,
+                    members = members )
+
+    @HasPermissionAllDecorator( 'hg.admin' )
+    def get_users_groups( self, apiuser ):
+        """"
+        Get all users groups
+
+        :param apiuser
+        """
+
+        result = []
+        for users_group in UsersGroup.getAll():
+            members = []
+            for user in users_group.members:
+                user = user.user
+                members.append( dict( id = user.user_id,
+                                username = user.username,
+                                firstname = user.name,
+                                lastname = user.lastname,
+                                email = user.email,
+                                active = user.active,
+                                admin = user.admin,
+                                ldap = user.ldap_dn ) )
+
+            result.append( dict( id = users_group.users_group_id,
+                                name = users_group.users_group_name,
+                                active = users_group.users_group_active,
+                                members = members ) )
+        return result
+
+    @HasPermissionAllDecorator( 'hg.admin' )
+    def create_users_group( self, apiuser, name, active = True ):
         """
         Creates an new usergroup
         
         :param name:
         :param active:
         """
-        form_data = {'users_group_name':name,
-                     'users_group_active':active}
+
+        if self.get_users_group( apiuser, name ):
+            raise JSONRPCError( "users group %s already exist" % name )
+
         try:
+            form_data = dict( users_group_name = name,
+                             users_group_active = active )
             ug = UsersGroup.create(form_data)
-            return {'id':ug.users_group_id,
-                    'msg':'created new users group %s' % name}
+            return dict( id = ug.users_group_id,
+                        msg = 'created new users group %s' % name )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create group %s' % name)
+
+    @HasPermissionAllDecorator( 'hg.admin' )
+    def add_user_to_users_group( self, apiuser, group_name, user_name ):
+        """"
+        Add a user to a group
+
+        :param apiuser
+        :param group_name
+        :param user_name
+        """
+
+        try:
+            users_group = UsersGroup.get_by_group_name( group_name )
+            if not users_group:
+                raise JSONRPCError( 'unknown users group %s' % group_name )
+
+            try:
+                user = User.get_by_username( user_name )
+            except NoResultFound:
+                raise JSONRPCError( 'unknown user %s' % user_name )
+
+            ugm = UsersGroupModel().add_user_to_group( users_group, user )
+
+            return dict( id = ugm.users_group_member_id,
+                        msg = 'created new users group member' )
+        except Exception:
+            log.error( traceback.format_exc() )
+            raise JSONRPCError( 'failed to create users group member' )
+
+    @HasPermissionAnyDecorator( 'hg.admin' )
+    def get_repo( self, apiuser, repo_name ):
+        """"
+        Get repository by name
+
+        :param apiuser
+        :param repo_name
+        """
+
+        try:
+            repo = Repository.get_by_repo_name( repo_name )
+        except NoResultFound:
+            return None
+
+        members = []
+        for user in repo.repo_to_perm:
+            perm = user.permission.permission_name
+            user = user.user
+            members.append( dict( type_ = "user",
+                                    id = user.user_id,
+                                    username = user.username,
+                                    firstname = user.name,
+                                    lastname = user.lastname,
+                                    email = user.email,
+                                    active = user.active,
+                                    admin = user.admin,
+                                    ldap = user.ldap_dn,
+                                    permission = perm ) )
+        for users_group in repo.users_group_to_perm:
+            perm = users_group.permission.permission_name
+            users_group = users_group.users_group
+            members.append( dict( type_ = "users_group",
+                                    id = users_group.users_group_id,
+                                    name = users_group.users_group_name,
+                                    active = users_group.users_group_active,
+                                    permission = perm ) )
+
+        return dict( id = repo.repo_id,
+                    name = repo.repo_name,
+                    type = repo.repo_type,
+                    description = repo.description,
+                    members = members )
+
+    @HasPermissionAnyDecorator( 'hg.admin' )
+    def get_repos( self, apiuser ):
+        """"
+        Get all repositories
+
+        :param apiuser
+        """
+
+        result = []
+        for repository in Repository.getAll():
+            result.append( dict( id = repository.repo_id,
+                                name = repository.repo_name,
+                                type = repository.repo_type,
+                                description = repository.description ) )
+        return result
+
+    @HasPermissionAnyDecorator( 'hg.admin', 'hg.create.repository' )
+    def create_repo( self, apiuser, name, owner_name, description = '', repo_type = 'hg', \
+                    private = False ):
+        """
+        Create a repository
+
+        :param apiuser
+        :param name
+        :param description
+        :param type
+        :param private
+        :param owner_name
+        """
+
+        try:
+            try:
+                owner = User.get_by_username( owner_name )
+            except NoResultFound:
+                raise JSONRPCError( 'unknown user %s' % owner )
+
+            if self.get_repo( apiuser, name ):
+                raise JSONRPCError( "repo %s already exist" % name )
+
+            groups = name.split( '/' )
+            real_name = groups[-1]
+            groups = groups[:-1]
+            parent_id = None
+            for g in groups:
+                group = Group.get_by_group_name( g )
+                if not group:
+                    group = ReposGroupModel().create( dict( group_name = g,
+                                                  group_description = '',
+                                                  group_parent_id = parent_id ) )
+                parent_id = group.group_id
+
+            RepoModel().create( dict( repo_name = real_name,
+                                     repo_name_full = name,
+                                     description = description,
+                                     private = private,
+                                     repo_type = repo_type,
+                                     repo_group = parent_id,
+                                     clone_uri = None ), owner )
+        except Exception:
+            log.error( traceback.format_exc() )
+            raise JSONRPCError( 'failed to create repository %s' % name )
+
+    @HasPermissionAnyDecorator( 'hg.admin' )
+    def add_user_to_repo( self, apiuser, repo_name, user_name, perm ):
+        """
+        Add permission for a user to a repository
+
+        :param apiuser
+        :param repo_name
+        :param user_name
+        :param perm
+        """
+
+        try:
+            try:
+                repo = Repository.get_by_repo_name( repo_name )
+            except NoResultFound:
+                raise JSONRPCError( 'unknown repository %s' % repo )
+
+            try:
+                user = User.get_by_username( user_name )
+            except NoResultFound:
+                raise JSONRPCError( 'unknown user %s' % user )
+
+            RepositoryPermissionModel().updateOrDeleteUserPermission( repo, user, perm )
+        except Exception:
+            log.error( traceback.format_exc() )
+            raise JSONRPCError( 'failed to edit permission %(repo)s for %(user)s'
+                            % dict( user = user_name, repo = repo_name ) )
+
         
  No newline at end of file

rhodecode/model/db.py

@@ -128,12 +128,15 b' class BaseModel(object):'
 
     @classmethod
     def get(cls, id_):
-        if id_:
-            return Session.query(cls).get(id_)
+        return cls.query().get( id_ )
+
+    @classmethod
+    def getAll( cls ):
+        return cls.query().all()
 
     @classmethod
     def delete(cls, id_):
-        obj = Session.query(cls).get(id_)
+        obj = cls.query().get( id_ )
         Session.delete(obj)
         Session.commit()
 
@@ -178,13 +181,13 b' class RhodeCodeSettings(Base, BaseModel)'
 
     @classmethod
     def get_by_name(cls, ldap_key):
-        return Session.query(cls)\
+        return cls.query()\
             .filter(cls.app_settings_name == ldap_key).scalar()
 
     @classmethod
     def get_app_settings(cls, cache=False):
 
-        ret = Session.query(cls)
+        ret = cls.query()
 
         if cache:
             ret = ret.options(FromCache("sql_cache_short", "get_hg_settings"))
@@ -200,7 +203,7 b' class RhodeCodeSettings(Base, BaseModel)'
 
     @classmethod
     def get_ldap_settings(cls, cache=False):
-        ret = Session.query(cls)\
+        ret = cls.query()\
                 .filter(cls.app_settings_name.startswith('ldap_')).all()
         fd = {}
         for row in ret:
@@ -227,7 +230,7 b' class RhodeCodeUi(Base, BaseModel):'
 
     @classmethod
     def get_by_key(cls, key):
-        return Session.query(cls).filter(cls.ui_key == key)
+        return cls.query().filter( cls.ui_key == key )
 
 
     @classmethod
@@ -311,7 +314,7 b' class User(Base, BaseModel):'
 
     @classmethod
     def get_by_api_key(cls, api_key):
-        return Session.query(cls).filter(cls.api_key == api_key).one()
+        return cls.query().filter( cls.api_key == api_key ).one()
 
     def update_lastlogin(self):
         """Update user lastlogin"""
@@ -376,11 +379,11 b' class UsersGroup(Base, BaseModel):'
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
-            gr = Session.query(cls)\
+            gr = cls.query()\
             .filter(cls.users_group_name.ilike(group_name))
         else:
-            gr = Session.query(UsersGroup)\
-                .filter(UsersGroup.users_group_name == group_name)
+            gr = cls.query()\
+                .filter( cls.users_group_name == group_name )
         if cache:
             gr = gr.options(FromCache("sql_cache_short",
                                           "get_user_%s" % group_name))
@@ -389,7 +392,7 b' class UsersGroup(Base, BaseModel):'
 
     @classmethod
     def get(cls, users_group_id, cache=False):
-        users_group = Session.query(cls)
+        users_group = cls.query()
         if cache:
             users_group = users_group.options(FromCache("sql_cache_short",
                                     "get_users_group_%s" % users_group_id))
@@ -456,7 +459,6 b' class UsersGroup(Base, BaseModel):'
             Session.rollback()
             raise
 
-
 class UsersGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = {'extend_existing':True}
@@ -472,6 +474,15 b' class UsersGroupMember(Base, BaseModel):'
         self.users_group_id = gr_id
         self.user_id = u_id
 
+    @staticmethod
+    def add_user_to_group( group, user ):
+        ugm = UsersGroupMember()
+        ugm.users_group = group
+        ugm.user = user
+        Session.add( ugm )
+        Session.commit()
+        return ugm
+
 class Repository(Base, BaseModel):
     __tablename__ = 'repositories'
     __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)
@@ -513,16 +524,14 b' class Repository(Base, BaseModel):'
     @classmethod
     def get_by_repo_name(cls, repo_name):
         q = Session.query(cls).filter(cls.repo_name == repo_name)
-
         q = q.options(joinedload(Repository.fork))\
                 .options(joinedload(Repository.user))\
-                .options(joinedload(Repository.group))\
-
+                .options( joinedload( Repository.group ) )
         return q.one()
 
     @classmethod
     def get_repo_forks(cls, repo_id):
-        return Session.query(cls).filter(Repository.fork_id == repo_id)
+        return cls.query().filter( Repository.fork_id == repo_id )
 
     @classmethod
     def base_path(cls):
@@ -605,7 +614,7 b' class Repository(Base, BaseModel):'
         baseui._tcfg = config.config()
 
 
-        ret = Session.query(RhodeCodeUi)\
+        ret = RhodeCodeUi.query()\
             .options(FromCache("sql_cache_short", "repository_repo_ui")).all()
 
         hg_ui = ret
@@ -660,7 +669,7 b' class Repository(Base, BaseModel):'
         None otherwise. `cache_active = False` means that this cache
         state is not valid and needs to be invalidated
         """
-        return Session.query(CacheInvalidation)\
+        return CacheInvalidation.query()\
             .filter(CacheInvalidation.cache_key == self.repo_name)\
             .filter(CacheInvalidation.cache_active == False)\
             .scalar()
@@ -669,7 +678,7 b' class Repository(Base, BaseModel):'
         """
         set a cache for invalidation for this instance
         """
-        inv = Session.query(CacheInvalidation)\
+        inv = CacheInvalidation.query()\
             .filter(CacheInvalidation.cache_key == self.repo_name)\
             .scalar()
 
@@ -771,8 +780,17 b' class Group(Base, BaseModel):'
         return '/'
 
     @classmethod
-    def get_by_group_name(cls, group_name):
-        return cls.query().filter(cls.group_name == group_name).scalar()
+    def get_by_group_name( cls, group_name, cache = False, case_insensitive = False ):
+        if case_insensitive:
+            gr = cls.query()\
+                .filter( cls.group_name.ilike( group_name ) )
+        else:
+            gr = cls.query()\
+                .filter( cls.group_name == group_name )
+        if cache:
+            gr = gr.options( FromCache( "sql_cache_short",
+                                          "get_group_%s" % group_name ) )
+        return gr.scalar()
 
     @property
     def parents(self):
@@ -800,7 +818,7 b' class Group(Base, BaseModel):'
 
     @property
     def children(self):
-        return Session.query(Group).filter(Group.parent_group == self)
+        return Group.query().filter( Group.parent_group == self )
 
     @property
     def name(self):
@@ -808,7 +826,8 b' class Group(Base, BaseModel):'
 
     @property
     def full_path(self):
-        return self.group_name
+        return Group.url_sep().join( [g.group_name for g in self.parents] +
+                        [self.group_name] )
 
     @property
     def full_path_splitted(self):
@@ -816,7 +835,7 b' class Group(Base, BaseModel):'
 
     @property
     def repositories(self):
-        return Session.query(Repository).filter(Repository.group == self)
+        return Repository.query().filter( Repository.group == self )
 
     @property
     def repositories_recursive_count(self):
@@ -855,7 +874,7 b' class Permission(Base, BaseModel):'
 
     @classmethod
     def get_by_key(cls, key):
-        return Session.query(cls).filter(cls.permission_name == key).scalar()
+        return cls.query().filter( cls.permission_name == key ).scalar()
 
 class RepoToPerm(Base, BaseModel):
     __tablename__ = 'repo_to_perm'
@@ -884,7 +903,7 b' class UserToPerm(Base, BaseModel):'
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
-        return Session.query(cls).filter(cls.user_id == user_id)\
+        return cls.query().filter( cls.user_id == user_id )\
             .filter(cls.permission == perm).scalar() is not None
 
     @classmethod
@@ -908,7 +927,7 b' class UserToPerm(Base, BaseModel):'
             raise Exception('perm needs to be an instance of Permission class')
 
         try:
-            Session.query(cls).filter(cls.user_id == user_id)\
+            cls.query().filter( cls.user_id == user_id )\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
@@ -944,7 +963,7 b' class UsersGroupToPerm(Base, BaseModel):'
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
-        return Session.query(cls).filter(cls.users_group_id ==
+        return cls.query().filter( cls.users_group_id ==
                                          users_group_id)\
                                          .filter(cls.permission == perm)\
                                          .scalar() is not None
@@ -970,7 +989,7 b' class UsersGroupToPerm(Base, BaseModel):'
             raise Exception('perm needs to be an instance of Permission class')
 
         try:
-            Session.query(cls).filter(cls.users_group_id == users_group_id)\
+            cls.query().filter( cls.users_group_id == users_group_id )\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
@@ -1022,7 +1041,7 b' class UserFollowing(Base, BaseModel):'
 
     @classmethod
     def get_repo_followers(cls, repo_id):
-        return Session.query(cls).filter(cls.follows_repo_id == repo_id)
+        return cls.query().filter( cls.follows_repo_id == repo_id )
 
 class CacheInvalidation(Base, BaseModel):
     __tablename__ = 'cache_invalidation'

rhodecode/model/repos_group.py

@@ -50,7 +50,7 b' class ReposGroupModel(BaseModel):'
         q = RhodeCodeUi.get_by_key('/').one()
         return q.ui_value
 
-    def __create_group(self, group_name):
+    def __create_group( self, group_name, parent_id ):
         """
         makes repositories group on filesystem
 
@@ -58,30 +58,44 b' class ReposGroupModel(BaseModel):'
         :param parent_id:
         """
 
-        create_path = os.path.join(self.repos_path, group_name)
+        if parent_id:
+            paths = Group.get( parent_id ).full_path.split( Group.url_sep() )
+            parent_path = os.sep.join( paths )
+        else:
+            parent_path = ''
+
+        create_path = os.path.join( self.repos_path, parent_path, group_name )
         log.debug('creating new group in %s', create_path)
 
         if os.path.isdir(create_path):
             raise Exception('That directory already exists !')
 
+
         os.makedirs(create_path)
 
-    def __rename_group(self, old, new):
+
+    def __rename_group( self, old, old_parent_id, new, new_parent_id ):
         """
         Renames a group on filesystem
         
         :param group_name:
         """
-
-        if old == new:
-            log.debug('skipping group rename')
-            return
-
         log.debug('renaming repos group from %s to %s', old, new)
 
+        if new_parent_id:
+            paths = Group.get( new_parent_id ).full_path.split( Group.url_sep() )
+            new_parent_path = os.sep.join( paths )
+        else:
+            new_parent_path = ''
 
-        old_path = os.path.join(self.repos_path, old)
-        new_path = os.path.join(self.repos_path, new)
+        if old_parent_id:
+            paths = Group.get( old_parent_id ).full_path.split( Group.url_sep() )
+            old_parent_path = os.sep.join( paths )
+        else:
+            old_parent_path = ''
+
+        old_path = os.path.join( self.repos_path, old_parent_path, old )
+        new_path = os.path.join( self.repos_path, new_parent_path, new )
 
         log.debug('renaming repos paths from %s to %s', old_path, new_path)
 
@@ -100,20 +114,20 b' class ReposGroupModel(BaseModel):'
         paths = os.sep.join(paths)
 
         rm_path = os.path.join(self.repos_path, paths)
-        if os.path.isdir(rm_path):
-            # delete only if that path really exists
             os.rmdir(rm_path)
 
     def create(self, form_data):
         try:
             new_repos_group = Group()
-            new_repos_group.group_description = form_data['group_description']
-            new_repos_group.parent_group = Group.get(form_data['group_parent_id'])
-            new_repos_group.group_name = new_repos_group.get_new_name(form_data['group_name'])
+            new_repos_group.group_name = form_data['group_name']
+            new_repos_group.group_description = \
+                form_data['group_description']
+            new_repos_group.group_parent_id = form_data['group_parent_id']
 
             self.sa.add(new_repos_group)
 
-            self.__create_group(new_repos_group.group_name)
+            self.__create_group( form_data['group_name'],
+                                form_data['group_parent_id'] )
 
             self.sa.commit()
             return new_repos_group
@@ -126,27 +140,23 b' class ReposGroupModel(BaseModel):'
 
         try:
             repos_group = Group.get(repos_group_id)
-            old_path = repos_group.full_path
+            old_name = repos_group.group_name
+            old_parent_id = repos_group.group_parent_id
 
-            #change properties
-            repos_group.group_description = form_data['group_description']
-            repos_group.parent_group = Group.get(form_data['group_parent_id'])
-            repos_group.group_name = repos_group.get_new_name(form_data['group_name'])
-
-            new_path = repos_group.full_path
+            repos_group.group_name = form_data['group_name']
+            repos_group.group_description = \
+                form_data['group_description']
+            repos_group.group_parent_id = form_data['group_parent_id']
 
             self.sa.add(repos_group)
 
-            self.__rename_group(old_path, new_path)
-
-            # we need to get all repositories from this new group and 
-            # rename them accordingly to new group path
-            for r in repos_group.repositories:
-                r.repo_name = r.get_new_name(r.just_name)
-                self.sa.add(r)
+            if old_name != form_data['group_name'] or ( old_parent_id !=
+                                                form_data['group_parent_id'] ):
+                self.__rename_group( old = old_name, old_parent_id = old_parent_id,
+                                    new = form_data['group_name'],
+                                    new_parent_id = form_data['group_parent_id'] )
 
             self.sa.commit()
-            return repos_group
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()

rhodecode/model/user.py

@@ -49,7 +49,6 b" PERM_WEIGHTS = {'repository.none': 0,"
 
 
 class UserModel(BaseModel):
-
     def get(self, user_id, cache=False):
         user = self.sa.query(User)
         if cache:
@@ -87,6 +86,7 b' class UserModel(BaseModel):'
             new_user.api_key = generate_api_key(form_data['username'])
             self.sa.add(new_user)
             self.sa.commit()
+            return new_user
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()