kallithea Changeset - 0b63a0d2cede

Changeset - 0b63a0d2cede

Parent rev.

Child rev.

[Not reviewed]

Merge beta

0 5 2

Nicolas VINOT - 14 years ago 2011-10-19 01:47:56
aeris@imirhil.fr

Merge with upstream

6 files changed with 539 insertions and 83 deletions:

rhodecode/controllers/api/api.py

295

rhodecode/model/db.py

rhodecode/model/repo_permission.py

rhodecode/model/repos_group.py

rhodecode/model/user.py

rhodecode/model/users_group.py

0 comments (0 inline, 0 general)

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
+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__)
 class ApiController(JSONRPCController):
     """
@@ @@ -42,57 +49,325 @@ class ApiController(JSONRPCController): @@
         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.get_by_username( username )
         if not user:
             return None
         return dict( id = user.user_id,
                         username = user.username,
                         firstname = user.name,
                         lastname = user.lastname,
                         email = user.email,
                         active = user.active,
                         admin = user.admin,
                         ldap = user.ldap_dn )
     @HasPermissionAllDecorator('hg.admin')
     def create_user(self, apiuser, username, password, active, admin, name,
                     lastname, email):
     def get_users( self, apiuser ):
         """"
         Get all users
         :param apiuser
         """
         Creates new user
         result = []
         for user in User.getAll():
             result.append( dict( id = user.user_id,
                                 username = user.username,
                                 firstname = user.name,
                                 lastname = user.lastname,
                                 email = user.email,
                                 active = user.active,
                                 admin = user.admin,
                                 ldap = user.ldap_dn ) )
         return result
     @HasPermissionAllDecorator( 'hg.admin' )
     def create_user( self, apiuser, username, password, firstname,
                     lastname, email, active = True, admin = False, ldap_dn = None ):
         """
         Create new user
         :param apiuser:
         :param username:
         :param password:
         :param active:
         :param admin:
         :param name:
         :param lastname:
         :param email:
         :param active:
         :param admin:
         :param ldap_dn:
         """
         if self.get_user( apiuser, username ):
             raise JSONRPCError( "user %s already exist" % username )
         try:
         form_data = dict(username=username,
                          password=password,
                          active=active,
                          admin=admin,
-                         name=name,
+                             name = firstname,
                          lastname=lastname,
                          email=email)
         try:
             u = User.create(form_data)
             return {'id':u.user_id,
                     'msg':'created new user %s' % name}
                              email = email,
                              ldap_dn = ldap_dn )
             UserModel().create_ldap( username, password, ldap_dn, form_data )
             return dict( msg = 'created new user %s' % username )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create user %s' % name)
             raise JSONRPCError( 'failed to create user %s' % username )
     @HasPermissionAllDecorator('hg.admin')
     def create_users_group(self, apiuser, name, active):
     def get_users_group( self, apiuser, group_name ):
         """"
         Get users group by name
         :param apiuser
         :param group_name
         """
         users_group = UsersGroup.get_by_group_name( group_name )
         if not users_group:
             return None
         members = []
         for user in users_group.members:
             user = user.user
             members.append( dict( id = user.user_id,
                             username = user.username,
                             firstname = user.name,
                             lastname = user.lastname,
                             email = user.email,
                             active = user.active,
                             admin = user.admin,
                             ldap = user.ldap_dn ) )
         return dict( id = users_group.users_group_id,
                     name = users_group.users_group_name,
                     active = users_group.users_group_active,
                     members = members )
     @HasPermissionAllDecorator( 'hg.admin' )
     def get_users_groups( self, apiuser ):
         """"
         Get all users groups
         :param apiuser
         """
         result = []
         for users_group in UsersGroup.getAll():
             members = []
             for user in users_group.members:
                 user = user.user
                 members.append( dict( id = user.user_id,
                                 username = user.username,
                                 firstname = user.name,
                                 lastname = user.lastname,
                                 email = user.email,
                                 active = user.active,
                                 admin = user.admin,
                                 ldap = user.ldap_dn ) )
             result.append( dict( id = users_group.users_group_id,
                                 name = users_group.users_group_name,
                                 active = users_group.users_group_active,
                                 members = members ) )
         return result
     @HasPermissionAllDecorator( 'hg.admin' )
     def create_users_group( self, apiuser, name, active = True ):
         """
         Creates an new usergroup
         :param name:
         :param active:
         """
         form_data = {'users_group_name':name,
                      'users_group_active':active}
         if self.get_users_group( apiuser, name ):
             raise JSONRPCError( "users group %s already exist" % name )
         try:
             form_data = dict( users_group_name = name,
                              users_group_active = active )
             ug = UsersGroup.create(form_data)
             return {'id':ug.users_group_id,
                     'msg':'created new users group %s' % name}
             return dict( id = ug.users_group_id,
                         msg = 'created new users group %s' % name )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create group %s' % name)
     @HasPermissionAllDecorator( 'hg.admin' )
     def add_user_to_users_group( self, apiuser, group_name, user_name ):
         """"
         Add a user to a group
         :param apiuser
         :param group_name
         :param user_name
         """
         try:
             users_group = UsersGroup.get_by_group_name( group_name )
             if not users_group:
                 raise JSONRPCError( 'unknown users group %s' % group_name )
             try:
                 user = User.get_by_username( user_name )
             except NoResultFound:
                 raise JSONRPCError( 'unknown user %s' % user_name )
             ugm = UsersGroupModel().add_user_to_group( users_group, user )
             return dict( id = ugm.users_group_member_id,
                         msg = 'created new users group member' )
         except Exception:
             log.error( traceback.format_exc() )
             raise JSONRPCError( 'failed to create users group member' )
     @HasPermissionAnyDecorator( 'hg.admin' )
     def get_repo( self, apiuser, repo_name ):
         """"
         Get repository by name
         :param apiuser
         :param repo_name
         """
         try:
             repo = Repository.get_by_repo_name( repo_name )
         except NoResultFound:
             return None
         members = []
         for user in repo.repo_to_perm:
             perm = user.permission.permission_name
             user = user.user
             members.append( dict( type_ = "user",
                                     id = user.user_id,
                                     username = user.username,
                                     firstname = user.name,
                                     lastname = user.lastname,
                                     email = user.email,
                                     active = user.active,
                                     admin = user.admin,
                                     ldap = user.ldap_dn,
                                     permission = perm ) )
         for users_group in repo.users_group_to_perm:
             perm = users_group.permission.permission_name
             users_group = users_group.users_group
             members.append( dict( type_ = "users_group",
                                     id = users_group.users_group_id,
                                     name = users_group.users_group_name,
                                     active = users_group.users_group_active,
                                     permission = perm ) )
         return dict( id = repo.repo_id,
                     name = repo.repo_name,
                     type = repo.repo_type,
                     description = repo.description,
                     members = members )
     @HasPermissionAnyDecorator( 'hg.admin' )
     def get_repos( self, apiuser ):
         """"
         Get all repositories
         :param apiuser
         """
         result = []
         for repository in Repository.getAll():
             result.append( dict( id = repository.repo_id,
                                 name = repository.repo_name,
                                 type = repository.repo_type,
                                 description = repository.description ) )
         return result
     @HasPermissionAnyDecorator( 'hg.admin', 'hg.create.repository' )
     def create_repo( self, apiuser, name, owner_name, description = '', repo_type = 'hg', \
                     private = False ):
         """
         Create a repository
         :param apiuser
         :param name
         :param description
         :param type
         :param private
         :param owner_name
         """
         try:
             try:
                 owner = User.get_by_username( owner_name )
             except NoResultFound:
                 raise JSONRPCError( 'unknown user %s' % owner )
             if self.get_repo( apiuser, name ):
                 raise JSONRPCError( "repo %s already exist" % name )
             groups = name.split( '/' )
             real_name = groups[-1]
             groups = groups[:-1]
             parent_id = None
             for g in groups:
                 group = Group.get_by_group_name( g )
                 if not group:
                     group = ReposGroupModel().create( dict( group_name = g,
                                                   group_description = '',
                                                   group_parent_id = parent_id ) )
                 parent_id = group.group_id
             RepoModel().create( dict( repo_name = real_name,
                                      repo_name_full = name,
                                      description = description,
                                      private = private,
                                      repo_type = repo_type,
                                      repo_group = parent_id,
                                      clone_uri = None ), owner )
         except Exception:
             log.error( traceback.format_exc() )
             raise JSONRPCError( 'failed to create repository %s' % name )
     @HasPermissionAnyDecorator( 'hg.admin' )
     def add_user_to_repo( self, apiuser, repo_name, user_name, perm ):
         """
         Add permission for a user to a repository
         :param apiuser
         :param repo_name
         :param user_name
         :param perm
         """
         try:
             try:
                 repo = Repository.get_by_repo_name( repo_name )
             except NoResultFound:
                 raise JSONRPCError( 'unknown repository %s' % repo )
             try:
                 user = User.get_by_username( user_name )
             except NoResultFound:
                 raise JSONRPCError( 'unknown user %s' % user )
             RepositoryPermissionModel().updateOrDeleteUserPermission( repo, user, perm )
         except Exception:
             log.error( traceback.format_exc() )
             raise JSONRPCError( 'failed to edit permission %(repo)s for %(user)s'
                             % dict( user = user_name, repo = repo_name ) )
@@ \ No newline at end of file @@

rhodecode/model/db.py

➞

Show inline comments

@@ @@ -125,18 +125,21 @@ class BaseModel(object): @@
     @classmethod
     def query(cls):
         return Session.query(cls)
     @classmethod
     def get(cls, id_):
         if id_:
             return Session.query(cls).get(id_)
         return cls.query().get( id_ )
     @classmethod
     def getAll( cls ):
         return cls.query().all()
     @classmethod
     def delete(cls, id_):
-        obj = Session.query(cls).get(id_)
+        obj = cls.query().get( id_ )
         Session.delete(obj)
         Session.commit()
 class RhodeCodeSettings(Base, BaseModel):
     __tablename__ = 'rhodecode_settings'
@@ @@ -175,19 +178,19 @@ class RhodeCodeSettings(Base, BaseModel) @@
         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)\
+        return cls.query()\
             .filter(cls.app_settings_name == ldap_key).scalar()
     @classmethod
     def get_app_settings(cls, cache=False):
-        ret = Session.query(cls)
+        ret = cls.query()
         if cache:
             ret = ret.options(FromCache("sql_cache_short", "get_hg_settings"))
         if not ret:
             raise Exception('Could not get application settings !')
@@ @@ -197,13 +200,13 @@ class RhodeCodeSettings(Base, BaseModel) @@
                 each.app_settings_value
         return settings
     @classmethod
     def get_ldap_settings(cls, cache=False):
-        ret = Session.query(cls)\
+        ret = cls.query()\
                 .filter(cls.app_settings_name.startswith('ldap_')).all()
         fd = {}
         for row in ret:
             fd.update({row.app_settings_name:row.app_settings_value})
         return fd
@@ @@ -224,13 +227,13 @@ class RhodeCodeUi(Base, BaseModel): @@
     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)
+        return cls.query().filter( cls.ui_key == key )
     @classmethod
     def get_builtin_hooks(cls):
         q = cls.query()
         q = q.filter(cls.ui_key.in_([cls.HOOK_UPDATE,
@@ @@ -308,13 +311,13 @@ class User(Base, BaseModel): @@
             return Session.query(cls).filter(cls.username.ilike(username)).scalar()
         else:
             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()
+        return cls.query().filter( cls.api_key == api_key ).one()
     def update_lastlogin(self):
         """Update user lastlogin"""
         self.last_login = datetime.datetime.now()
         Session.add(self)
@@ @@ -373,26 +376,26 @@ class UsersGroup(Base, BaseModel): @@
     def __repr__(self):
         return '<userGroup(%s)>' % (self.users_group_name)
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
-            gr = Session.query(cls)\
+            gr = cls.query()\
             .filter(cls.users_group_name.ilike(group_name))
         else:
             gr = Session.query(UsersGroup)\
                 .filter(UsersGroup.users_group_name == group_name)
             gr = cls.query()\
                 .filter( cls.users_group_name == group_name )
         if cache:
             gr = gr.options(FromCache("sql_cache_short",
                                           "get_user_%s" % group_name))
         return gr.scalar()
     @classmethod
     def get(cls, users_group_id, cache=False):
-        users_group = Session.query(cls)
+        users_group = cls.query()
         if cache:
             users_group = users_group.options(FromCache("sql_cache_short",
                                     "get_users_group_%s" % users_group_id))
         return users_group.get(users_group_id)
     @classmethod
@@ @@ -453,13 +456,12 @@ class UsersGroup(Base, BaseModel): @@
             Session.commit()
         except:
             log.error(traceback.format_exc())
             Session.rollback()
             raise
 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)
@@ @@ -469,12 +471,21 @@ class UsersGroupMember(Base, BaseModel): @@
     users_group = relationship('UsersGroup')
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
         self.user_id = u_id
     @staticmethod
     def add_user_to_group( group, user ):
         ugm = UsersGroupMember()
         ugm.users_group = group
         ugm.user = user
         Session.add( ugm )
         Session.commit()
         return ugm
 class Repository(Base, BaseModel):
     __tablename__ = 'repositories'
     __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)
     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)
@@ @@ -510,22 +521,20 @@ class Repository(Base, BaseModel): @@
     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))\
                 .options( joinedload( Repository.group ) )
         return q.one()
     @classmethod
     def get_repo_forks(cls, repo_id):
-        return Session.query(cls).filter(Repository.fork_id == repo_id)
+        return cls.query().filter( Repository.fork_id == repo_id )
     @classmethod
     def base_path(cls):
         """
         Returns base path when all repos are stored
