.. _api:

API

===

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 ACCESS FOR WEB VIEWS

++++++++++++++++++++++++

API access can also be turned on for each view decorated with `@LoginRequired`

decorator. To enable API access simple change standard login decorator into

`@LoginRequired(api_access=True)`. After such a change view can be accessed

by adding a GET parameter to url `?api_key=<api_key>`. By default it's only

enabled on RSS/ATOM feed views.

API ACCESS

++++++++++

All clients are required to send JSON-RPC spec JSON data::

    {   

        "id:<id>,

        "api_key":"<api_key>",

        "method":"<method_name>",

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

    }

Example call for autopulling remotes repos using curl::

    curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"id":1,"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'

Simply provide

 - *id* A value of any type, which is used to match the response with the request that it is replying to.

 - *api_key* for access and permission validation.

 - *method* is name of method to call

 - *args* is an key:value list of arguments to pass to method

.. note::

    api_key can be found in your user account page

RhodeCode API will return always a JSON-RPC response::

    {   

        "id":<id>,

        "result": "<result>",

        "error": null

    }

All responses from API will be `HTTP/1.0 200 OK`, if there's an error while

calling api *error* key from response will contain failure description

and result will be null.

API METHODS

+++++++++++

pull

----

Pulls given repo from remote location. Can be used to automatically keep

remote repos up to date. This command can be executed only using api_key

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "pull"

    args :    {

              }

OUTPUT::

    error :  null

get_users

---------

Lists all existing users. This command can be executed only using api_key

belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method :  "get_users"

    args :    { }

OUTPUT::

    result: [

              {

                "id" :       "<id>",

                "username" : "<username>",

                "firstname": "<firstname>",

                "lastname" : "<lastname>",

                "email" :    "<email>",

                "active" :   "<bool>",

                "admin" :    "<bool>",

                "ldap" :     "<ldap_dn>"

              },

    	      …

            ]

    error:  null

create_user

-----------

Creates new user in RhodeCode. This command can be executed only using api_key

belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method :  "create_user"

    args :    {

                "username" :  "<username>",

                "password" :  "<password>",

                "firstname" : "<firstname>",

                "lastname" :  "<lastname>",

                "email" :     "<useremail>"

                "active" :    "<bool> = True",

                "admin" :     "<bool> = False",

                "ldap_dn" :   "<ldap_dn> = None"

              }

OUTPUT::

    result: {

              "msg" : "created new user <username>"

            }

    error:  null

get_users_group

---------------

Gets an existing users group. This command can be executed only using api_key

belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method :  "get_users_group"

    args :    {

                "group_name" : "<name>"

              }

OUTPUT::

    result : None if group not exist

             {

               "id" :       "<id>",

               "active":    "<bool>",

               "members" :  [

	    	                  { "id" :       "<userid>",

	                            "username" : "<username>",

	                            "firstname": "<firstname>",

	                            "lastname" : "<lastname>",

	                            "email" :    "<email>",

	                            "active" :   "<bool>",

	                            "admin" :    "<bool>",

	                            "ldap" :     "<ldap_dn>"

	                          },

	    	                  …

	                        ]

             }

    error : null

create_users_group

------------------

Creates new users group. This command can be executed only using api_key

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "create_users_group"

    args:     {

                "active":"<bool> = True"

              }

OUTPUT::

    result: {

              "id":  "<newusersgroupid>",

            }

    error:  null

add_user_to_users_group

-----------------------

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

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "add_user_users_group"

    args:     {

                "group_name" :  "<groupname>",

                "username" :   "<username>"

              }

OUTPUT::

    result: {

              "id":  "<newusersgroupmemberid>",

              "msg": "created new users group member"

            }

    error:  null

get_repo

--------

Gets an existing repository. This command can be executed only using api_key

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "get_repo"

    args:     {

              }

