Mercurial > kallithea
changeset 1591:0b63a0d2cede beta
Merge with upstream
| author | Nicolas VINOT <aeris@imirhil.fr> |
|---|---|
| date | Wed, 19 Oct 2011 01:47:56 +0200 |
| parents | 2c08b6929b1c (current diff) 10d117545a7e (diff) |
| children | 8628c8706bf8 |
| files | rhodecode/controllers/api/api.py rhodecode/model/db.py rhodecode/model/repos_group.py |
| diffstat | 6 files changed, 1012 insertions(+), 557 deletions(-) [+] |
line wrap: on
line diff
--- a/rhodecode/controllers/api/api.py Mon Oct 17 15:48:19 2011 +0200 +++ b/rhodecode/controllers/api/api.py Wed Oct 19 01:47:56 2011 +0200 @@ -2,97 +2,371 @@ 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__) +log = logging.getLogger( __name__ ) -class ApiController(JSONRPCController): +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 + + + Each function should also **raise** JSONRPCError for any errors that happens - + """ - @HasPermissionAllDecorator('hg.admin') - def pull(self, apiuser, repo): + @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) - + if Repository.is_valid( repo ) is False: + raise JSONRPCError( 'Unknown repo "%s"' % repo ) + try: - ScmModel().pull_changes(repo, self.rhodecode_user.username) + ScmModel().pull_changes( repo, self.rhodecode_user.username ) return 'Pulled from %s' % repo except Exception: - raise JSONRPCError('Unable to pull changes from "%s"' % repo) + 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): + @HasPermissionAllDecorator( 'hg.admin' ) + 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: """ - - form_data = dict(username=username, - password=password, - active=active, - admin=admin, - name=name, - lastname=lastname, - email=email) + + if self.get_user( apiuser, username ): + raise JSONRPCError( "user %s already exist" % username ) + try: - u = User.create(form_data) - return {'id':u.user_id, - 'msg':'created new user %s' % name} + 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' % name) + 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 create_users_group(self, apiuser, name, active): + @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 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: - ug = UsersGroup.create(form_data) - return {'id':ug.users_group_id, - 'msg':'created new users group %s' % name} + 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 group %s' % name) - \ No newline at end of file + 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 ) ) +
--- a/rhodecode/model/db.py Mon Oct 17 15:48:19 2011 +0200 +++ b/rhodecode/model/db.py Wed Oct 19 01:47:56 2011 +0200 @@ -51,146 +51,149 @@ from rhodecode.model.caching_query import FromCache -log = logging.getLogger(__name__) +log = logging.getLogger( __name__ ) #============================================================================== # BASE CLASSES #============================================================================== -class ModelSerializer(json.JSONEncoder): +class ModelSerializer( json.JSONEncoder ): """ Simple Serializer for JSON, - + usage:: - + to make object customized for serialization implement a __json__ method that will return a dict for serialization into json - + example:: - + class Task(object): - + def __init__(self, name, value): self.name = name self.value = value - + def __json__(self): return dict(name=self.name, - value=self.value) - + value=self.value) + """ - def default(self, obj): + def default( self, obj ): - if hasattr(obj, '__json__'): + if hasattr( obj, '__json__' ): return obj.__json__() else: - return json.JSONEncoder.default(self, obj) + return json.JSONEncoder.default( self, obj ) -class BaseModel(object): +class BaseModel( object ): """Base Model for all classess """ @classmethod - def _get_keys(cls): + def _get_keys( cls ): """return column names for this model """ - return class_mapper(cls).c.keys() + return class_mapper( cls ).c.keys() - def get_dict(self): + def get_dict( self ): """return dict with keys and values corresponding to this model data """ d = {} for k in self._get_keys(): - d[k] = getattr(self, k) + d[k] = getattr( self, k ) return d - def get_appstruct(self): + def get_appstruct( self ): """return list with keys and values tupples corresponding to this model data """ l = [] for k in self._get_keys(): - l.append((k, getattr(self, k),)) + l.append( ( k, getattr( self, k ), ) ) return l - def populate_obj(self, populate_dict): + def populate_obj( self, populate_dict ): """populate model with data from given populate_dict""" for k in self._get_keys(): if k in populate_dict: - setattr(self, k, populate_dict[k]) + setattr( self, k, populate_dict[k] ) @classmethod - def query(cls): - return Session.query(cls) + def query( cls ): + return Session.query( cls ) @classmethod - def get(cls, id_): - if id_: - return Session.query(cls).get(id_) + def get( cls, id_ ): + return cls.query().get( id_ ) @classmethod - def delete(cls, id_): - obj = Session.query(cls).get(id_) - Session.delete(obj) + def getAll( cls ): + return cls.query().all() + + @classmethod + def delete( cls, id_ ): + obj = cls.query().get( id_ ) + Session.delete( obj ) Session.commit() -class RhodeCodeSettings(Base, BaseModel): +class RhodeCodeSettings( Base, BaseModel ): __tablename__ = 'rhodecode_settings' - __table_args__ = (UniqueConstraint('app_settings_name'), {'extend_existing':True}) - app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - app_settings_name = Column("app_settings_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - _app_settings_value = Column("app_settings_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + __table_args__ = ( UniqueConstraint( 'app_settings_name' ), {'extend_existing':True} ) + app_settings_id = Column( "app_settings_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + app_settings_name = Column( "app_settings_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + _app_settings_value = Column( "app_settings_value", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) - def __init__(self, k='', v=''): + def __init__( self, k = '', v = '' ): self.app_settings_name = k self.app_settings_value = v - @validates('_app_settings_value') - def validate_settings_value(self, key, val): - assert type(val) == unicode + @validates( '_app_settings_value' ) + def validate_settings_value( self, key, val ): + assert type( val ) == unicode return val @hybrid_property - def app_settings_value(self): + def app_settings_value( self ): v = self._app_settings_value if v == 'ldap_active': - v = str2bool(v) - return v + v = str2bool( v ) + return v @app_settings_value.setter - def app_settings_value(self,val): + def app_settings_value( self, val ): """ Setter that will always make sure we use unicode in app_settings_value - + :param val: """ - self._app_settings_value = safe_unicode(val) + self._app_settings_value = safe_unicode( val ) - def __repr__(self): - return "<%s('%s:%s')>" % (self.__class__.__name__, - self.app_settings_name, self.app_settings_value) + def __repr__( self ): + return "<%s('%s:%s')>" % ( self.__class__.__name__, + self.app_settings_name, self.app_settings_value ) @classmethod - def get_by_name(cls, ldap_key): - return Session.query(cls)\ - .filter(cls.app_settings_name == ldap_key).scalar() + def get_by_name( cls, ldap_key ): + return cls.query()\ + .filter( cls.app_settings_name == ldap_key ).scalar() @classmethod - def get_app_settings(cls, cache=False): + 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")) + ret = ret.options( FromCache( "sql_cache_short", "get_hg_settings" ) ) if not ret: - raise Exception('Could not get application settings !') + raise Exception( 'Could not get application settings !' ) settings = {} for each in ret: settings['rhodecode_' + each.app_settings_name] = \ @@ -199,222 +202,222 @@ return settings @classmethod - def get_ldap_settings(cls, cache=False): - ret = Session.query(cls)\ - .filter(cls.app_settings_name.startswith('ldap_')).all() + def get_ldap_settings( cls, cache = False ): + ret = cls.query()\ + .filter( cls.app_settings_name.startswith( 'ldap_' ) ).all() fd = {} for row in ret: - fd.update({row.app_settings_name:row.app_settings_value}) + fd.update( {row.app_settings_name:row.app_settings_value} ) return fd -class RhodeCodeUi(Base, BaseModel): +class RhodeCodeUi( Base, BaseModel ): __tablename__ = 'rhodecode_ui' - __table_args__ = (UniqueConstraint('ui_key'), {'extend_existing':True}) + __table_args__ = ( UniqueConstraint( 'ui_key' ), {'extend_existing':True} ) HOOK_UPDATE = 'changegroup.update' HOOK_REPO_SIZE = 'changegroup.repo_size' HOOK_PUSH = 'pretxnchangegroup.push_logger' HOOK_PULL = 'preoutgoing.pull_logger' - ui_id = Column("ui_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - ui_section = Column("ui_section", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - ui_key = Column("ui_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - ui_value = Column("ui_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True) + ui_id = Column( "ui_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + ui_section = Column( "ui_section", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + ui_key = Column( "ui_key", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + ui_value = Column( "ui_value", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + ui_active = Column( "ui_active", Boolean(), nullable = True, unique = None, default = True ) @classmethod - def get_by_key(cls, key): - return Session.query(cls).filter(cls.ui_key == key) + def get_by_key( cls, key ): + return cls.query().filter( cls.ui_key == key ) @classmethod - def get_builtin_hooks(cls): + def get_builtin_hooks( cls ): q = cls.query() - q = q.filter(cls.ui_key.in_([cls.HOOK_UPDATE, + q = q.filter( cls.ui_key.in_( [cls.HOOK_UPDATE, cls.HOOK_REPO_SIZE, - cls.HOOK_PUSH, cls.HOOK_PULL])) + cls.HOOK_PUSH, cls.HOOK_PULL] ) ) return q.all() @classmethod - def get_custom_hooks(cls): + def get_custom_hooks( cls ): q = cls.query() - q = q.filter(~cls.ui_key.in_([cls.HOOK_UPDATE, + q = q.filter( ~cls.ui_key.in_( [cls.HOOK_UPDATE, cls.HOOK_REPO_SIZE, - cls.HOOK_PUSH, cls.HOOK_PULL])) - q = q.filter(cls.ui_section == 'hooks') + cls.HOOK_PUSH, cls.HOOK_PULL] ) ) + q = q.filter( cls.ui_section == 'hooks' ) return q.all() @classmethod - def create_or_update_hook(cls, key, val): - new_ui = cls.get_by_key(key).scalar() or cls() + def create_or_update_hook( cls, key, val ): + new_ui = cls.get_by_key( key ).scalar() or cls() new_ui.ui_section = 'hooks' new_ui.ui_active = True new_ui.ui_key = key new_ui.ui_value = val - Session.add(new_ui) + Session.add( new_ui ) Session.commit() -class User(Base, BaseModel): +class User( Base, BaseModel ): __tablename__ = 'users' - __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'extend_existing':True}) - user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - username = Column("username", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - active = Column("active", Boolean(), nullable=True, unique=None, default=None) - admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) - name = Column("name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) - ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + __table_args__ = ( UniqueConstraint( 'username' ), UniqueConstraint( 'email' ), {'extend_existing':True} ) + user_id = Column( "user_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + username = Column( "username", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + password = Column( "password", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + active = Column( "active", Boolean(), nullable = True, unique = None, default = None ) + admin = Column( "admin", Boolean(), nullable = True, unique = None, default = False ) + name = Column( "name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + lastname = Column( "lastname", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + email = Column( "email", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + last_login = Column( "last_login", DateTime( timezone = False ), nullable = True, unique = None, default = None ) + ldap_dn = Column( "ldap_dn", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + api_key = Column( "api_key", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) - user_log = relationship('UserLog', cascade='all') - user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all') + user_log = relationship( 'UserLog', cascade = 'all' ) + user_perms = relationship( 'UserToPerm', primaryjoin = "User.user_id==UserToPerm.user_id", cascade = 'all' ) - repositories = relationship('Repository') - user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all') - repo_to_perm = relationship('RepoToPerm', primaryjoin='RepoToPerm.user_id==User.user_id', cascade='all') + repositories = relationship( 'Repository' ) + user_followers = relationship( 'UserFollowing', primaryjoin = 'UserFollowing.follows_user_id==User.user_id', cascade = 'all' ) + repo_to_perm = relationship( 'RepoToPerm', primaryjoin = 'RepoToPerm.user_id==User.user_id', cascade = 'all' ) - group_member = relationship('UsersGroupMember', cascade='all') + group_member = relationship( 'UsersGroupMember', cascade = 'all' ) @property - def full_contact(self): - return '%s %s <%s>' % (self.name, self.lastname, self.email) + def full_contact( self ): + return '%s %s <%s>' % ( self.name, self.lastname, self.email ) @property - def short_contact(self): - return '%s %s' % (self.name, self.lastname) + def short_contact( self ): + return '%s %s' % ( self.name, self.lastname ) @property - def is_admin(self): + def is_admin( self ): return self.admin - def __repr__(self): + def __repr__( self ): try: - return "<%s('id:%s:%s')>" % (self.__class__.__name__, - self.user_id, self.username) + return "<%s('id:%s:%s')>" % ( self.__class__.__name__, + self.user_id, self.username ) except: return self.__class__.__name__ @classmethod - def get_by_username(cls, username, case_insensitive=False): + def get_by_username( cls, username, case_insensitive = False ): if case_insensitive: - return Session.query(cls).filter(cls.username.ilike(username)).scalar() + return Session.query( cls ).filter( cls.username.ilike( username ) ).scalar() else: - return Session.query(cls).filter(cls.username == username).scalar() + return Session.query( cls ).filter( cls.username == username ).scalar() @classmethod - def get_by_api_key(cls, api_key): - return Session.query(cls).filter(cls.api_key == api_key).one() + def get_by_api_key( cls, api_key ): + return cls.query().filter( cls.api_key == api_key ).one() - def update_lastlogin(self): + def update_lastlogin( self ): """Update user lastlogin""" self.last_login = datetime.datetime.now() - Session.add(self) + Session.add( self ) Session.commit() - log.debug('updated user %s lastlogin', self.username) + log.debug( 'updated user %s lastlogin', self.username ) @classmethod - def create(cls, form_data): + def create( cls, form_data ): from rhodecode.lib.auth import get_crypt_password try: new_user = cls() for k, v in form_data.items(): if k == 'password': - v = get_crypt_password(v) - setattr(new_user, k, v) + v = get_crypt_password( v ) + setattr( new_user, k, v ) - new_user.api_key = generate_api_key(form_data['username']) - Session.add(new_user) + new_user.api_key = generate_api_key( form_data['username'] ) + Session.add( new_user ) Session.commit() return new_user except: - log.error(traceback.format_exc()) + log.error( traceback.format_exc() ) Session.rollback() raise -class UserLog(Base, BaseModel): +class UserLog( Base, BaseModel ): __tablename__ = 'user_logs' __table_args__ = {'extend_existing':True} - user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) - repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) + user_log_id = Column( "user_log_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) + repository_id = Column( "repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = False, unique = None, default = None ) + repository_name = Column( "repository_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + user_ip = Column( "user_ip", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + action = Column( "action", UnicodeText( length = 1200000, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + action_date = Column( "action_date", DateTime( timezone = False ), nullable = True, unique = None, default = None ) @property - def action_as_day(self): - return date(*self.action_date.timetuple()[:3]) + def action_as_day( self ): + return date( *self.action_date.timetuple()[:3] ) - user = relationship('User') - repository = relationship('Repository') + user = relationship( 'User' ) + repository = relationship( 'Repository' ) -class UsersGroup(Base, BaseModel): +class UsersGroup( Base, BaseModel ): __tablename__ = 'users_groups' __table_args__ = {'extend_existing':True} - users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) - users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) + users_group_id = Column( "users_group_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + users_group_name = Column( "users_group_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = True, default = None ) + users_group_active = Column( "users_group_active", Boolean(), nullable = True, unique = None, default = None ) - members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined") + members = relationship( 'UsersGroupMember', cascade = "all, delete, delete-orphan", lazy = "joined" ) - def __repr__(self): - return '<userGroup(%s)>' % (self.users_group_name) + def __repr__( self ): + return '<userGroup(%s)>' % ( self.users_group_name ) @classmethod - def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): + def get_by_group_name( cls, group_name, cache = False, case_insensitive = False ): if case_insensitive: - gr = Session.query(cls)\ - .filter(cls.users_group_name.ilike(group_name)) + 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)) + gr = gr.options( FromCache( "sql_cache_short", + "get_user_%s" % group_name ) ) return gr.scalar() @classmethod - def get(cls, users_group_id, cache=False): - users_group = Session.query(cls) + def get( cls, users_group_id, cache = False ): + users_group = cls.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) + users_group = users_group.options( FromCache( "sql_cache_short", + "get_users_group_%s" % users_group_id ) ) + return users_group.get( users_group_id ) @classmethod - def create(cls, form_data): + def create( cls, form_data ): try: new_users_group = cls() for k, v in form_data.items(): - setattr(new_users_group, k, v) + setattr( new_users_group, k, v ) - Session.add(new_users_group) + Session.add( new_users_group ) Session.commit() return new_users_group except: - log.error(traceback.format_exc()) + log.error( traceback.format_exc() ) Session.rollback() raise @classmethod - def update(cls, users_group_id, form_data): + def update( cls, users_group_id, form_data ): try: - users_group = cls.get(users_group_id, cache=False) + users_group = cls.get( users_group_id, cache = False ) for k, v in form_data.items(): if k == 'users_group_members': @@ -422,176 +425,182 @@ Session.flush() members_list = [] if v: - for u_id in set(list(v)): - member = UsersGroupMember(users_group_id,u_id) - members_list.append(member) - setattr(users_group, 'members', members_list) - setattr(users_group, k, v) + for u_id in set( list( v ) ): + member = UsersGroupMember( users_group_id, u_id ) + members_list.append( member ) + setattr( users_group, 'members', members_list ) + setattr( users_group, k, v ) - Session.add(users_group) + Session.add( users_group ) Session.commit() except: - log.error(traceback.format_exc()) + log.error( traceback.format_exc() ) Session.rollback() raise @classmethod - def delete(cls, users_group_id): + def delete( cls, users_group_id ): try: # check if this group is not assigned to repo assigned_groups = UsersGroupRepoToPerm.query()\ - .filter(UsersGroupRepoToPerm.users_group_id == - users_group_id).all() + .filter( UsersGroupRepoToPerm.users_group_id == + users_group_id ).all() if assigned_groups: - raise UsersGroupsAssignedException('Group assigned to %s' % - assigned_groups) + raise UsersGroupsAssignedException( 'Group assigned to %s' % + assigned_groups ) - users_group = cls.get(users_group_id, cache=False) - Session.delete(users_group) + users_group = cls.get( users_group_id, cache = False ) + Session.delete( users_group ) Session.commit() except: - log.error(traceback.format_exc()) + log.error( traceback.format_exc() ) Session.rollback() raise - -class UsersGroupMember(Base, BaseModel): +class UsersGroupMember( Base, BaseModel ): __tablename__ = 'users_groups_members' __table_args__ = {'extend_existing':True} - users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) + users_group_member_id = Column( "users_group_member_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + users_group_id = Column( "users_group_id", Integer(), ForeignKey( 'users_groups.users_group_id' ), nullable = False, unique = None, default = None ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) - user = relationship('User', lazy='joined') - users_group = relationship('UsersGroup') + user = relationship( 'User', lazy = 'joined' ) + users_group = relationship( 'UsersGroup' ) - def __init__(self, gr_id='', u_id=''): + def __init__( self, gr_id = '', u_id = '' ): self.users_group_id = gr_id self.user_id = u_id -class Repository(Base, BaseModel): + @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},) + __table_args__ = ( UniqueConstraint( 'repo_name' ), {'extend_existing':True}, ) - repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) - clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None) - repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg') - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) - private = Column("private", Boolean(), nullable=True, unique=None, default=None) - enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True) - enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True) - description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) + repo_id = Column( "repo_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + repo_name = Column( "repo_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = True, default = None ) + clone_uri = Column( "clone_uri", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = False, default = None ) + repo_type = Column( "repo_type", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = False, default = 'hg' ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = False, default = None ) + private = Column( "private", Boolean(), nullable = True, unique = None, default = None ) + enable_statistics = Column( "statistics", Boolean(), nullable = True, unique = None, default = True ) + enable_downloads = Column( "downloads", Boolean(), nullable = True, unique = None, default = True ) + description = Column( "description", String( length = 10000, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + created_on = Column( 'created_on', DateTime( timezone = False ), nullable = True, unique = None, default = datetime.datetime.now ) - fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None) - group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None) + fork_id = Column( "fork_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = True, unique = False, default = None ) + group_id = Column( "group_id", Integer(), ForeignKey( 'groups.group_id' ), nullable = True, unique = False, default = None ) - user = relationship('User') - fork = relationship('Repository', remote_side=repo_id) - group = relationship('Group') - repo_to_perm = relationship('RepoToPerm', cascade='all', order_by='RepoToPerm.repo_to_perm_id') - users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all') - stats = relationship('Statistics', cascade='all', uselist=False) + user = relationship( 'User' ) + fork = relationship( 'Repository', remote_side = repo_id ) + group = relationship( 'Group' ) + repo_to_perm = relationship( 'RepoToPerm', cascade = 'all', order_by = 'RepoToPerm.repo_to_perm_id' ) + users_group_to_perm = relationship( 'UsersGroupRepoToPerm', cascade = 'all' ) + stats = relationship( 'Statistics', cascade = 'all', uselist = False ) - followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all') + followers = relationship( 'UserFollowing', primaryjoin = 'UserFollowing.follows_repo_id==Repository.repo_id', cascade = 'all' ) - logs = relationship('UserLog', cascade='all') + logs = relationship( 'UserLog', cascade = 'all' ) - def __repr__(self): - return "<%s('%s:%s')>" % (self.__class__.__name__, - self.repo_id, self.repo_name) + def __repr__( self ): + return "<%s('%s:%s')>" % ( self.__class__.__name__, + self.repo_id, self.repo_name ) @classmethod - def url_sep(cls): + def url_sep( cls ): return '/' - + @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))\ - + 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 ) ) return q.one() @classmethod - def get_repo_forks(cls, repo_id): - return Session.query(cls).filter(Repository.fork_id == repo_id) + def get_repo_forks( cls, repo_id ): + return cls.query().filter( Repository.fork_id == repo_id ) @classmethod - def base_path(cls): + def base_path( cls ): """ Returns base path when all repos are stored - + :param cls: """ - q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == - cls.url_sep()) - q.options(FromCache("sql_cache_short", "repository_repo_path")) + q = Session.query( RhodeCodeUi ).filter( RhodeCodeUi.ui_key == + cls.url_sep() ) + q.options( FromCache( "sql_cache_short", "repository_repo_path" ) ) return q.one().ui_value @property - def just_name(self): - return self.repo_name.split(Repository.url_sep())[-1] + def just_name( self ): + return self.repo_name.split( Repository.url_sep() )[-1] @property - def groups_with_parents(self): + def groups_with_parents( self ): groups = [] if self.group is None: return groups cur_gr = self.group - groups.insert(0, cur_gr) + groups.insert( 0, cur_gr ) while 1: - gr = getattr(cur_gr, 'parent_group', None) + gr = getattr( cur_gr, 'parent_group', None ) cur_gr = cur_gr.parent_group if gr is None: break - groups.insert(0, gr) + groups.insert( 0, gr ) return groups @property - def groups_and_repo(self): + def groups_and_repo( self ): return self.groups_with_parents, self.just_name @LazyProperty - def repo_path(self): + def repo_path( self ): """ Returns base full path for that repository means where it actually exists on a filesystem """ - q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == - Repository.url_sep()) - q.options(FromCache("sql_cache_short", "repository_repo_path")) + q = Session.query( RhodeCodeUi ).filter( RhodeCodeUi.ui_key == + Repository.url_sep() ) + q.options( FromCache( "sql_cache_short", "repository_repo_path" ) ) return q.one().ui_value @property - def repo_full_path(self): + def repo_full_path( self ): p = [self.repo_path] # we need to split the name by / since this is how we store the # names in the database, but that eventually needs to be converted # into a valid system path - p += self.repo_name.split(Repository.url_sep()) - return os.path.join(*p) + p += self.repo_name.split( Repository.url_sep() ) + return os.path.join( *p ) - def get_new_name(self, repo_name): + def get_new_name( self, repo_name ): """ returns new full repository name based on assigned group and new new - + :param group_name: """ path_prefix = self.group.full_path_splitted if self.group else [] - return Repository.url_sep().join(path_prefix + [repo_name]) + return Repository.url_sep().join( path_prefix + [repo_name] ) @property - def _ui(self): + def _ui( self ): """ Creates an db based ui object for this repository """ @@ -605,48 +614,48 @@ baseui._tcfg = config.config() - ret = Session.query(RhodeCodeUi)\ - .options(FromCache("sql_cache_short", "repository_repo_ui")).all() + ret = RhodeCodeUi.query()\ + .options( FromCache( "sql_cache_short", "repository_repo_ui" ) ).all() hg_ui = ret for ui_ in hg_ui: if ui_.ui_active: - log.debug('settings ui from db[%s]%s:%s', ui_.ui_section, - ui_.ui_key, ui_.ui_value) - baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value) + log.debug( 'settings ui from db[%s]%s:%s', ui_.ui_section, + ui_.ui_key, ui_.ui_value ) + baseui.setconfig( ui_.ui_section, ui_.ui_key, ui_.ui_value ) return baseui @classmethod - def is_valid(cls, repo_name): + def is_valid( cls, repo_name ): """ returns True if given repo name is a valid filesystem repository - + @param cls: @param repo_name: """ from rhodecode.lib.utils import is_valid_repo - return is_valid_repo(repo_name, cls.base_path()) + return is_valid_repo( repo_name, cls.base_path() ) #========================================================================== # SCM PROPERTIES #========================================================================== - def get_changeset(self, rev): - return get_changeset_safe(self.scm_instance, rev) + def get_changeset( self, rev ): + return get_changeset_safe( self.scm_instance, rev ) @property - def tip(self): - return self.get_changeset('tip') + def tip( self ): + return self.get_changeset( 'tip' ) @property - def author(self): + def author( self ): return self.tip.author @property - def last_change(self): + def last_change( self ): return self.scm_instance.last_change #========================================================================== @@ -654,397 +663,407 @@ #========================================================================== @property - def invalidate(self): + def invalidate( self ): """ Returns Invalidation object if this repo should be invalidated None otherwise. `cache_active = False` means that this cache state is not valid and needs to be invalidated """ - return Session.query(CacheInvalidation)\ - .filter(CacheInvalidation.cache_key == self.repo_name)\ - .filter(CacheInvalidation.cache_active == False)\ + return CacheInvalidation.query()\ + .filter( CacheInvalidation.cache_key == self.repo_name )\ + .filter( CacheInvalidation.cache_active == False )\ .scalar() - def set_invalidate(self): + def set_invalidate( self ): """ set a cache for invalidation for this instance """ - inv = Session.query(CacheInvalidation)\ - .filter(CacheInvalidation.cache_key == self.repo_name)\ + inv = CacheInvalidation.query()\ + .filter( CacheInvalidation.cache_key == self.repo_name )\ .scalar() if inv is None: - inv = CacheInvalidation(self.repo_name) + inv = CacheInvalidation( self.repo_name ) inv.cache_active = True - Session.add(inv) + Session.add( inv ) Session.commit() @LazyProperty - def scm_instance(self): + def scm_instance( self ): return self.__get_instance() @property - def scm_instance_cached(self): - @cache_region('long_term') - def _c(repo_name): + def scm_instance_cached( self ): + @cache_region( 'long_term' ) + def _c( repo_name ): return self.__get_instance() # TODO: remove this trick when beaker 1.6 is released # and have fixed this issue with not supporting unicode keys - rn = safe_str(self.repo_name) + rn = safe_str( self.repo_name ) inv = self.invalidate if inv is not None: - region_invalidate(_c, None, rn) + region_invalidate( _c, None, rn ) # update our cache inv.cache_active = True - Session.add(inv) + Session.add( inv ) Session.commit() - return _c(rn) + return _c( rn ) - def __get_instance(self): + def __get_instance( self ): repo_full_path = self.repo_full_path try: - alias = get_scm(repo_full_path)[0] - log.debug('Creating instance of %s repository', alias) - backend = get_backend(alias) + alias = get_scm( repo_full_path )[0] + log.debug( 'Creating instance of %s repository', alias ) + backend = get_backend( alias ) except VCSError: - log.error(traceback.format_exc()) - log.error('Perhaps this repository is in db and not in ' + log.error( traceback.format_exc() ) + log.error( 'Perhaps this repository is in db and not in ' 'filesystem run rescan repositories with ' - '"destroy old data " option from admin panel') + '"destroy old data " option from admin panel' ) return if alias == 'hg': - repo = backend(safe_str(repo_full_path), create=False, - baseui=self._ui) + repo = backend( safe_str( repo_full_path ), create = False, + baseui = self._ui ) #skip hidden web repository if repo._get_hidden(): return else: - repo = backend(repo_full_path, create=False) + repo = backend( repo_full_path, create = False ) return repo -class Group(Base, BaseModel): +class Group( Base, BaseModel ): __tablename__ = 'groups' - __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'), - CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},) + __table_args__ = ( UniqueConstraint( 'group_name', 'group_parent_id' ), + CheckConstraint( 'group_id != group_parent_id' ), {'extend_existing':True}, ) __mapper_args__ = {'order_by':'group_name'} - group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - group_name = Column("group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) - group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) - group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + group_id = Column( "group_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + group_name = Column( "group_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = True, default = None ) + group_parent_id = Column( "group_parent_id", Integer(), ForeignKey( 'groups.group_id' ), nullable = True, unique = None, default = None ) + group_description = Column( "group_description", String( length = 10000, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) - parent_group = relationship('Group', remote_side=group_id) + parent_group = relationship( 'Group', remote_side = group_id ) - def __init__(self, group_name='', parent_group=None): + def __init__( self, group_name = '', parent_group = None ): self.group_name = group_name self.parent_group = parent_group - def __repr__(self): - return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id, - self.group_name) + def __repr__( self ): + return "<%s('%s:%s')>" % ( self.__class__.__name__, self.group_id, + self.group_name ) @classmethod - def groups_choices(cls): + def groups_choices( cls ): from webhelpers.html import literal as _literal - repo_groups = [('', '')] + repo_groups = [( '', '' )] sep = ' » ' - _name = lambda k: _literal(sep.join(k)) + _name = lambda k: _literal( sep.join( k ) ) - repo_groups.extend([(x.group_id, _name(x.full_path_splitted)) - for x in cls.query().all()]) - - repo_groups = sorted(repo_groups,key=lambda t: t[1].split(sep)[0]) + repo_groups.extend( [( x.group_id, _name( x.full_path_splitted ) ) + for x in cls.query().all()] ) + + repo_groups = sorted( repo_groups, key = lambda t: t[1].split( sep )[0] ) return repo_groups - + @classmethod - def url_sep(cls): + def url_sep( cls ): 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): + def parents( self ): parents_recursion_limit = 5 groups = [] if self.parent_group is None: return groups cur_gr = self.parent_group - groups.insert(0, cur_gr) + groups.insert( 0, cur_gr ) cnt = 0 while 1: cnt += 1 - gr = getattr(cur_gr, 'parent_group', None) + gr = getattr( cur_gr, 'parent_group', None ) cur_gr = cur_gr.parent_group if gr is None: break if cnt == parents_recursion_limit: # this will prevent accidental infinit loops - log.error('group nested more than %s' % - parents_recursion_limit) + log.error( 'group nested more than %s' % + parents_recursion_limit ) break - groups.insert(0, gr) + groups.insert( 0, gr ) return groups @property - def children(self): - return Session.query(Group).filter(Group.parent_group == self) + def children( self ): + return Group.query().filter( Group.parent_group == self ) @property - def name(self): - return self.group_name.split(Group.url_sep())[-1] + def name( self ): + return self.group_name.split( Group.url_sep() )[-1] @property - def full_path(self): - return self.group_name + def full_path( self ): + return Group.url_sep().join( [g.group_name for g in self.parents] + + [self.group_name] ) @property - def full_path_splitted(self): - return self.group_name.split(Group.url_sep()) + def full_path_splitted( self ): + return self.group_name.split( Group.url_sep() ) @property - def repositories(self): - return Session.query(Repository).filter(Repository.group == self) + def repositories( self ): + return Repository.query().filter( Repository.group == self ) @property - def repositories_recursive_count(self): + def repositories_recursive_count( self ): cnt = self.repositories.count() - def children_count(group): + def children_count( group ): cnt = 0 for child in group.children: cnt += child.repositories.count() - cnt += children_count(child) + cnt += children_count( child ) return cnt - return cnt + children_count(self) + return cnt + children_count( self ) - def get_new_name(self, group_name): + def get_new_name( self, group_name ): """ returns new full group name based on parent and new name - + :param group_name: """ path_prefix = self.parent_group.full_path_splitted if self.parent_group else [] - return Group.url_sep().join(path_prefix + [group_name]) + return Group.url_sep().join( path_prefix + [group_name] ) -class Permission(Base, BaseModel): +class Permission( Base, BaseModel ): __tablename__ = 'permissions' __table_args__ = {'extend_existing':True} - permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - permission_name = Column("permission_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - permission_longname = Column("permission_longname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + permission_id = Column( "permission_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + permission_name = Column( "permission_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + permission_longname = Column( "permission_longname", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) - def __repr__(self): - return "<%s('%s:%s')>" % (self.__class__.__name__, - self.permission_id, self.permission_name) + def __repr__( self ): + return "<%s('%s:%s')>" % ( self.__class__.__name__, + self.permission_id, self.permission_name ) @classmethod - def get_by_key(cls, key): - return Session.query(cls).filter(cls.permission_name == key).scalar() + def get_by_key( cls, key ): + return cls.query().filter( cls.permission_name == key ).scalar() -class RepoToPerm(Base, BaseModel): +class RepoToPerm( Base, BaseModel ): __tablename__ = 'repo_to_perm' - __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True}) - repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) - repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) + __table_args__ = ( UniqueConstraint( 'user_id', 'repository_id' ), {'extend_existing':True} ) + repo_to_perm_id = Column( "repo_to_perm_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) + permission_id = Column( "permission_id", Integer(), ForeignKey( 'permissions.permission_id' ), nullable = False, unique = None, default = None ) + repository_id = Column( "repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = False, unique = None, default = None ) - user = relationship('User') - permission = relationship('Permission') - repository = relationship('Repository') + user = relationship( 'User' ) + permission = relationship( 'Permission' ) + repository = relationship( 'Repository' ) -class UserToPerm(Base, BaseModel): +class UserToPerm( Base, BaseModel ): __tablename__ = 'user_to_perm' - __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'extend_existing':True}) - user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) + __table_args__ = ( UniqueConstraint( 'user_id', 'permission_id' ), {'extend_existing':True} ) + user_to_perm_id = Column( "user_to_perm_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) + permission_id = Column( "permission_id", Integer(), ForeignKey( 'permissions.permission_id' ), nullable = False, unique = None, default = None ) - user = relationship('User') - permission = relationship('Permission') + user = relationship( 'User' ) + permission = relationship( 'Permission' ) @classmethod - def has_perm(cls, user_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def has_perm( cls, user_id, perm ): + 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)\ - .filter(cls.permission == perm).scalar() is not None + return cls.query().filter( cls.user_id == user_id )\ + .filter( cls.permission == perm ).scalar() is not None @classmethod - def grant_perm(cls, user_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def grant_perm( cls, user_id, perm ): + if not isinstance( perm, Permission ): + raise Exception( 'perm needs to be an instance of Permission class' ) new = cls() new.user_id = user_id new.permission = perm try: - Session.add(new) + Session.add( new ) Session.commit() except: Session.rollback() @classmethod - def revoke_perm(cls, user_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def revoke_perm( cls, user_id, perm ): + if not isinstance( perm, Permission ): + raise Exception( 'perm needs to be an instance of Permission class' ) try: - Session.query(cls).filter(cls.user_id == user_id)\ - .filter(cls.permission == perm).delete() + cls.query().filter( cls.user_id == user_id )\ + .filter( cls.permission == perm ).delete() Session.commit() except: Session.rollback() -class UsersGroupRepoToPerm(Base, BaseModel): +class UsersGroupRepoToPerm( Base, BaseModel ): __tablename__ = 'users_group_repo_to_perm' - __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True}) - users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) - permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) - repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) + __table_args__ = ( UniqueConstraint( 'repository_id', 'users_group_id', 'permission_id' ), {'extend_existing':True} ) + users_group_to_perm_id = Column( "users_group_to_perm_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + users_group_id = Column( "users_group_id", Integer(), ForeignKey( 'users_groups.users_group_id' ), nullable = False, unique = None, default = None ) + permission_id = Column( "permission_id", Integer(), ForeignKey( 'permissions.permission_id' ), nullable = False, unique = None, default = None ) + repository_id = Column( "repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = False, unique = None, default = None ) - users_group = relationship('UsersGroup') - permission = relationship('Permission') - repository = relationship('Repository') + users_group = relationship( 'UsersGroup' ) + permission = relationship( 'Permission' ) + repository = relationship( 'Repository' ) - def __repr__(self): - return '<userGroup:%s => %s >' % (self.users_group, self.repository) + def __repr__( self ): + return '<userGroup:%s => %s >' % ( self.users_group, self.repository ) -class UsersGroupToPerm(Base, BaseModel): +class UsersGroupToPerm( Base, BaseModel ): __tablename__ = 'users_group_to_perm' - users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) - permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) + users_group_to_perm_id = Column( "users_group_to_perm_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + users_group_id = Column( "users_group_id", Integer(), ForeignKey( 'users_groups.users_group_id' ), nullable = False, unique = None, default = None ) + permission_id = Column( "permission_id", Integer(), ForeignKey( 'permissions.permission_id' ), nullable = False, unique = None, default = None ) - users_group = relationship('UsersGroup') - permission = relationship('Permission') + users_group = relationship( 'UsersGroup' ) + permission = relationship( 'Permission' ) @classmethod - def has_perm(cls, users_group_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def has_perm( cls, users_group_id, perm ): + 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 == - users_group_id)\ - .filter(cls.permission == perm)\ + return cls.query().filter( cls.users_group_id == + users_group_id )\ + .filter( cls.permission == perm )\ .scalar() is not None @classmethod - def grant_perm(cls, users_group_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def grant_perm( cls, users_group_id, perm ): + if not isinstance( perm, Permission ): + raise Exception( 'perm needs to be an instance of Permission class' ) new = cls() new.users_group_id = users_group_id new.permission = perm try: - Session.add(new) + Session.add( new ) Session.commit() except: Session.rollback() @classmethod - def revoke_perm(cls, users_group_id, perm): - if not isinstance(perm, Permission): - raise Exception('perm needs to be an instance of Permission class') + def revoke_perm( cls, users_group_id, perm ): + if not isinstance( perm, Permission ): + raise Exception( 'perm needs to be an instance of Permission class' ) try: - Session.query(cls).filter(cls.users_group_id == users_group_id)\ - .filter(cls.permission == perm).delete() + cls.query().filter( cls.users_group_id == users_group_id )\ + .filter( cls.permission == perm ).delete() Session.commit() except: Session.rollback() -class GroupToPerm(Base, BaseModel): +class GroupToPerm( Base, BaseModel ): __tablename__ = 'group_to_perm' - __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True}) + __table_args__ = ( UniqueConstraint( 'group_id', 'permission_id' ), {'extend_existing':True} ) - group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) - group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) + group_to_perm_id = Column( "group_to_perm_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) + permission_id = Column( "permission_id", Integer(), ForeignKey( 'permissions.permission_id' ), nullable = False, unique = None, default = None ) + group_id = Column( "group_id", Integer(), ForeignKey( 'groups.group_id' ), nullable = False, unique = None, default = None ) - user = relationship('User') - permission = relationship('Permission') - group = relationship('Group') + user = relationship( 'User' ) + permission = relationship( 'Permission' ) + group = relationship( 'Group' ) -class Statistics(Base, BaseModel): +class Statistics( Base, BaseModel ): __tablename__ = 'statistics' - __table_args__ = (UniqueConstraint('repository_id'), {'extend_existing':True}) - stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) - stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) - commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data - commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data - languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data + __table_args__ = ( UniqueConstraint( 'repository_id' ), {'extend_existing':True} ) + stat_id = Column( "stat_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + repository_id = Column( "repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = False, unique = True, default = None ) + stat_on_revision = Column( "stat_on_revision", Integer(), nullable = False ) + commit_activity = Column( "commit_activity", LargeBinary( 1000000 ), nullable = False )#JSON data + commit_activity_combined = Column( "commit_activity_combined", LargeBinary(), nullable = False )#JSON data + languages = Column( "languages", LargeBinary( 1000000 ), nullable = False )#JSON data - repository = relationship('Repository', single_parent=True) + repository = relationship( 'Repository', single_parent = True ) -class UserFollowing(Base, BaseModel): +class UserFollowing( Base, BaseModel ): __tablename__ = 'user_followings' - __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'), - UniqueConstraint('user_id', 'follows_user_id') - , {'extend_existing':True}) + __table_args__ = ( UniqueConstraint( 'user_id', 'follows_repository_id' ), + UniqueConstraint( 'user_id', 'follows_user_id' ) + , {'extend_existing':True} ) - user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) - follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) - follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) + user_following_id = Column( "user_following_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None ) + follows_repo_id = Column( "follows_repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = True, unique = None, default = None ) + follows_user_id = Column( "follows_user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = True, unique = None, default = None ) + follows_from = Column( 'follows_from', DateTime( timezone = False ), nullable = True, unique = None, default = datetime.datetime.now ) - user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id') + user = relationship( 'User', primaryjoin = 'User.user_id==UserFollowing.user_id' ) - follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') - follows_repository = relationship('Repository', order_by='Repository.repo_name') + follows_user = relationship( 'User', primaryjoin = 'User.user_id==UserFollowing.follows_user_id' ) + follows_repository = relationship( 'Repository', order_by = 'Repository.repo_name' ) @classmethod - def get_repo_followers(cls, repo_id): - return Session.query(cls).filter(cls.follows_repo_id == repo_id) + def get_repo_followers( cls, repo_id ): + return cls.query().filter( cls.follows_repo_id == repo_id ) -class CacheInvalidation(Base, BaseModel): +class CacheInvalidation( Base, BaseModel ): __tablename__ = 'cache_invalidation' - __table_args__ = (UniqueConstraint('cache_key'), {'extend_existing':True}) - cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) - cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) - cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) + __table_args__ = ( UniqueConstraint( 'cache_key' ), {'extend_existing':True} ) + cache_id = Column( "cache_id", Integer(), nullable = False, unique = True, default = None, primary_key = True ) + cache_key = Column( "cache_key", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + cache_args = Column( "cache_args", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None ) + cache_active = Column( "cache_active", Boolean(), nullable = True, unique = None, default = False ) - def __init__(self, cache_key, cache_args=''): + def __init__( self, cache_key, cache_args = '' ): self.cache_key = cache_key self.cache_args = cache_args self.cache_active = False - def __repr__(self): - return "<%s('%s:%s')>" % (self.__class__.__name__, - self.cache_id, self.cache_key) + def __repr__( self ): + return "<%s('%s:%s')>" % ( self.__class__.__name__, + self.cache_id, self.cache_key ) -class DbMigrateVersion(Base, BaseModel): +class DbMigrateVersion( Base, BaseModel ): __tablename__ = 'db_migrate_version' __table_args__ = {'extend_existing':True} - repository_id = Column('repository_id', String(250), primary_key=True) - repository_path = Column('repository_path', Text) - version = Column('version', Integer) + repository_id = Column( 'repository_id', String( 250 ), primary_key = True ) + repository_path = Column( 'repository_path', Text ) + version = Column( 'version', Integer )
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rhodecode/model/repo_permission.py Wed Oct 19 01:47:56 2011 +0200 @@ -0,0 +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 <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__ ) + +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 )
--- a/rhodecode/model/repos_group.py Mon Oct 17 15:48:19 2011 +0200 +++ b/rhodecode/model/repos_group.py Wed Oct 19 01:47:56 2011 +0200 @@ -36,21 +36,21 @@ 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): + def __create_group( self, group_name, parent_id ): """ makes repositories group on filesystem @@ -58,107 +58,117 @@ :param parent_id: """ - create_path = os.path.join(self.repos_path, group_name) - log.debug('creating new group in %s', create_path) + 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 !') + 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, new): + + 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 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 = '' - log.debug('renaming repos paths from %s to %s', old_path, new_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 ) - 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) + log.debug( 'renaming repos paths from %s to %s', old_path, new_path ) - def __delete_group(self, group): + 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) + paths = group.full_path.split( Group.url_sep() ) + 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) + 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_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.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 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) - old_path = repos_group.full_path - - #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.get( repos_group_id ) + old_name = repos_group.group_name + old_parent_id = repos_group.group_parent_id - self.sa.add(repos_group) - - self.__rename_group(old_path, new_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'] - # 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) + 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() - return repos_group 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
--- a/rhodecode/model/user.py Mon Oct 17 15:48:19 2011 +0200 +++ b/rhodecode/model/user.py Wed Oct 19 01:47:56 2011 +0200 @@ -49,7 +49,6 @@ class UserModel(BaseModel): - def get(self, user_id, cache=False): user = self.sa.query(User) if cache: @@ -87,6 +86,7 @@ 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()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rhodecode/model/users_group.py Wed Oct 19 01:47:56 2011 +0200 @@ -0,0 +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 <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 +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