@@ @@ -602,13 +611,13 @@ class Repository(Base, BaseModel): @@
         #clean the baseui object
         baseui._ocfg = config.config()
         baseui._ucfg = config.config()
         baseui._tcfg = config.config()
-        ret = Session.query(RhodeCodeUi)\
+        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,
@@ @@ -657,22 +666,22 @@ class Repository(Base, BaseModel): @@
     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)\
+        return CacheInvalidation.query()\
             .filter(CacheInvalidation.cache_key == self.repo_name)\
             .filter(CacheInvalidation.cache_active == False)\
             .scalar()
     def set_invalidate(self):
         """
         set a cache for invalidation for this instance
         """
-        inv = Session.query(CacheInvalidation)\
+        inv = CacheInvalidation.query()\
             .filter(CacheInvalidation.cache_key == self.repo_name)\
             .scalar()
         if inv is None:
             inv = CacheInvalidation(self.repo_name)
         inv.cache_active = True
@@ @@ -768,14 +777,23 @@ class Group(Base, BaseModel): @@
     @classmethod
     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):
         parents_recursion_limit = 5
         groups = []
         if self.parent_group is None:
@@ @@ -797,29 +815,30 @@ class Group(Base, BaseModel): @@
             groups.insert(0, gr)
         return groups
     @property
     def children(self):
