Each request is authenticated and logged together with IP address.

- Build for speed and performance. You can make multiple pulls/pushes simultaneous.

  Proven to work with 1000s of repositories and users

- Supports http/https, LDAP, AD, proxy-pass authentication.

- Full permissions (private/read/write/admin) together with IP restrictions for each repository,

  additional explicit forking and repository creation permissions.

- Repository groups let you group repos and manage them easier.

- Users can fork other users repos, and compare them at any time.

- Integrates easily with other systems, with custom created mappers you can connect it to almost

  any issue tracker, and with an JSON-RPC API you can make much more

- Build in commit-api let's you add, edit and commit files right from RhodeCode

  web interface using simple editor or upload binary files using simple form.

    error:  null

get_users_group

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

belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "get_users_group"

    args :    {

              }

OUTPUT::

    id : <id_given_in_input>

    result : None if group not exist

    error : null

get_users_groups

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

api_key belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    error : null

create_users_group

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

belonging to user with admin rights

INPUT::

    id : <id_for_response>

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "users_group": {

                     "users_group_id" : "<id>",

                     "group_name" :     "<groupname>",

                     "active":          "<bool>",

               },

            }

    error:  null

add_user_to_users_group

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

`false`. This command can be executed only using api_key

belonging to user with admin rights

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "add_user_users_group"

    args:     {

                "userid" : "<user_id or username>",

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "success": True|False # depends on if member is in group

                      User is already in that group"

            }

    error:  null

remove_user_from_users_group

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

be `false`. This command can be executed only

using api_key belonging to user with admin rights

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "remove_user_from_users_group"

    args:     {

                "userid" : "<user_id or username>",

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "success":  True|False,  # depends on if member is in group

                      User wasn't in group"

            }

    error:  null

get_repo

    error:  null

grant_users_group_permission

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

existing one if found. This command can be executed only using

api_key belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "grant_users_group_permission"

    args:     {

                "repoid" : "<reponame or repo_id>"

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

              }

OUTPUT::

    id : <id_given_in_input>

    error:  null

revoke_users_group_permission

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

executed only using api_key belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method  : "revoke_users_group_permission"

    args:     {

                "repoid" : "<reponame or repo_id>"

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

- #518 added possibility of specifying multiple patterns for issues

- update codemirror to latest version

fixes

+++++

- fixed #578 set proper PATH with current Python for Git

  hooks to execute within same Python as RhodeCode

- fixed issue with Git bare repos that ends with .git in name

1.4.2 (**2012-09-12**)

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

- Whoosh logging is now controlled by the .ini files logging setup

- added clone-url into edit form on /settings page

- added help text into repo add/edit forms

- created rcextensions module with additional mappings (ref #322) and

  post push/pull/create repo hooks callbacks

- implemented #377 Users view for his own permissions on account page

- #401 repository group is automatically pre-selected when adding repos

  inside a repository group

- added alternative HTTP 403 response when client failed to authenticate. Helps

  solving issues with Mercurial and LDAP

- #402 removed group prefix from repository name when listing repositories

  inside a group

  line

- extended journal with day aggregates and paging

- implemented #107 source code lines highlight ranges

- implemented #93 customizable changelog on combined revision ranges -

  equivalent of githubs compare view

- implemented #108 extended and more powerful LDAP configuration

- major code rewrites optimized codes for speed and memory usage

- raw and diff downloads are now in git format

- setup command checks for write access to given path

- fixed many issues with international characters and unicode. It uses utf8

  decode with replace to provide less errors even with non utf8 encoded strings

- #125 added API KEY access to feeds

                  action="delete_email", conditions=dict(method=["DELETE"]))

        m.connect("user_ips", "/users_ips/{id}",

                  action="add_ip", conditions=dict(method=["PUT"]))

        m.connect("user_ips_delete", "/users_ips/{id}",

                  action="delete_ip", conditions=dict(method=["DELETE"]))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/users_groups') as m:

        m.connect("users_groups", "/users_groups",

                  action="create", conditions=dict(method=["POST"]))

        m.connect("users_groups", "/users_groups",

                  action="index", conditions=dict(method=["GET"]))

                    category='error')

            raise HTTPInternalServerError()

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_users_group(self, repo_name):

        """

        :param repo_name:

        """

        try:

            RepoModel().revoke_users_group_permission(

                repo=repo_name, group_name=request.POST['users_group_id']

            )

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of repository'

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

    def repo_stats(self, repo_name):

        """

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

"""

    rhodecode.controllers.admin.repos_groups

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

    :created_on: Mar 23, 2010

    :author: marcink

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

    :license: GPLv3, see COPYING for more details.

