========================

``RhodeCode`` is a fast and powerful management tool for Mercurial_ and GIT_ 

It works on http/https and has a built in permission/authentication system with 

simple API so it's easy integrable with existing external systems.

RhodeCode is similar in some respects to github or bitbucket_, 

This command can be executed only using api_key belonging to user with admin 

rights.

INPUT::

    api_key : "<api_key>"

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

belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

            ]

    error:  null

create_user

-----------

Creates new user or updates current one if such user exists. This command can 

be executed only using api_key belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

            }

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

             }

    error : null

get_users_groups

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

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

api_key belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

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

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

            }

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

            }

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

            }

    error:  null

get_repos

---------

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

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

`dirs`. This command can be executed only using api_key belonging to user 

with admin rights

INPUT::

    api_key : "<api_key>"

    error:  null

create_repo

-----------

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

OUTPUT::

    result: {

            }

    error:  null

INPUT::

    api_key : "<api_key>"

    args:     {

                "repo_name" :  "<reponame>",

                "username" :   "<username>",

              }

OUTPUT::

    result: {

            }

    error:  null

INPUT::

    api_key : "<api_key>"

    args:     {

                "repo_name" :  "<reponame>",

              }

OUTPUT::

    result: {

            }

        from rhodecode.lib.profiler import ProfilingMiddleware

        app = ProfilingMiddleware(app)

        # Handle Python exceptions

        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])

        app = Cascade([static_app, app])

        app = make_gzip_middleware(app, global_conf, compress_level=1)

    app.config = config

    return app

                                            function=check_repo))

        #ajax delete repo perm user

        m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",

        #ajax delete repo perm users_group

        m.connect('delete_repo_users_group',

                  "/repos_delete_users_group/{repo_name:.*}",

        m.connect('repo_cache', "/repos_cache/{repo_name:.*}",

                  action="repo_cache", conditions=dict(method=["DELETE"],

                                                       function=check_repo))

                  action="repo_public_journal", conditions=dict(method=["PUT"],

                                                        function=check_repo))

        m.connect('repo_pull', "/repo_pull/{repo_name:.*}",

        m.connect("formatted_repos_group", "/repos_groups/{id}.{format}",

                  action="show", conditions=dict(method=["GET"],

                                                 function=check_int))

    #ADMIN USER REST ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",

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

    #ADMIN MAIN PAGES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/admin') as m:

                  action='add_repo')

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

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='api/api') as m:

        m.connect('api', '/api')

    #USER JOURNAL

    rmap.connect('journal', '%s/journal' % ADMIN_PREFIX, controller='journal')

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

                 controller='followers', action='followers',

                 conditions=dict(function=check_repo))

    return rmap

    rhodecode.controllers.admin.repos

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

    :created_on: Apr 7, 2010

    :author: marcink

        return redirect(url('repos'))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_user(self, repo_name):

        """

        """

        try:

            Session.commit()

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

                    category='error')

            raise HTTPInternalServerError()

        :param repo_name:

        """

        try:

            Session.commit()

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

                      ' users groups'),

                    category='error')

        """

        try:

            Session.commit()

        except Exception, e:

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

    rhodecode.controllers.admin.repos_groups

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

    :created_on: Mar 23, 2010

    :author: marcink

from formencode import htmlfill

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

from rhodecode.lib import helpers as h

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import RepoGroup

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        data['group_name'] = repo_group.name

        return data

    @HasPermissionAnyDecorator('hg.admin')

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

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

        # url('repos_groups')

        sk = lambda g: g.parents[0].group_name if g.parents else g.group_name

        c.groups = sorted(RepoGroup.query().all(), key=sk)

        return render('admin/repos_groups/repos_groups_show.html')

                                          c.repo_groups_choices)()

        try:

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

            Session.commit()

            h.flash(_('created repos group %s') \

                    % form_result['group_name'], category='success')

        self.__load_defaults()

        c.repos_group = RepoGroup.get(id)

        try:

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

            ReposGroupModel().update(id, form_result)

        return redirect(url('repos_groups'))

    def show_by_name(self, group_name):

        id_ = RepoGroup.get_by_group_name(group_name).group_id

        return self.show(id_)

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

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

        # url('repos_group', id=ID)

        defaults = self.__load_data(id_)

        # we need to exclude this group from the group list for editing

        return htmlfill.render(

            render('admin/repos_groups/repos_groups_edit.html'),

            for g in groups:

                group = RepoGroup.get_by_group_name(g)

                if not group:

                parent_id = group.group_id

            repo = RepoModel().create(

            raise JSONRPCError('failed to create repository %s' % repo_name)

    @HasPermissionAnyDecorator('hg.admin')

        """

        :param repo_name:

        :param username:

        :param perm:

            if repo is None:

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

            Session.commit()

            return dict(

                    perm, username, repo_name

                )

            )

            )

    @HasPermissionAnyDecorator('hg.admin')

        """

        :param repo_name:

        :param group_name:

        :param perm:

            if repo is None:

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

                raise JSONRPCError('unknown users group %s' % user_group)

            Session.commit()

            return dict(

                    perm, group_name, repo_name

                )

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                )

            )

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

log = logging.getLogger(__name__)

        super(HomeController, self).__before__()

    def index(self):

        c.repos_list = self.scm_model.get_repos()

        return render('/index.html')

import os

import re

def __get_lem():

    from pygments import lexers

    except (ImportError, UnicodeDecodeError, Exception):

        return unicode(str_, from_encoding, 'replace')

def safe_str(unicode_, to_encoding='utf8'):

    """

    safe str function. Does few trick to turn unicode_ into string

    return safe_str

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    return ''.join(uri)

def get_changeset_safe(repo, rev):

    """

    Safe version of get_changeset if this changeset doesn't exists for a

                   "was: %s" % err)

        return None

def extract_mentioned_users(s):

    """

    Returns unique usernames from given string s that have @mention