-        return Session.query(Group).filter(Group.parent_group == self)
+        return Group.query().filter( Group.parent_group == self )
     @property
     def name(self):
         return self.group_name.split(Group.url_sep())[-1]
     @property
     def full_path(self):
         return self.group_name
         return Group.url_sep().join( [g.group_name for g in self.parents] +
                         [self.group_name] )
     @property
     def full_path_splitted(self):
         return self.group_name.split(Group.url_sep())
     @property
     def repositories(self):
-        return Session.query(Repository).filter(Repository.group == self)
+        return Repository.query().filter( Repository.group == self )
     @property
     def repositories_recursive_count(self):
         cnt = self.repositories.count()
         def children_count(group):
@@ @@ -852,13 +871,13 @@ class Permission(Base, BaseModel): @@
     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()
+        return cls.query().filter( cls.permission_name == key ).scalar()
 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)
@@ @@ -881,13 +900,13 @@ class UserToPerm(Base, BaseModel): @@
     @classmethod
     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)\
+        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')
@@ @@ -905,13 +924,13 @@ class UserToPerm(Base, BaseModel): @@
     @classmethod
     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)\
+            cls.query().filter( cls.user_id == user_id )\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
             Session.rollback()
 class UsersGroupRepoToPerm(Base, BaseModel):
