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

 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
         """
         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' )
     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
         """
@@ @@ -170,184 +176,198 @@ class ApiController( JSONRPCController ) @@
                 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 )
             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,
                                     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
             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

@@ @@ -6,57 +6,58 @@ @@
     repository permission model for RhodeCode
     :created_on: Oct 1, 2011
     :author: nvinot
     :copyright: (C) 2011-2011 Nicolas Vinot <aeris@imirhil.fr>
     :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__)
+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

@@ @@ -15,159 +15,160 @@ @@
 # 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__)
+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

@@ @@ -46,39 +46,44 @@ class UsersGroupModel( BaseModel ): @@
         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

0 comments (0 inline, 0 general)