"""

        return redirect(url('repos_groups'))

    @HasReposGroupPermissionAnyDecorator('group.admin')

    def delete_repos_group_user_perm(self, group_name):

        """

        :param group_name:

        """

        try:

            if not c.rhodecode_user.is_admin:

                if c.rhodecode_user.user_id == safe_int(request.POST['user_id']):

                    category='error')

            raise HTTPInternalServerError()

    @HasReposGroupPermissionAnyDecorator('group.admin')

    def delete_repos_group_users_group_perm(self, group_name):

        """

        :param group_name:

        """

        try:

            recursive = str2bool(request.POST.get('recursive', False))

                obj_type='users_group', recursive=recursive

            )

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of group'

                    category='error')

            raise HTTPInternalServerError()

    def show_by_name(self, group_name):

        """

        This is a proxy that does a lookup group_name -> id, and shows

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

"""

    rhodecode.controllers.admin.users_groups

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

    :created_on: Jan 25, 2011

    :author: marcink

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

    :license: GPLv3, see COPYING for more details.

"""

            UsersGroupModel().create(name=form_result['users_group_name'],

                                     active=form_result['users_group_active'])

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users_groups/users_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('users_groups'))

    def new(self, format='html'):

        """GET /users_groups/new: Form to create a new item"""

            form_result = users_group_form.to_python(request.POST)

            UsersGroupModel().update(c.users_group, form_result)

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            ug_model = UsersGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('edit_users_group', id=id))

    def delete(self, id):

        """DELETE /users_groups/id: Delete an existing item"""

        #           method='delete')

        # url('users_group', id=ID)

        usr_gr = UsersGroup.get_or_404(id)

        try:

            UsersGroupModel().delete(usr_gr)

            Session().commit()

        except UsersGroupsAssignedException, e:

            h.flash(e, category='error')

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        return redirect(url('users_groups'))

    def show(self, id, format='html'):

        """GET /users_groups/id: Show a specific item"""

        # url('users_group', id=ID)

            users_group.inherit_default_permissions = inherit_perms

            Session().add(users_group)

            if grant_create_perm:

                usersgroup_model.revoke_perm(id, 'hg.create.none')

                usersgroup_model.grant_perm(id, 'hg.create.repository')

                        category='success')

            else:

                usersgroup_model.revoke_perm(id, 'hg.create.repository')

                usersgroup_model.grant_perm(id, 'hg.create.none')

                        category='success')

            if grant_fork_perm:

                usersgroup_model.revoke_perm(id, 'hg.fork.none')

                usersgroup_model.grant_perm(id, 'hg.fork.repository')

                        category='success')

            else:

                usersgroup_model.revoke_perm(id, 'hg.fork.repository')

                usersgroup_model.grant_perm(id, 'hg.fork.none')

                        category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during permissions saving'),

        raise JSONRPCError('repository `%s` does not exist' % (repoid))

    return repo

def get_users_group_or_error(usersgroupid):

    """

    :param userid:

    """

    users_group = UsersGroupModel().get_group(usersgroupid)

    if users_group is None:

    return users_group