@@ @@ -941,13 +960,13 @@ class UsersGroupToPerm(Base, BaseModel): @@
     @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')
-        return Session.query(cls).filter(cls.users_group_id ==
+        return cls.query().filter( cls.users_group_id ==
                                          users_group_id)\
                                          .filter(cls.permission == perm)\
                                          .scalar() is not None
     @classmethod
     def grant_perm(cls, users_group_id, perm):
@@ @@ -967,13 +986,13 @@ class UsersGroupToPerm(Base, BaseModel): @@
     @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')
         try:
-            Session.query(cls).filter(cls.users_group_id == users_group_id)\
+            cls.query().filter( cls.users_group_id == users_group_id )\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
             Session.rollback()
@@ @@ -1019,13 +1038,13 @@ class UserFollowing(Base, BaseModel): @@
     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)
+        return cls.query().filter( cls.follows_repo_id == repo_id )
 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)

rhodecode/model/repo_permission.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- 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 )

rhodecode/model/repos_group.py

➞

Show inline comments

@@ @@ -47,44 +47,58 @@ class ReposGroupModel(BaseModel): @@
         Get's the repositories root path from database
         """
         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
         :param repo_name:
         :param parent_id:
         """
         create_path = os.path.join(self.repos_path, group_name)
         if parent_id:
             paths = Group.get( parent_id ).full_path.split( Group.url_sep() )
             parent_path = os.sep.join( paths )
         else:
             parent_path = ''
         create_path = os.path.join( self.repos_path, parent_path, group_name )
         log.debug('creating new group in %s', create_path)
         if os.path.isdir(create_path):
             raise Exception('That directory already exists !')
         os.makedirs(create_path)
     def __rename_group(self, old, new):
     def __rename_group( self, old, old_parent_id, new, new_parent_id ):
         """
         Renames a group on filesystem
         :param group_name:
         """
         if old == new:
             log.debug('skipping group rename')
             return
         log.debug('renaming repos group from %s to %s', old, new)
         if new_parent_id:
             paths = Group.get( new_parent_id ).full_path.split( Group.url_sep() )
             new_parent_path = os.sep.join( paths )
         else:
             new_parent_path = ''
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
         if old_parent_id:
             paths = Group.get( old_parent_id ).full_path.split( Group.url_sep() )
             old_parent_path = os.sep.join( paths )
         else:
             old_parent_path = ''
         old_path = os.path.join( self.repos_path, old_parent_path, old )
         new_path = os.path.join( self.repos_path, new_parent_path, new )
         log.debug('renaming repos paths from %s to %s', old_path, new_path)
         if os.path.isdir(new_path):
             raise Exception('Was trying to rename to already '
                             'existing dir %s' % new_path)
