Stefan Engel <mail@engel-stefan.de>

    Andrew Shadura <bugzilla@tut.by>

    Raoul Thill <raoul.thill@gmail.com>

    Philip Jameson <philip.j@hostdime.com>

    Mads Kiilerich <madski@unity3d.com>

    Dan Sheridan <djs@adelard.com>

  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

- fixes #298 ldap created users with mixed case emails created conflicts

  on saving a form

- fixes issue when owner of a repo couldn't revoke permissions for users

  and groups

- fixes #271 rare JSON serialization problem with statistics

- fixes #337 missing validation check for conflicting names of a group with a

- #340 fixed session problem for mysql and celery tasks

- fixed #331 RhodeCode mangles repository names if the a repository group

  contains the "full path" to the repositories

- #355 RhodeCode doesn't store encrypted LDAP passwords

1.2.5 (**2012-01-28**)

  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

.s1 { color: #bb8844 } /* Literal.String.Single */

.ss { color: #bb8844 } /* Literal.String.Symbol */

.bp { color: #999999 } /* Name.Builtin.Pseudo */

.vc { color: #ff99ff } /* Name.Variable.Class */

.vg { color: #ff99ff } /* Name.Variable.Global */

.vi { color: #ff99ff } /* Name.Variable.Instance */

    - if celery is used each instance should run separate celery instance, but

      the message broken should be common to all of them (ex one rabbitmq

      shared server)    

    - load balance using round robin or ip hash, recommended is writing LB rules

      that will separate regular user traffic from automated processes like CI

      servers or build bots.

            pass

        return is_valid_repo(repo_name, config['base_path'])

    def check_group(environ, match_dict):

        """

        :param environ:

        :param match_dict:

        """

        repos_group_name = match_dict.get('group_name')

        return is_valid_repos_group(repos_group_name, config['base_path'])

                  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"]))

import logging

import traceback

from pylons import request

from pylons import tmpl_context as c, url

from webhelpers.paginate import Page

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

                        for un in no.notifications_to_users)

            if h.HasPermissionAny('hg.admin')() or owner:

                    NotificationModel().mark_read(c.rhodecode_user.user_id, no)

                    Session().commit()

                    return 'ok'

        except Exception:

            log.error(traceback.format_exc())

        return 'fail'

    def delete(self, notification_id):

        """DELETE /_admin/notifications/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

                        for un in no.notifications_to_users)

            if h.HasPermissionAny('hg.admin')() or owner:

                    NotificationModel().delete(c.rhodecode_user.user_id, no)

                    Session().commit()

                    return 'ok'

        except Exception:

            log.error(traceback.format_exc())

        return 'fail'

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

        """GET /_admin/notifications/id: Show a specific item"""

        # url('notification', notification_id=ID)

        c.user = self.rhodecode_user

        no = Notification.get(notification_id)

                    for un in no.notifications_to_users)

        if no and (h.HasPermissionAny('hg.admin', 'repository.admin')() or owner):

            unotification = NotificationModel()\

                            .get_user_notification(c.user.user_id, no)

            # if this association to user is not valid, we don't want to show

            # this message

                    unotification.mark_as_read()

                    Session().commit()

                c.notification = no

                return render('admin/notifications/show_notification.html')

    def edit(self, notification_id, format='html'):

        """GET /_admin/notifications/id/edit: Form to edit an existing item"""

        # url('edit_notification', notification_id=ID)

                    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

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_pullrequests(self):

                                .filter(PullRequest.user_id ==

                                        self.rhodecode_user.user_id)\

                                    .filter(PullRequestReviewers.user_id ==

        return render('admin/users/user_edit_my_account_pullrequests.html')

    @NotAnonymous()

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

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

"""

from formencode import htmlfill

from pylons import request, session, tmpl_context as c, url, config

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_unicode, str2bool

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.meta import Session

from rhodecode.lib.utils import action_logger

from sqlalchemy.orm import joinedload

log = logging.getLogger(__name__)

        super(UsersGroupsController, self).__before__()

        c.available_permissions = config['available_permissions']

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

        """GET /users_groups: All items in the collection"""

        # url('users_groups')

        return render('admin/users_groups/users_groups.html')

    def create(self):

        """POST /users_groups: Create a new item"""

        # url('users_groups')

        try:

            form_result = users_group_form.to_python(dict(request.POST))

                                     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"""

    def _load_data(self, id):

        c.users_group.permissions = {

            'repositories': {},

            'repositories_groups': {}

        }

            .all()

        for gr in ugroup_repo_perms:

            c.users_group.permissions['repositories'][gr.repository.repo_name]  \

                = gr.permission.permission_name

            .all()

        for gr in ugroup_group_perms:

            c.users_group.permissions['repositories_groups'][gr.group.group_name] \

                = gr.permission.permission_name

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('users_group', id=ID),

        #           method='put')

        # url('users_group', id=ID)

        self._load_data(id)

        available_members = [safe_unicode(x[0]) for x in c.available_members]

                                          old_data=c.users_group.get_dict(),

                                          available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            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:

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': ug_model.has_perm(id,

                                                      'hg.create.repository'),

                'fork_repo_perm': ug_model.has_perm(id,

                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"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('users_group', id=ID),

        #           method='delete')

        # url('users_group', id=ID)

        try:

            Session().commit()

            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)

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

        """GET /users_groups/id/edit: Form to edit an existing item"""

        # url('edit_users_group', id=ID)

        self._load_data(id)

        defaults = c.users_group.get_dict()

        defaults.update({

            'create_repo_perm': ug_model.has_perm(c.users_group,

                                                  'hg.create.repository'),

            'fork_repo_perm': ug_model.has_perm(c.users_group,

                                                'hg.fork.repository'),

        )

    def update_perm(self, id):

        """PUT /users_perm/id: Update an existing item"""

        # url('users_group_perm', id=ID, method='put')

        grant_create_perm = str2bool(request.POST.get('create_repo_perm'))

        grant_fork_perm = str2bool(request.POST.get('fork_repo_perm'))

        inherit_perms = str2bool(request.POST.get('inherit_default_permissions'))

        try:

            users_group.inherit_default_permissions = inherit_perms

            Session().add(users_group)

            if grant_create_perm: