Changeset - 3338a0994472
Parent rev.
Child rev.
[Not reviewed]
beta
0 3 0
Nicolas VINOT - 14 years ago 2011-10-01 16:34:07
aeris@imirhil.fr
Transplanted from: 14b67cdc0f25
Improve API with user/group/repo CRUD methods
3 files changed with 210 insertions and 36 deletions:
.hgignore
3
rhodecode/controllers/api/api.py
104
8
rhodecode/model/db.py
103
28
0 comments (0 inline, 0 general)
.hgignore
➞
Show inline comments
 
syntax: glob
 
*.pyc
 
*.swp
 
*.ini
 
Paste*
 

			




	
	
	
		
 
syntax: regexp

			




	
	
	
		
 
^build

			




	
	
	
		
 
^docs/build/

			




	
	
	
		
 
^docs/_build/

			




	
	
	
		
 
^data$

			




	
	
		
 
@@ -11,6 +13,7 @@ syntax: regexp

			




	
	
	
		
 
^\.project$

			




	
	
	
		
 
^\.pydevproject$

			




	
	
	
		
 
^rhodecode\.db$

			




	
	
	
		
 
^test\.db$

			




	
	
	
		
 
^repositories\.config$

			




	
	
	
		
 
^RhodeCode\.egg-info$

			




	
	
	
		
 
^env$

			




        

    


    
    

    

        

                

                    rhodecode/controllers/api/api.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
import traceback

			




	
	
	
		
 
import logging

			




	
	
	
		
 

			




	
	
	
		
 
from rhodecode.controllers.api import JSONRPCController, JSONRPCError

			




	
	
	
		
 
from rhodecode.lib.auth import HasPermissionAllDecorator

			




	
	
	
		
 
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, UsersGroupMember, Group, Repository

			




	
	
	
		
 
from rhodecode.model.repo import RepoModel

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class ApiController(JSONRPCController):

			




	
	
	
		
 
    """

			




	
	
		
 
@@ -44,45 +45,62 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
            return 'Pulled from %s' % repo

			




	
	
	
		
 
        except Exception:

			




	
	
	
		
 
            raise JSONRPCError('Unable to pull changes from "%s"' % repo)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAllDecorator('hg.admin')

			




	
	
	
		
 
    def create_user(self, apiuser, username, password, active, admin, name, 

			




	
	
	
		
 
                    lastname, email):

			




	
	
	
		
 
    def create_user(self, apiuser, username, password, name,

			




	
	
	
		
 
                    lastname, email, active=True, admin=False, ldap_dn=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Creates 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)

			




	
	
	
		
 
                         email=email,

			




	
	
	
		
 
                         ldap_dn=ldap_dn)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            u = User.create(form_data)

			




	
	
	
		
 
            return {'id':u.user_id,

			




	
	
	
		
 
                    'msg':'created new user %s' % name}

			




	
	
	
		
 
        except Exception:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            raise JSONRPCError('failed to create user %s' % name)

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAllDecorator('hg.admin')

			




	
	
	
		
 
    def list_users(self, apiuser):

			




	
	
	
		
 
        """"

			




	
	
	
		
 
        Lists all users

			




	
	
	
		
 

			




	
	
	
		
 
        :param apiuser

			




	
	
	
		
 
        """

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for user in User.getAll():

			




	
	
	
		
 
            result.append({ 'username':user.username,

			




	
	
	
		
 
                            'name': user.name,

			




	
	
	
		
 
                            'lastname': user.lastname,

			




	
	
	
		
 
                            'email': user.email })

			




	
	
	
		
 
        return result

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAllDecorator('hg.admin')

			




	
	
	
		
 
    def create_users_group(self, apiuser, name, active):

			




	
	
	
		
 
    def create_users_group(self, apiuser, name, active=True):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Creates an new usergroup

			




	
	
	
		
 
        

			




	
	
	
		
 
        :param name:

			




	
	
	
		
 
        :param active:

			




	
	
	
		
 
        """

			




	
	
		
 