@@ @@ -97,59 +111,55 @@ class ReposGroupModel(BaseModel): @@
         :param group: instance of group from database
         """
         paths = group.full_path.split(Group.url_sep())
         paths = os.sep.join(paths)
         rm_path = os.path.join(self.repos_path, paths)
         if os.path.isdir(rm_path):
             # delete only if that path really exists
             os.rmdir(rm_path)
     def create(self, form_data):
         try:
             new_repos_group = Group()
             new_repos_group.group_description = form_data['group_description']
             new_repos_group.parent_group = Group.get(form_data['group_parent_id'])
             new_repos_group.group_name = new_repos_group.get_new_name(form_data['group_name'])
             new_repos_group.group_name = form_data['group_name']
             new_repos_group.group_description = \
                 form_data['group_description']
             new_repos_group.group_parent_id = form_data['group_parent_id']
             self.sa.add(new_repos_group)
             self.__create_group(new_repos_group.group_name)
             self.__create_group( form_data['group_name'],
                                 form_data['group_parent_id'] )
             self.sa.commit()
             return new_repos_group
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
     def update(self, repos_group_id, form_data):
         try:
             repos_group = Group.get(repos_group_id)
             old_path = repos_group.full_path
             old_name = repos_group.group_name
             old_parent_id = repos_group.group_parent_id
             #change properties
             repos_group.group_description = form_data['group_description']
             repos_group.parent_group = Group.get(form_data['group_parent_id'])
             repos_group.group_name = repos_group.get_new_name(form_data['group_name'])
             new_path = repos_group.full_path
             repos_group.group_name = form_data['group_name']
             repos_group.group_description = \
                 form_data['group_description']
             repos_group.group_parent_id = form_data['group_parent_id']
             self.sa.add(repos_group)
             self.__rename_group(old_path, new_path)
             # we need to get all repositories from this new group and
             # rename them accordingly to new group path
             for r in repos_group.repositories:
                 r.repo_name = r.get_new_name(r.just_name)
                 self.sa.add(r)
             if old_name != form_data['group_name'] or ( old_parent_id !=
                                                 form_data['group_parent_id'] ):
                 self.__rename_group( old = old_name, old_parent_id = old_parent_id,
                                     new = form_data['group_name'],
                                     new_parent_id = form_data['group_parent_id'] )
             self.sa.commit()
             return repos_group
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
     def delete(self, users_group_id):

rhodecode/model/user.py

➞

Show inline comments

@@ @@ -46,13 +46,12 @@ PERM_WEIGHTS = {'repository.none': 0, @@
                 'repository.read': 1,
                 'repository.write': 3,
                 'repository.admin': 3}
 class UserModel(BaseModel):
     def get(self, user_id, cache=False):
         user = self.sa.query(User)
         if cache:
             user = user.options(FromCache("sql_cache_short",
                                           "get_user_%s" % user_id))
         return user.get(user_id)
@@ @@ -84,12 +83,13 @@ class UserModel(BaseModel): @@
             for k, v in form_data.items():
                 setattr(new_user, k, v)
             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()
             raise
     def create_ldap(self, username, password, user_dn, attrs):

rhodecode/model/users_group.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- 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

0 comments (0 inline, 0 general)