kallithea Changeset - 307ec693bdf2

Changeset - 307ec693bdf2

Parent rev.

Child rev.

[Not reviewed]

beta

0 5 0

Nicolas VINOT - 14 years ago 2011-10-07 21:49:28
aeris@imirhil.fr

[API] Create groups needed when creating repo

5 files changed with 122 insertions and 98 deletions:

.hgignore

rhodecode/controllers/api/api.py

rhodecode/model/repo_permission.py

rhodecode/model/repos_group.py

rhodecode/model/users_group.py

0 comments (0 inline, 0 general)

.hgignore

➞

Show inline comments

 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

➞

Show inline comments

@@ @@ -2,24 +2,26 @@ 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
@@ @@ -50,26 +52,27 @@ 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.by_username( username )
         if not user:
         try:
             user = User.by_username( username )
         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' )
@@ @@ -100,24 +103,27 @@ class ApiController( JSONRPCController ) @@
         :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:
@@ @@ -182,24 +188,27 @@ class ApiController( JSONRPCController ) @@
                                 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 ):
@@ @@ -207,47 +216,49 @@ class ApiController( JSONRPCController ) @@
         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 )
             user = User.by_username( user_name )
             if not user:
             try:
                 user = User.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
         """
         repo = Repository.by_repo_name( repo_name )
         if not repo:
         try:
             repo = Repository.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,
@@ @@ -278,76 +289,85 @@ class ApiController( JSONRPCController ) @@
         :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
             owner = User.by_username( owner_name )
             if owner is None:
             try:
                 owner = User.by_username( owner_name )
             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:
             repo = Repository.by_repo_name( repo_name )
             if not repo:
             try:
                 repo = Repository.by_repo_name( repo_name )
             except NoResultFound:
                 raise JSONRPCError( 'unknown repository %s' % repo )
             user = User.by_username( user_name )
             if not user:
             try:
                 user = User.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 ) )

rhodecode/model/repo_permission.py

➞

Show inline comments

@@ @@ -18,45 +18,46 @@ @@
 # 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__)
+log = logging.getLogger( __name__ )
 class RepositoryPermissionModel(BaseModel):
     def getUserPermission(self, repository, user):
 class RepositoryPermissionModel( BaseModel ):
     def getUserPermission( self, repository, user ):
         return RepoToPerm.query() \
                 .filter(RepoToPerm.user == user) \
                 .filter(RepoToPerm.repository == repository) \
                 .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)
     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.add( p )
         Session.commit()
     def deleteUserPermission(self, repository, user):
         current = self.getUserPermission(repository, user)
         Session.delete(current)
         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):
+    def updateOrDeleteUserPermission( self, repository, user, permission ):
         if permission:
             self.updateUserPermission(repository, user, 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

➞

Show inline comments

@@ @@ -27,147 +27,148 @@ 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__)
+log = logging.getLogger( __name__ )
 class ReposGroupModel(BaseModel):
+class ReposGroupModel( BaseModel ):
     @LazyProperty
     def repos_path(self):
+    def repos_path( self ):
         """
         Get's the repositories root path from database
         """
         q = RhodeCodeUi.get_by_key('/').one()
+        q = RhodeCodeUi.get_by_key( '/' ).one()
         return q.ui_value
     def __create_group(self, group_name, parent_id):
+    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)
             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)
         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 !')
         if os.path.isdir( create_path ):
             raise Exception( 'That directory already exists !' )
         os.makedirs(create_path)
+        os.makedirs( create_path )
     def __rename_group(self, old, old_parent_id, new, new_parent_id):
+    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)
+        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)
             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)
             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)
         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)
+        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)
         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):
+    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)
         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)
         rm_path = os.path.join( self.repos_path, paths )
         os.rmdir( rm_path )
     def create(self, form_data):
+    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.sa.add( new_repos_group )
             self.__create_group(form_data['group_name'],
                                 form_data['group_parent_id'])
             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())
+            log.error( traceback.format_exc() )
             self.sa.rollback()
             raise
     def update(self, repos_group_id, form_data):
+    def update( self, repos_group_id, form_data ):
         try:
             repos_group = Group.get(repos_group_id)
+            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)
+            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'])
             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())
+            log.error( traceback.format_exc() )
             self.sa.rollback()
             raise
     def delete(self, users_group_id):
+    def delete( self, users_group_id ):
         try:
             users_group = Group.get(users_group_id)
             self.sa.delete(users_group)
             self.__delete_group(users_group)
             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())
+            log.error( traceback.format_exc() )
             self.sa.rollback()
             raise

rhodecode/model/users_group.py

➞

Show inline comments

@@ @@ -58,24 +58,29 @@ class UsersGroupModel( BaseModel ): @@
             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:

0 comments (0 inline, 0 general)