def get_perm_or_error(permid):

    """

    Get permission by id or name or return JsonRPCError if not found

            raise JSONRPCError('failed to delete ID:%s %s' % (user.user_id,

                                                              user.username))

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, usersgroupid):

        """"

        :param apiuser:

        :param usersgroupid:

        """

        users_group = get_users_group_or_error(usersgroupid)

        data['members'] = members

        return data

    @HasPermissionAllDecorator('hg.admin')

    def get_users_groups(self, apiuser):

        """"

        :param apiuser:

        """

        result = []

        for users_group in UsersGroupModel().get_all():

        :param apiuser:

        :param group_name:

        :param active:

        """

        if UsersGroupModel().get_by_name(group_name):

        try:

            active = Optional.extract(active)

            ug = UsersGroupModel().create(name=group_name, active=active)

            Session().commit()

            return dict(

                users_group=ug.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group `%s`' % group_name)

    @HasPermissionAllDecorator('hg.admin')

    def add_user_to_users_group(self, apiuser, usersgroupid, userid):

        """"

        :param apiuser:

        :param usersgroupid:

        :param userid:

        """

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

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

            success = True if ugm != True else False

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else 'User is already in that group'

            Session().commit()

            return dict(

                success=success,

                msg=msg

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                    users_group.users_group_name

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def remove_user_from_users_group(self, apiuser, usersgroupid, userid):

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            success = UsersGroupModel().remove_user_from_group(users_group,

                                                               user)

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else "User wasn't in group"

            Session().commit()

            return dict(success=success, msg=msg)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                        users_group.users_group_name

                    )

            )

    def get_repo(self, apiuser, repoid):

        """"

            )

    @HasPermissionAllDecorator('hg.admin')

    def grant_users_group_permission(self, apiuser, repoid, usersgroupid,

                                     perm):

        """

        existing one if found

        :param apiuser:

        :param repoid:

        :param usersgroupid:

        :param perm:

            RepoModel().grant_users_group_permission(repo=repo,

                                                     group_name=users_group,

                                                     perm=perm)

            Session().commit()

            return dict(

                    'repo: `%s`' % (

                    perm.permission_name, users_group.users_group_name,

                    repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'repo: `%s`' % (

                    usersgroupid, repo.repo_name

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def revoke_users_group_permission(self, apiuser, repoid, usersgroupid):

        """

        :param apiuser:

        :param repoid:

        :param usersgroupid:

        """

        repo = get_repo_or_error(repoid)

        try:

            RepoModel().revoke_users_group_permission(repo=repo,

                                                      group_name=users_group)

            Session().commit()

            return dict(

                    users_group.users_group_name, repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'repo: `%s`' % (

                    users_group.users_group_name, repo.repo_name

                )

            )

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

"""

    rhodecode.model.user_group

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

    :created_on: Jan 25, 2011

    :author: marcink

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

    :license: GPLv3, see COPYING for more details.

"""

            # update permissions

            for member, perm, member_type in perms_updates:

                ## set for user

                if member_type == 'user':

                    # this updates also current one if found

                    _set_perm_user(obj, user=member, perm=perm)

                else:

                    _set_perm_group(obj, users_group=member, perm=perm)

            # set new permissions

            for member, perm, member_type in perms_new:

                if member_type == 'user':

                    _set_perm_user(obj, user=member, perm=perm)

            log.error('Error removing repos_group %s' % repos_group)

            raise

    def delete_permission(self, repos_group, obj, obj_type, recursive):

        """

        Revokes permission for repos_group for given obj(user or users_group),

        :param repos_group:

        :param recursive: recurse to all children of group

        """

        from rhodecode.model.repo import RepoModel

        repos_group = self._get_repos_group(repos_group)

        for el in repos_group.recursive_groups_and_repos():

        if obj:

            self.sa.delete(obj)

            log.debug('Revoked perm on %s on %s' % (repos_group, user))

    def grant_users_group_permission(self, repos_group, group_name, perm):

        """

        existing one if found

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param group_name: Instance of UserGroup, users_group_id,

        :param perm: Instance of Permission, or permission_name

        """

        repos_group = self._get_repos_group(repos_group)

        group_name = self.__get_users_group(group_name)

        permission = self._get_perm(perm)

        obj.permission = permission

        self.sa.add(obj)

        log.debug('Granted perm %s to %s on %s' % (perm, group_name, repos_group))

    def revoke_users_group_permission(self, repos_group, group_name):

        """

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param group_name: Instance of UserGroup, users_group_id,

        """

        repos_group = self._get_repos_group(repos_group)

        group_name = self.__get_users_group(group_name)

        obj = self.sa.query(UsersGroupRepoGroupToPerm)\

            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\

            # repositories

            for perm in default_repo_perms:

                r_k = perm.UserRepoToPerm.repository.repo_name

                p = 'repository.admin'

                user.permissions[RK][r_k] = p

            for perm in default_repo_groups_perms:

                rg_k = perm.UserRepoGroupToPerm.group.group_name

                p = 'group.admin'

                user.permissions[GK][rg_k] = p

            return user

                p = 'repository.admin'

            else:

                p = perm.Permission.permission_name

            user.permissions[RK][r_k] = p

        # on given group

        for perm in default_repo_groups_perms:

            rg_k = perm.UserRepoGroupToPerm.group.group_name

            p = perm.Permission.permission_name

            user.permissions[GK][rg_k] = p

                p = perm.Permission.permission_name

                if not explicit:

                    p = _choose_perm(p, cur_perm)

            user.permissions[RK][r_k] = p

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

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

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

        # check if user is part of user groups for this repository groups and

        # fill in his permission from it. _choose_perm decides of which

        # permission should be selected based on selected method

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