Starting from RhodeCode version 1.2 a simple API was implemented.

There's a single schema for calling all api methods. API is implemented

with JSON protocol both ways. An url to send API request in RhodeCode is

<your_server>/_admin/api

    {

        "api_key":"<api_key>",

        "method":"<method_name>",

        "args":{"<arg_key>":"<arg_val>"}

    }

.. note::

    api_key can be found in your user account page

    {

        "result": "<result>",

        "error": null

    }

    result: {

              "id":  "<newusersgroupid>",

              "msg": "created new users group <name>"

            }

    error:  null

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

belonging to user with admin rights

INPUT::

	                                "firstname":   "<firstname>",

	                                "lastname" :   "<lastname>",

	                                "email" :      "<email>",

	                                "active" :     "<bool>",

	                                "admin" :      "<bool>",

	                                "ldap" :       "<ldap_dn>",

	                              },

                                  …

                                  {

                                    "id" :       "<usersgroupid>",

                                    "name" :     "<usersgroupname>",

                                    "active":    "<bool>",

                                  },

                                  …

                                ]

            }

    error:  null

    api_key : "<api_key>"

    method :  "add_user_to_repo"

    args:     {

                "repo_name" :  "<reponame>",

                "user_name" :  "<username>",

              }

OUTPUT::

    result: None

    error:  null

from rhodecode.lib.compat import izip_longest, json

from paste.response import replace_header

from pylons.controllers import WSGIController

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

HTTPBadRequest, HTTPError

from rhodecode.model.db import User

from rhodecode.lib.auth import AuthUser

log = logging.getLogger('JSONRPC')

class JSONRPCError(BaseException):

    def __init__(self, message):

        self.message = message

    def __str__(self):

        return str(self.message)

def jsonrpc_error(message, code=None):

class JSONRPCController(WSGIController):

    """

     A WSGI-speaking JSON-RPC controller class

            return jsonrpc_error(message="JSON parse error ERR:%s RAW:%r" \

                                 % (e, urllib.unquote_plus(raw_body)))

        #check AUTH based on API KEY

        try:

            self._req_api_key = json_body['api_key']

            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)

        #check if we can find this session using api_key

        try:

            u = User.get_by_api_key(self._req_api_key)

            auth_u = AuthUser(u.user_id, self._req_api_key)

        except Exception, e:

            return jsonrpc_error(message='Invalid API KEY')

        self._error = None

        try:

            return jsonrpc_error(message=str(e))

        # now that we have a method, add self._req_params to

        # 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 

        # perms decorators to work they expect the controller class to have

        # rhodecode_user attribute set

        self.rhodecode_user = auth_u

        if USER_SESSION_ATTR not in arglist:

            return jsonrpc_error(message='This method [%s] does not support '

                                 'authentication (missing %s param)' %

                                 (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

                continue

            # 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

        self._rpc_args['start_response'] = start_response

        status = []

        headers = []

        exc_info = []

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

            status.append(new_status)

            headers.extend(new_headers)

            exc_info.append(new_exc_info)

        output = WSGIController.__call__(self, environ, change_content)

            json_exc = JSONRPCError('Internal server error')

            self._error = str(json_exc)

        if self._error is not None:

            raw_response = None

        try:

            return json.dumps(response)

        except TypeError, e:

            log.debug('Error encoding response: %s', e)

            return json.dumps(dict(result=None,

    rhodecode.model.users_group

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~

    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

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

# 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.meta import Session

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        return RepoToPerm.query() \

                .filter(RepoToPerm.user == user) \

                .filter(RepoToPerm.repository == repository) \

                .scalar()

    def delete_user_permission(self, repository, user):

        current = self.get_user_permission(repository, user)

        if current:

            Session.delete(current)

            Session.commit()

    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)