@@ -92,7 +110,85 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
            ug = UsersGroup.create(form_data)

			




	
	
	
		
 
            return {'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 list_users_groups(self, apiuser):

			




	
	
	
		
 
        """"

			




	
	
	
		
 
        Lists all users groups

			




	
	
	
		
 

			




	
	
	
		
 
        :param apiuser

			




	
	
	
		
 
        """

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for users_group in UsersGroup.getAll():

			




	
	
	
		
 
            result.append({ 'name': users_group.name })

			




	
	
	
		
 
        return result

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAllDecorator('hg.admin')

			




	
	
	
		
 
    def add_user_to_group(self, apiuser, user_name, group_name):

			




	
	
	
		
 
        """"

			




	
	
	
		
 
        Add a user to a group

			




	
	
	
		
 

			




	
	
	
		
 
        :param apiuser

			




	
	
	
		
 
        :param user_name

			




	
	
	
		
 
        :param group_name

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        users_group = UsersGroup.get_by_group_name(group_name)

			




	
	
	
		
 
        if not users_group:

			




	
	
	
		
 
            raise JSONRPCError('unknown users group %s' % group_name)

			




	
	
	
		
 

			




	
	
	
		
 
        user = User.by_username(user_name)

			




	
	
	
		
 
        if not user:

			




	
	
	
		
 
            raise JSONRPCError('unknown user %s' % user_name)

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            UsersGroupMember.create(user, users_group)

			




	
	
	
		
 
        except Exception:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            raise JSONRPCError('failed to create users group member')

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

			




	
	
	
		
 
    def create_repo(self, apiuser, name, owner_name, description=None, repo_type='hg', \

			




	
	
	
		
 
                    private=False, group_name=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Create a repository

			




	
	
	
		
 

			




	
	
	
		
 
        :param apiuser

			




	
	
	
		
 
        :param name

			




	
	
	
		
 
        :param description

			




	
	
	
		
 
        :param type

			




	
	
	
		
 
        :param private

			




	
	
	
		
 
        :param owner_name

			




	
	
	
		
 
        :param group_name

			




	
	
	
		
 
        :param clone

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        if group_name:

			




	
	
	
		
 
            group = Group.get_by_group_name(group_name)

			




	
	
	
		
 
            if group is None:

			




	
	
	
		
 
                raise JSONRPCError('unknown group %s' % group_name)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            group = None

			




	
	
	
		
 

			




	
	
	
		
 
        owner = User.by_username(owner_name)

			




	
	
	
		
 
        if owner is None:

			




	
	
	
		
 
            raise JSONRPCError('unknown user %s' % owner)

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            RepoModel().create({ "repo_name" : name,

			




	
	
	
		
 
                                 "repo_name_full" : name,

			




	
	
	
		
 
                                 "description" : description,

			




	
	
	
		
 
                                 "private" : private,

			




	
	
	
		
 
                                 "repo_type" : repo_type,

			




	
	
	
		
 
                                 "repo_group" : group,

			




	
	
	
		
 
                                 "clone_uri" : None }, owner)

			




	
	
	
		
 
        except Exception:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            raise JSONRPCError('failed to create repository %s' % name)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    rhodecode/model/db.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -122,17 +122,21 @@ class BaseModel(object):

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def query(cls):

			




	
	
	
		
 
        return Session.query(cls)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get(cls, 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'

			




	
	
		
 
@@ -149,19 +153,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 !')

			




	
	
		
 
@@ -171,13 +175,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})

			




	
	
	
		
 

			




	
	
		
 
@@ -201,13 +205,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,

			




	
	
		
 
@@ -279,20 +283,19 @@ class User(Base, BaseModel):

			




	
	
	
		
 
        except:

			




	
	
	
		
 
            return self.__class__.__name__

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def by_username(cls, username, case_insensitive=False):

			




	
	
	
		
 
        if case_insensitive:

			




	
	
	
		
 
            return Session.query(cls).filter(cls.username.like(username)).one()

			




	
	
	
		
 
            return cls.query().filter(cls.username.like(username)).one()

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            return Session.query(cls).filter(cls.username == username).one()

			




	
	
	
		
 
            return cls.query().filter(cls.username == username).one()

			




	
	
	
		
 

			




	
	
	
		
 
    @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)

			




	
	
		
 
@@ -351,26 +354,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

			




	
	
		
 
@@ -448,12 +451,28 @@ 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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, user, users_group):

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            users_group_member = cls()

			




	
	
	
		
 
            users_group_member.user = user

			




	
	
	
		
 
            users_group_member.users_group = users_group

			




	
	
	
		
 

			




	
	
	
		
 
            Session.add(users_group_member)

			




	
	
	
		
 
            Session.commit()

			




	
	
	
		
 
            return users_group_member

			




	
	
	
		
 
        except:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            Session.rollback()

			




	
	
	
		
 
            raise

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
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)

			




	
	
		
 
@@ -482,25 +501,47 @@ class Repository(Base, BaseModel):

			




	
	
	
		
 
    logs = relationship('UserLog', cascade='all')

			




	
	
	
		
 

			




	
	
	
		
 
    def __repr__(self):

			




	
	
	
		
 
        return "<%s('%s:%s')>" % (self.__class__.__name__,

			




	
	
	
		
 
                                  self.repo_id, self.repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @staticmethod

			




	
	
	
		
 
    def create(name, description, repo_type, private, owner, group, clone):

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            repo = Repository()

			




	
	
	
		
 
            repo.repo_name = name

			




	
	
	
		
 
            repo.clone_uri = clone

			




	
	
	
		
 
            repo.repo_type = repo_type

			




	
	
	
		
 
            repo.user = owner

			




	
	
	
		
 
            repo.private = private

			




	
	
	
		
 
            repo.description = description

			




	
	
	
		
 
            repo.group = group

			




	
	
	
		
 

			




	
	
	
		
 
            Session.add(repo)

			




	
	
	
		
 
            Session.commit()

			




	
	
	
		
 

			




	
	
	
		
 
            RepoToPerm.create(repo, owner, Permission.get_by_name('repository.write'))

			




	
	
	
		
 
            return repo

			




	
	
	
		
 
        except:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            Session.rollback()

			




	
	
	
		
 
            raise

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def by_repo_name(cls, repo_name):

			




	
	
	
		
 
        q = Session.query(cls).filter(cls.repo_name == repo_name)

			




	
	
	
		
 
        q = cls.query().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)

			




	
	
	
		
 
        return cls.query().filter(Repository.fork_id == repo_id)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def base_path(cls):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns base path when all repos are stored

			




	
	
	
		
 
        

			




	
	
		
 
@@ -538,13 +579,13 @@ class Repository(Base, BaseModel):

			




	
	
	
		
 
    @LazyProperty

			




	
	
	
		
 
    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 == '/')

			




	
	
	
		
 
        q = RhodeCodeUi.query().filter(RhodeCodeUi.ui_key == '/')

			




	
	
	
		
 
        q.options(FromCache("sql_cache_short", "repository_repo_path"))

			




	
	
	
		
 
        return q.one().ui_value

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def repo_full_path(self):

			




	
	
	
		
 
        p = [self.repo_path]

			




	
	
		
 
@@ -566,13 +607,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,

			




	
	
		
 
@@ -621,22 +662,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

			




	
	
		
 
@@ -718,12 +759,25 @@ class Group(Base, BaseModel):

			




	
	
	
		
 
                                  self.group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def url_sep(cls):

			




	
	
	
		
 
        return '/'

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    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:

			




	
	
	
		
 
            return groups

			




	
	
		
 
@@ -744,22 +798,22 @@ 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 full_path(self):

			




	
	
	
		
 
        return Group.url_sep().join([g.group_name for g in self.parents] +

			




	
	
	
		
 
                        [self.group_name])

			




	
	
	
		
 

			




	
	
	
		
 
    @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):

			




	
	
		
 
@@ -781,13 +835,17 @@ 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()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_name(cls, name):

			




	
	
	
		
 
        return cls.query().filter(cls.permission_name == name).one()

			




	
	
	
		
 

			




	
	
	
		
 
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)

			




	
	
		
 
@@ -795,12 +853,29 @@ class RepoToPerm(Base, BaseModel):

			




	
	
	
		
 
    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')

			




	
	
	
		
 

			




	
	
	
		
 
    @staticmethod

			




	
	
	
		
 
    def create(repo, user, p):

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            perm = RepoToPerm()

			




	
	
	
		
 
            perm.repository = repo

			




	
	
	
		
 
            perm.user = user

			




	
	
	
		
 
            perm.permission = p

			




	
	
	
		
 

			




	
	
	
		
 
            Session.add(perm)

			




	
	
	
		
 
            Session.commit()

			




	
	
	
		
 

			




	
	
	
		
 
            return perm

			




	
	
	
		
 
        except:

			




	
	
	
		
 
            log.error(traceback.format_exc())

			




	
	
	
		
 
            Session.rollback()

			




	
	
	
		
 
            raise

			




	
	
	
		
 

			




	
	
	
		
 
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)

			




	
	
		
 
@@ -810,13 +885,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')

			




	
	
		
 
@@ -834,13 +909,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):

			




	
	
		
 
@@ -870,13 +945,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):

			




	
	
		
 
@@ -896,13 +971,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()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -948,13 +1023,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)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.