[API] Create groups needed when creating repo

.hgignore

@@ -1,19 +1,16
 syntax: glob
 *.pyc
 *.swp
-*.ini
-Paste*
 
 syntax: regexp
 ^build
 ^docs/build/
 ^docs/_build/
 ^data$
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^rhodecode\.db$
 ^test\.db$
 ^repositories\.config$
 ^RhodeCode\.egg-info$
-^env$

rhodecode/controllers/api/api.py

@@ -1,353 +1,373
 import traceback
 import logging
 
 from rhodecode.controllers.api import JSONRPCController, JSONRPCError
 from rhodecode.lib.auth import HasPermissionAllDecorator, HasPermissionAnyDecorator
 from rhodecode.model.scm import ScmModel
 
 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__ )
 
 
 class ApiController( JSONRPCController ):
     """
     API Controller
 
 
     Each method needs to have USER as argument this is then based on given
     API_KEY propagated as instance of user object
 
     Preferably this should be first argument also
 
 
     Each function should also **raise** JSONRPCError for any
     errors that happens
 
     """
 
     @HasPermissionAllDecorator( 'hg.admin' )
     def pull( self, apiuser, repo ):
         """
         Dispatch pull action on given repo
 
 
         :param user:
         :param repo:
         """
 
         if Repository.is_valid( repo ) is False:
             raise JSONRPCError( 'Unknown repo "%s"' % repo )
 
         try:
             ScmModel().pull_changes( repo, self.rhodecode_user.username )
             return 'Pulled from %s' % repo
         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
         """
 
+        try:
         user = User.by_username( username )
-        if not user:
+        except NoResultFound:
             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 get_users( self, apiuser ):
         """"
         Get all users
 
         :param apiuser
         """
 
         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 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 = firstname,
                              lastname = lastname,
                              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' % username )
 
     @HasPermissionAllDecorator( 'hg.admin' )
     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:
         """
 
+        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 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.by_username( user_name )
-            if not user:
+            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.by_repo_name( repo_name )
-        if not repo:
+        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 = None, repo_type = 'hg', \
-                    private = False, group_name = None ):
+    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
-        :param group_name
-        :param clone
         """
 
         try:
-            if group_name:
-                group = Group.get_by_group_name( group_name )
-                if group is None:
-                    raise JSONRPCError( 'unknown group %s' % group_name )
-            else:
-                group = None
-
+            try:
             owner = User.by_username( owner_name )
-            if owner is None:
+            except NoResultFound:
                 raise JSONRPCError( 'unknown user %s' % owner )
 
-            RepoModel().create( { "repo_name" : name,
-                                 "repo_name_full" : name,
-                                 "description" : description,
-                                 "private" : private,
-                                 "repo_type" : repo_type,
-                                 "repo_group" : group,
-                                 "clone_uri" : None }, 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.by_repo_name( repo_name )
-            if not repo:
+            except NoResultFound:
                 raise JSONRPCError( 'unknown repository %s' % repo )
 
+            try:
             user = User.by_username( user_name )
-            if not user:
+            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 ) )
 

rhodecode/model/repo_permission.py

@@ -1,62 +1,63
 # -*- 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)
  No newline at end of file
+            self.deleteUserPermission( repository, user )

rhodecode/model/repos_group.py

@@ -1,173 +1,174
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.user_group
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     users groups model for RhodeCode
 
     :created_on: Jan 25, 2011
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[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 os
 import logging
 import traceback
 import shutil
 
 from pylons.i18n.translation import _
 
 from vcs.utils.lazy import LazyProperty
 
 from rhodecode.model import BaseModel
 from rhodecode.model.caching_query import FromCache
 from rhodecode.model.db import Group, RhodeCodeUi
 
 log = logging.getLogger(__name__)
 
 
 class ReposGroupModel(BaseModel):
 
     @LazyProperty
     def repos_path(self):
         """
         Get's the repositories root path from database
         """
 
         q = RhodeCodeUi.get_by_key('/').one()
         return q.ui_value
 
     def __create_group(self, group_name, parent_id):
         """
         makes repositories group on filesystem
 
         :param repo_name:
         :param parent_id:
         """
 
         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, old_parent_id, new, new_parent_id):
         """
         Renames a group on filesystem
         
         :param group_name:
         """
         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 = ''
 
         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)
 
         if os.path.isdir(new_path):
             raise Exception('Was trying to rename to already '
                             'existing dir %s' % new_path)
         shutil.move(old_path, new_path)
 
     def __delete_group(self, group):
         """
         Deletes a group from a filesystem
         
         :param group: instance of group from database
         """
         paths = group.full_path.split(Group.url_sep())
         paths = os.sep.join(paths)
 
         rm_path = os.path.join(self.repos_path, paths)
         os.rmdir(rm_path)
 
     def create(self, form_data):
         try:
             new_repos_group = Group()
             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(form_data['group_name'],
                                 form_data['group_parent_id'])
 
             self.sa.commit()
+            return new_repos_group
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def update(self, repos_group_id, form_data):
 
         try:
             repos_group = Group.get(repos_group_id)
             old_name = repos_group.group_name
             old_parent_id = repos_group.group_parent_id
 
             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)
 
             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()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def delete(self, users_group_id):
         try:
             users_group = Group.get(users_group_id)
             self.sa.delete(users_group)
             self.__delete_group(users_group)
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise

rhodecode/model/users_group.py

@@ -1,84 +1,89
 # -*- 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