OUTPUT::

            {

                "id" :          "<id>",

                "type" :        "<type>",

                "description" : "<description>",

                "members" :     [

                                  { "id" :         "<userid>",

	                                "username" :   "<username>",

	                                "firstname":   "<firstname>",

	                                "lastname" :   "<lastname>",

	                                "email" :      "<email>",

	                                "active" :     "<bool>",

	                                "admin" :      "<bool>",

	                                "ldap" :       "<ldap_dn>",

	                                "permission" : "repository.(read|write|admin)"

	                              },

                                  …

                                  {

                                    "id" :       "<usersgroupid>",

                                    "name" :     "<usersgroupname>",

                                    "active":    "<bool>",

                                    "permission" : "repository.(read|write|admin)"

                                  },

                                  …

                                ]

            }

    error:  null

get_repo_nodes

--------------

returns a list of nodes and it's children in a flat list for a given path 

with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "get_repo_nodes"

    args:     {

                "revision"  : "<revision>",

                "root_path" : "<root_path>",

                "ret_type"  : "<ret_type>" = 'all'

              }

OUTPUT::

    result: [

              {

                "name" :        "<name>"

                "type" :        "<type>",

              },

              …

            ]

    error:  null

create_repo

-----------

Creates a repository. This command can be executed only using api_key

belonging to user with admin rights.

If repository name contains "/", all needed repository groups will be created.

For example "foo/bar/baz" will create groups "foo", "bar" (with "foo" as parent),

and create "baz" repository with "bar" as group.

INPUT::

    api_key : "<api_key>"

    method :  "create_repo"

    args:     {

                "owner_name" :  "<ownername>",

                "description" : "<description> = ''",

                "repo_type" :   "<type> = 'hg'",

                "private" :     "<bool> = False"

              }

OUTPUT::

    error:  null

add_user_to_repo

----------------

Add a user to a repository. This command can be executed only using api_key

belonging to user with admin rights.

If "perm" is None, user will be removed from the repository.

INPUT::

    api_key : "<api_key>"

    method :  "add_user_to_repo"

    args:     {

                "repo_name" :  "<reponame>",

                "username" :  "<username>",

                "perm" :       "(None|repository.(read|write|admin))",

              }

OUTPUT::

    error:  null

add_users_group_to_repo

-----------------------

Add a users group to a repository. This command can be executed only using 

api_key belonging to user with admin rights. If "perm" is None, group will 

be removed from the repository.

INPUT::

    api_key : "<api_key>"

    method :  "add_users_group_to_repo"

    args:     {

                "repo_name" :  "<reponame>",

                "group_name" :  "<groupname>",

                "perm" :       "(None|repository.(read|write|admin))",

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.api

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

    API controller for RhodeCode

    :created_on: Aug 20, 2011

    :author: marcink

    :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>

    :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; version 2

# of the License or (at your opinion) any later version of the license.

#

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import traceback

import logging

from sqlalchemy.orm.exc import NoResultFound

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

from rhodecode.model.db import User, UsersGroup, RepoGroup, 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.repos_group import ReposGroupModel

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

    errors that happens

    """

    @HasPermissionAllDecorator('hg.admin')

        """

        Dispatch pull action on given repo

        :param user:

        """

        try:

        except Exception:

    @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 get_users(self, apiuser):

        """"

        Get all users

        :param apiuser:

        """

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

        :param lastname:

        :param email:

        :param active:

        :param admin:

        :param ldap_dn:

        """

        if User.get_by_username(username):

            raise JSONRPCError("user %s already exist" % username)

        try:

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

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

    @HasPermissionAllDecorator('hg.admin')

    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,

                    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,

                                active=users_group.users_group_active,

                                members=members))

        return result

    @HasPermissionAllDecorator('hg.admin')

        """

        Creates an new usergroup

        :param active:

        """

        try:

            Session.commit()

            return dict(id=ug.users_group_id,

        except Exception:

            log.error(traceback.format_exc())

    @HasPermissionAllDecorator('hg.admin')

    def add_user_to_users_group(self, apiuser, group_name, username):

        """"

        Add a user to a group

        :param apiuser:

        :param group_name:

        :param username:

        """

        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(username)

            except NoResultFound:

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

            ugm = UsersGroupModel().add_user_to_group(users_group, user)

            Session.commit()

            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:

        """

        repo = Repository.get_by_repo_name(repo_name)

        if repo is None:

            raise JSONRPCError('unknown repository %s' % repo)

        members = []

        for user in repo.repo_to_perm:

            perm = user.permission.permission_name

            user = user.user

            members.append(

                dict(