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 232 insertions and 59 deletions:
.hgignore
3
rhodecode/controllers/api/api.py
116
21
rhodecode/model/db.py
113
38
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):

			




	
	
	
		
 
    """

			




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

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Dispatch pull action on given repo

			




	
	
	
		
 
        

			




	
	
	
		
 
        

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        :param user:

			




	
	
	
		
 
        :param repo:

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        if Repository.is_valid(repo) is False:

			




	
	
	
		
 
            raise JSONRPCError('Unknown repo "%s"' % repo)

			




	
	
		
 
@@ -44,55 +45,149 @@ 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:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        form_data = {'users_group_name':name,

			




	
	
	
		
 
                     'users_group_active':active}

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            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)

			




	
	
	
		
 
        

			




	
	
		
 
\ No newline at end of file

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    rhodecode/model/db.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -54,30 +54,30 @@ log = logging.getLogger(__name__)

			




	
	
	
		
 
# BASE CLASSES

			




	
	
	
		
 
#==============================================================================

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        if hasattr(obj, '__json__'):

			




	
	
	
		
 
            return obj.__json__()

			




	
	
		
 
@@ -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,33 +283,32 @@ 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)

			




	
	
	
		
 
        Session.commit()

			




	
	
	
		
 
        log.debug('updated user %s lastlogin', self.username)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    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)

			




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

			




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

			




	
	
	
		
 
        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.