- 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

- 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

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

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

    rhodecode.controllers.admin.users_groups

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

    :created_on: Jan 25, 2011

    :author: marcink

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

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

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

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

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

def get_users_group_or_error(usersgroupid):

    """

    :param userid:

    """

    users_group = UsersGroupModel().get_group(usersgroupid)

    if users_group is None:

    return users_group

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

        """

        """

        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:

    @HasPermissionAllDecorator('hg.admin')

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

        """"

        :param apiuser:

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

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                    users_group.users_group_name

                )

            )

        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"

        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

        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:

            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

                )

    rhodecode.model.user_group

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

    :created_on: Jan 25, 2011

    :author: marcink

                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

    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

    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)

    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)

                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[RK][r_k] = p

        # on given group

        for perm in default_repo_groups_perms:

            rg_k = perm.UserRepoGroupToPerm.group.group_name

            user.permissions[RK][r_k] = p

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

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

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

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

    rhodecode.model.users_group

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

    :created_on: Oct 1, 2011

    :author: nvinot

        %endif

    %endfor

    %for g2p in c.repo_info.users_group_to_perm:

        <tr id="id${id(g2p.users_group.users_group_name)}">

            <td>${h.radio('g_perm_%s' % g2p.users_group.users_group_name,'repository.none')}</td>

            tr.parentNode.removeChild(tr);

        },

        failure:function(o){

        },

    };

    var postData = '_method=delete&users_group_id='+users_group_id;

        </tr>

    %endfor

    %for g2p in c.repos_group.users_group_to_perm:

        <tr id="id${id(g2p.users_group.users_group_name)}">

            <td>${h.radio('g_perm_%s' % g2p.users_group.users_group_name,'group.none')}</td>

            tr.parentNode.removeChild(tr);

        },

        failure:function(o){

        },

    };

    var recursive = YUD.get('recursive').checked;

<%inherit file="/base/base.html"/>

<%def name="title()">

</%def>

                  <tr>

                      <td>

                          <div style="white-space: nowrap">

                          ${h.link_to(h.literal(' » '.join(map(h.safe_unicode,[g.name for g in gr.parents+[gr]]))), url('repos_group_home',group_name=gr.group_name))}

                          </div>

                      </td>

            </table>

            % else:

            % endif

    </div>

<%inherit file="/base/base.html"/>

<%def name="title()">

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))}

    »

    »

</%def>

<%def name="page_nav()">

<%inherit file="/base/base.html"/>

<%def name="title()">

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))}

    »

</%def>

<%def name="page_nav()">

                    <td>

                        ${h.form(url('users_group', id=u_group.users_group_id),method='delete')}

                            ${h.submit('remove_',_('delete'),id="remove_group_%s" % u_group.users_group_id,

                        ${h.end_form()}

                    </td>

                </tr>

                      <ul>

                          <li>${h.link_to(_('admin journal'),h.url('admin_home'),class_='journal')}</li>

                          <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>

                          <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>

                          <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>

                          <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>

                          <li>${h.link_to(_('defaults'),h.url('defaults'),class_='defaults')}</li>

                     ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}

                      <%def name="admin_menu_simple()">

                      <ul>

                      </ul>

                      </%def>

                      ## ADMIN MENU

    def test_index(self):

        self.log_user()

        response = self.app.get(url('repos_groups'))

#    def test_index_as_xml(self):

#        response = self.app.get(url('formatted_repos_groups', format='xml'))