}

    error:  null

Adds a user to a users group. This command can be executed only using api_key

belonging to user with admin rights

	                                "active" :     "<bool>",

	                                "admin" :      "<bool>",

	                                "ldap" :       "<ldap_dn>",

	                              },

                                  …

                                  {

                                    "id" :       "<usersgroupid>",

                                    "name" :     "<usersgroupname>",

                                    "active":    "<bool>",

                                  },

                                  …

                                ]

    args:     {

                "repo_name" :  "<reponame>",

                "user_name" :  "<username>",

              }

OUTPUT::

    result: None

    error:  null

log = logging.getLogger('JSONRPC')

class JSONRPCError(BaseException):

    def __init__(self, message):

    return resp

class JSONRPCController(WSGIController):

    """

     A WSGI-speaking JSON-RPC controller class

            self._req_api_key = json_body['api_key']

            self._req_id = json_body['id']

            self._req_method = json_body['method']

            log.debug('method: %s, params: %s',

                      self._req_method,

        except KeyError, e:

            return jsonrpc_error(message='Incorrect JSON query missing %s' % e)

        # self.kargs and dispatch control to WGIController

        argspec = inspect.getargspec(self._func)

        arglist = argspec[0][1:]

        default_empty = types.NotImplementedType

                                fillvalue=default_empty))

        # this is little trick to inject logged in user for 

                                 (self._func.__name__, USER_SESSION_ATTR))

        # get our arglist and check if we provided them as args

            if arg == USER_SESSION_ATTR:

                # USER_SESSION_ATTR is something translated from api key and 

                # this is checked before so we don't need validate it

            # skip the required param check if it's default value is 

            # NotImplementedType (default_empty)

        self._rpc_args = {USER_SESSION_ATTR:u}

        self._rpc_args['action'] = self._req_method

        self._rpc_args['environ'] = environ

        status = []

        headers = []

        exc_info = []

        def change_content(new_status, new_headers, new_exc_info=None):

            status.append(new_status)

            headers.extend(new_headers)

        """"

        Get a user by username

        """

        user = User.get_by_username(username)

        if not user:

            return None

                    username=user.username,

                    firstname=user.name,

                    lastname=user.lastname,

                    email=user.email,

                    active=user.active,

                    admin=user.admin,

    @HasPermissionAllDecorator('hg.admin')

    def get_users(self, apiuser):

        """"

        Get all users

        """

        result = []

        for user in User.getAll():

                                username=user.username,

                                firstname=user.name,

                                lastname=user.lastname,

                                email=user.email,

                                active=user.active,

                                admin=user.admin,

        return result

    @HasPermissionAllDecorator('hg.admin')

        """"

        Get users group by name

        """

        users_group = UsersGroup.get_by_group_name(group_name)

        """"

        Get all users groups

        """

        result = []

        """"

        Add a user to a group

        """

        try:

        """"

        Get repository by name

        """

        repo = Repository.get_by_repo_name(repo_name)

        for user in repo.repo_to_perm:

            perm = user.permission.permission_name

            user = user.user

                                    id=user.user_id,

                                    username=user.username,

                                    firstname=user.name,

                                    active=user.active,

                                    admin=user.admin,

                                    ldap=user.ldap_dn,

        for users_group in repo.users_group_to_perm:

            perm = users_group.permission.permission_name

            users_group = users_group.users_group

                                    id=users_group.users_group_id,

                                    name=users_group.users_group_name,

                                    active=users_group.users_group_active,

                    name=repo.repo_name,

                    type=repo.repo_type,

                    description=repo.description,

    @HasPermissionAnyDecorator('hg.admin')

    def get_repos(self, apiuser):

        """"

        Get all repositories

        """

        result = []

        for repository in Repository.getAll():

                                name=repository.repo_name,

                                type=repository.repo_type,

        return result

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

        """

        Create a repository

        """

        try:

            for g in groups:

                group = RepoGroup.get_by_group_name(g)

                if not group:

                                                  group_description='',

                parent_id = group.group_id

                                     repo_name_full=name,

                                     description=description,

                                     private=private,

                                     repo_type=repo_type,

                                     repo_group=parent_id,

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

        """

        Add permission for a user to a repository

        """

        try:

            RepositoryPermissionModel()\

                .update_or_delete_user_permission(repo, user, perm)

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

    repository permission model for RhodeCode

    :created_on: Oct 1, 2011

    :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

import logging

from rhodecode.model import BaseModel

log = logging.getLogger(__name__)

                .scalar()

    def update_user_permission(self, repository, user, permission):

        permission = Permission.get_by_key(permission)

        current = self.get_user_permission(repository, user)

        if current:

        if current:

            self.sa.delete(current)

    def update_or_delete_user_permission(self, repository, user, permission):

        if permission:

            self.update_user_permission(repository, user, permission)

        else:

            self.delete_user_permission(repository, user)