Philip Jameson <philip.j@hostdime.com>

    Mads Kiilerich <madski@unity3d.com>

    Dan Sheridan <djs@adelard.com>

- 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

get_users_group

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

belonging to user with admin rights.

    api_key : "<api_key>"

    method :  "get_users_group"

    args :    {

              }

OUTPUT::

get_users_groups

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

api_key belonging to user with admin rights.

create_users_group

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

belonging to user with admin rights

    id : <id_given_in_input>

    result: {

              "users_group": {

                     "users_group_id" : "<id>",

                     "group_name" :     "<groupname>",

add_user_to_users_group

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

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

belonging to user with admin rights

    api_key : "<api_key>"

    method :  "add_user_users_group"

    args:     {

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

              }

    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

    api_key : "<api_key>"

    method :  "remove_user_from_users_group"

    args:     {

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

              }

    id : <id_given_in_input>

    result: {

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

                      User wasn't in group"

            }

    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.

    method :  "grant_users_group_permission"

    args:     {

                "repoid" : "<reponame or repo_id>"

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

              }

revoke_users_group_permission

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

executed only using api_key belonging to user with admin rights.

INPUT::

    method  : "revoke_users_group_permission"

    args:     {

                "repoid" : "<reponame or repo_id>"

              }

OUTPUT::

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

- 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

  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

- 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

   required, you can uncheck them

.. note::

   64bit: You also need to install the Microsoft Windows SDK for .NET 3.5 SP1 (.NET 4.0 won't work).

   Download from: http://www.microsoft.com/en-us/download/details.aspx?id=3138

  .. note::

     64bit: Download and install the 64bit version.

     http://sourceforge.net/projects/pywin32/files/pywin32/Build%20218/pywin32-218.win-amd64-py2.7.exe/download

Step4 - Python BIN

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

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

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

    large traffic (large amount of users, CI servers etc). RhodeCode can be

    scaled horizontally on one (recommended) or multiple machines. In order

    to scale horizontally you need to do the following:

    - each instance needs it's own .ini file and unique `instance_id` set in them

      shared disk storage, preferably together with repositories. This `data`

      dir contains template caches, sessions, whoosh index and it's used for

      tasks locking (so it's safe across multiple instances). Set the

      `cache_dir`, `index_dir`, `beaker.cache.data_dir`, `beaker.cache.lock_dir`

    - 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

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

    def check_group(environ, match_dict):

        """

        :param environ:

        :param match_dict:

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

from pylons import request

from pylons import tmpl_context as c, url

from webhelpers.paginate import Page

                    Session().commit()

                    return 'ok'

        except Exception:

            log.error(traceback.format_exc())

        return 'fail'

                    Session().commit()

                    return 'ok'

        except Exception:

            log.error(traceback.format_exc())

        return 'fail'

        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)

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

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_users_group(self, repo_name):

        """

        :param repo_name:

        """

        except Exception:

            log.error(traceback.format_exc())

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

                    category='error')

            raise HTTPInternalServerError()

    rhodecode.controllers.admin.repos_groups

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

    :created_on: Mar 23, 2010

    :author: marcink

    @HasReposGroupPermissionAnyDecorator('group.admin')

    def delete_repos_group_user_perm(self, group_name):

        """

        :param group_name:

        """

    @HasReposGroupPermissionAnyDecorator('group.admin')

    def delete_repos_group_users_group_perm(self, group_name):

        """

        :param group_name:

        """

        except Exception:

            log.error(traceback.format_exc())

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

                    category='error')

            raise HTTPInternalServerError()

    @NotAnonymous()

    def my_account_my_pullrequests(self):

                                .filter(PullRequest.user_id ==

                                        self.rhodecode_user.user_id)\

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

    rhodecode.controllers.admin.users_groups

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

    :created_on: Jan 25, 2011

    :author: marcink

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

    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(

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

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

        return redirect(url('users_groups'))

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

        #           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({

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

        #    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'))

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

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

                        category='success')

            else:

                        category='success')

            if grant_fork_perm:

                        category='success')

            else:

                        category='success')

            Session().commit()

    HasPermissionAllDecorator, HasPermissionAnyDecorator, \

    HasPermissionAnyApi, HasRepoPermissionAnyApi

from rhodecode.lib.utils import map_groups, repo2db_mapper

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.permission import PermissionModel

from rhodecode.model.db import Repository, RhodeCodeSetting, UserIpMap

def get_users_group_or_error(usersgroupid):

    """

    :param userid:

    """

    if users_group is None:

    return users_group

        if isinstance(userid, Optional):

            userid = apiuser.user_id

        user = get_user_or_error(userid)

        try:

            if locked:

                Repository.lock(repo, user.user_id)

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, usersgroupid):

        """"

        :param apiuser:

        :param usersgroupid:

    @HasPermissionAllDecorator('hg.admin')

    def get_users_groups(self, apiuser):

        """"

        :param apiuser:

        """

        result = []

            result.append(users_group.get_api_data())

        return result

        :param active:

        """

        try:

            active = Optional.extract(active)

            Session().commit()

            return dict(

                users_group=ug.get_api_data()

            )

        except Exception:

    @HasPermissionAllDecorator('hg.admin')

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

        """"

        :param apiuser:

        :param usersgroupid:

        users_group = get_users_group_or_error(usersgroupid)

        try:

            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'

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                    users_group.users_group_name

                )

            )

        users_group = get_users_group_or_error(usersgroupid)

        try:

                                                               user)

                        user.username, users_group.users_group_name

                    )

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

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                        users_group.users_group_name

                    )

            )

    def grant_users_group_permission(self, apiuser, repoid, usersgroupid,

                                     perm):

        """

        existing one if found

        :param apiuser:

            Session().commit()

            return dict(

                    'repo: `%s`' % (

                    perm.permission_name, users_group.users_group_name,

                    repo.repo_name