args:     {

                "repoid" :          "<reponame or repo_id>",

                "fork_name":        "<forkname>",

                "owner":            "<username or user_id = Optional(=apiuser)>",

                "description":      "<description>",

                "copy_permissions": "<bool>",

                "private":          "<bool>",

                "landing_rev":      "<landing_rev>"

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "msg": "Created fork of `<reponame>` as `<forkname>`",

              "success": true

            }

    error:  null

delete_repo

-----------

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "delete_repo"

    args:     {

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "msg": "Deleted repository `<reponame>`",

              "success": true

            }

    error:  null

grant_user_permission

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

Grant permission for user on given repository, or update 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>"

from formencode import htmlfill

from webob.exc import HTTPInternalServerError, HTTPForbidden

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

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

import rhodecode

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, HasRepoPermissionAllDecorator, NotAnonymous,\

    HasPermissionAny, HasReposGroupPermissionAny, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\

    RhodeCodeSetting, RepositoryField

from rhodecode.model.forms import RepoForm, RepoFieldForm, RepoPermsForm

from rhodecode.model.scm import ScmModel, GroupList

from rhodecode.model.repo import RepoModel

from rhodecode.lib.compat import json

from sqlalchemy.sql.expression import func

log = logging.getLogger(__name__)

class ReposController(BaseRepoController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        acl_groups = GroupList(RepoGroup.query().all(),

                               perm_set=['group.write', 'group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)

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

        repo_model = RepoModel()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: 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('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.not_mapped_error(repo_name)

            return redirect(url('repos'))

        try:

            _forks = repo.forks.count()

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Deleted repository %s') % repo_name, category='success')

            Session().commit()

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

    @HasRepoPermissionAllDecorator('repository.admin')

    def set_repo_perm_member(self, repo_name):

        form = RepoPermsForm()().to_python(request.POST)

        perms_new = form['perms_new']

        perms_updates = form['perms_updates']

        cur_repo = repo_name

        # update permissions

        for member, perm, member_type in perms_updates:

            if member_type == 'user':

                # this updates existing one

                RepoModel().grant_user_permission(

                    repo=cur_repo, user=member, perm=perm

                )

            else:

                RepoModel().grant_users_group_permission(

                    repo=cur_repo, group_name=member, perm=perm

                repo_name_full=fork_name,

                repo_group=group,

                repo_type=repo.repo_type,

                description=Optional.extract(description),

                private=Optional.extract(private),

                copy_permissions=Optional.extract(copy_permissions),

                landing_rev=Optional.extract(landing_rev),

                update_after_clone=False,

                fork_parent_id=repo.repo_id,

            )

            RepoModel().create_fork(form_data, cur_user=owner)

            return dict(

                msg='Created fork of `%s` as `%s`' % (repo.repo_name,

                                                      fork_name),

                success=True  # cannot return the repo data here since fork

                              # cann be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to fork repository `%s` as `%s`' % (repo_name,

                                                            fork_name)

            )

        """

        Deletes a given repository

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

        try:

            Session().commit()

            return dict(

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to delete repository `%s`' % repo.repo_name

            )

    @HasPermissionAllDecorator('hg.admin')

    def grant_user_permission(self, apiuser, repoid, userid, perm):

        """

        Grant permission for user on given repository, or update existing one

        if found

        :param repoid:

        :param userid:

        :param perm:

        """

        repo = get_repo_or_error(repoid)

        user = get_user_or_error(userid)

        perm = get_perm_or_error(perm)

        try:

class LdapConnectionError(Exception):

    pass

class LdapImportError(Exception):

    pass

class DefaultUserException(Exception):

    pass

class UserOwnsReposException(Exception):

    pass

class UserGroupsAssignedException(Exception):

    pass

class StatusChangeOnClosedPullRequestError(Exception):

    pass

class HTTPLockedRC(HTTPClientError):

    """

    Special Exception For locked Repos in RhodeCode, the return code can

    be overwritten by _code keyword argument passed into constructors

    """

    code = 423

    title = explanation = 'Repository Locked'

    def __init__(self, reponame, username, *args, **kwargs):

        from rhodecode import CONFIG

        from rhodecode.lib.utils2 import safe_int

        _code = CONFIG.get('lock_ret_code')

        self.code = safe_int(_code, self.code)

        self.title = self.explanation = ('Repository `%s` locked by '

                                         'user `%s`' % (reponame, username))

        super(HTTPLockedRC, self).__init__(*args, **kwargs)

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import shutil

import logging

import traceback

from datetime import datetime

from rhodecode.lib.vcs.backends import get_backend

from rhodecode.lib.compat import json

from rhodecode.lib.utils2 import LazyProperty, safe_str, safe_unicode,\

    remove_prefix, obfuscate_url_pw

from rhodecode.lib.caching_query import FromCache

from rhodecode.lib.hooks import log_create_repository, log_delete_repository

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, UserRepoToPerm, User, Permission, \

    Statistics, UserGroup, UserGroupRepoToPerm, RhodeCodeUi, RepoGroup,\

    RhodeCodeSetting, RepositoryField

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    cls = Repository

    URL_SEPARATOR = Repository.url_sep()

    def __get_users_group(self, users_group):

        return self._get_instance(UserGroup, users_group,

                                  callback=UserGroup.get_by_group_name)

    def _get_repos_group(self, repos_group):

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        fork_of = form_data.get('fork_parent_id')

        ## repo creation defaults, private and repo_type are filled in form

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        enable_statistics = defs.get('repo_enable_statistics')

        enable_locking = defs.get('repo_enable_locking')

        enable_downloads = defs.get('repo_enable_downloads')

        return self.create_repo(

            repo_name, repo_type, description, owner, private, clone_uri,

            repos_group, landing_rev, just_db, fork_of, copy_fork_permissions,

            enable_statistics, enable_locking, enable_downloads

        )

    def create_fork(self, form_data, cur_user):

        """

        Simple wrapper into executing celery task for fork creation

        :param form_data:

        :param cur_user:

        """

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

        repo = self._get_repo(repo)

        if repo:

            old_repo_dict = repo.get_dict()

            owner = repo.user

            try:

                self.sa.delete(repo)

                self.__delete_repo(repo)

                log_delete_repository(old_repo_dict,

                                      deleted_by=owner.username)

            except Exception:

                log.error(traceback.format_exc())

                raise

    def grant_user_permission(self, repo, user, perm):

        """

        Grant permission for user on given repository, or update existing one

        if found

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        user = self._get_user(user)

        repo = self._get_repo(repo)

        permission = self._get_perm(perm)