c097458480a5972dd75d5695b61e855fd0ab371e rhodecode-0.0.0.7.0

8bdec09436cb7e4a764bd2ba50b84060e30eb34f rhodecode-0.0.0.7.1

1a18994cdc3bdd156ee93c7c0fb8d94a88f1f640 rhodecode-0.0.0.7.2

a3a7c3e03b76ee264a828cb1087970bb98bbffcd rhodecode-0.0.0.7.3

58b46f9194c347641bfc9a26697ef413a4761971 rhodecode-0.0.0.7.4

710e7a75bb6b8346cee3bd0ddda67592e4790268 rhodecode-0.0.0.7.5

ca80f8c0056211dad33483a50b913593516d7a6c rhodecode-0.0.0.7.6

0cf49c29c846fefeb4e1a222e4b1850e9e3eaa62 rhodecode-0.0.0.7.7

702c7e565c56a49c89414e81f28571c8e5b67408 rhodecode-0.0.0.7.8

c12f4d19c95065f313eefcd45eac9ef507f5fa55 rhodecode-0.0.0.7.9

558eb7c5028f24a90b5466ed16be13b213ba1fc2 rhodecode-0.0.0.8.0

a9814a642e11092b243ca01721254a04633a0ffc rhodecode-0.0.0.8.1

ccbe729908844884aea89d00fb14a6cb92e10c06 rhodecode-0.0.0.8.2

ca41d544dbdfd2f81bd0304168492a26276aadb6 rhodecode-0.0.0.8.3

2fa16ec5822da0c6fade3dd1ed9b6c0655e5dbbf rhodecode-0.0.0.8.4

16ba57d8fe2317c49dbd422afd07ab497687aa02 rhodecode-0.0.0.8.5

53128b6b9a4ddb6ee9554cbb83a082a6d1316b42 rhodecode-0.0.1.0.0rc4

afd98d1f817e6a6b52172735c22160239e615a6b rhodecode-0.0.1.0.0

bee56f209c40a6880f2f633b02227b5ee1f8ff5a rhodecode-0.0.1.0.1

d85b0948e53925ebbbc49e9f7967013a04f866e9 rhodecode-0.0.1.0.2

d9c8dddb96af521e346f05b88d515c536eef3d17 rhodecode-0.0.1.1.0

344f748517814ed0408a49e392dc625f4cc37fdc rhodecode-0.0.1.1.1

6c01c12eafb8cc72d4c4cbd121400fad755b2862 rhodecode-0.0.1.1.2

4fa80e0484ef5c33feaa9c39fc66916f410ba353 rhodecode-0.0.1.1.3

cb77867d69d3c5931712aac486c980a42ee90745 rhodecode-0.0.1.1.5

cb77867d69d3c5931712aac486c980a42ee90745 rhodecode-0.0.1.1.5

008bdfdd95c8bd31ae6d89f76c75c1f49cbcd0bc rhodecode-0.0.1.1.5

c5af1d3c861fb36b156224e75c2f55a97f54657d rhodecode-0.0.1.1.6

7327a0d1584cf28d33e738048af1f6809d499451 rhodecode-0.0.1.1.7

bd102f45950f779995a1beae42b6eb099cdd27b3 rhodecode-0.0.1.1.7

c8974135732aa0ceb841cee6df66e29f089b4963 rhodecode-0.0.1.1.8

c252049af24cd98eef5f4143fa3abbff3c912e29 rhodecode-0.0.1.2.0

0b8fba8ab90b01f811a50e6e7384989cced21d38 rhodecode-0.0.1.2.1

22273bec00ba2fd860c60a9277d3d7229e288e18 rhodecode-0.0.1.2.2

1ff606a7858dbd8a5f70b3da5cc89524bd0d84f9 rhodecode-0.0.1.2.3

a7a282a902b207ce34e830d643c79b7ab52e3b35 rhodecode-0.0.1.2.4

b6b611e7722e754abebaae6e265cbb4c823d344d rhodecode-0.0.1.2.5

dbc82e3362a25d2aece42060089824c4342efd17 rhodecode-0.0.1.3.0

79a95f338fd0115b2cdb77118f39e17d22ff505c rhodecode-0.0.1.3.1

9ab21c5ddb84935bea5c743b4e147ed5a398b30c rhodecode-0.0.1.3.2

934906f028b582a254e0028ba25e5d20dd32b9cd rhodecode-0.0.1.3.3

af21362474e3ab5aa0e2fbb1c872356f2c16c4f3 rhodecode-0.0.1.3.4

0e2792e04bd316fe64335cbe6a476031ac60b29b rhodecode-0.0.1.3.5

edfff9f37916389144d3a3644d0a7d7adfd79b11 rhodecode-0.0.1.3.6

9ae95fdeca184f2404205645f06c6597b74ef2db rhodecode-0.0.1.4.0

909143a4dde53c46d4f24abb426ec870471c7de1 rhodecode-0.0.1.4.1

d998cc84cf726798486a438763053f0e1dc1b646 rhodecode-0.0.1.4.2

3f5d40b9dd99ccb009ea2211ee2d4b594c634946 rhodecode-0.0.1.4.3

3148c08cf86f1849917e2d50f7ab7766c1550b0a rhodecode-0.0.1.4.4

a5f0bc867edc88be23eb808693e5393a97d4c54a rhodecode-0.0.1.5.0

3259dc7caea48687eab018ee646ae6ad7e7ef377 rhodecode-0.0.1.5.1

efe23d6c178c11d575a0214181276a3452776e48 rhodecode-0.0.1.5.2

1a498b11f1540f5b94b6f6009298f5dc3eaad9e9 rhodecode-0.0.1.5.3

3447862ad8c9ceba85857774c526e39fde3a2281 rhodecode-0.0.1.5.4

c15d7b336af58df9f1bbc8f8957464e7ea618d4c rhodecode-0.0.1.6.0rc1

78b53ee0d247f90d51b028307ff5717851b6c265 rhodecode-0.0.1.6.0

351ad34d56321349ff5bd38f537bd768b8efef2e rhodecode-0.0.1.7.0

1f71ef689d2a3c9978cea6591a1f4e9107a5ca83 rhodecode-0.0.1.7.1

d17e88a1a88a29f6fac948c94498129e405a40d3 0.1

ad0ce803b40cb17fc3988373052943e041030b02 0.2

c6e32714336345403adf76abb6ebf9b8116fcdc7 0.2.1

    error:  null

get_repo_nodes

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

Return a list of files and directories for a given path at the given revision.

It is possible to specify ret_type to show only ``files`` or ``dirs``.

This command can only be executed using the api_key of a user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "get_repo_nodes"

    args:     {

                "repoid" : "<reponame or repo_id>"

                "revision"  : "<revision>",

                "root_path" : "<root_path>",

                "ret_type"  : "<ret_type> = Optional('all')"

              }

OUTPUT::

    id : <id_given_in_input>

    result: [

              {

                "name" :        "<name>"

                "type" :        "<type>",

              },

              …

            ]

    error:  null

create_repo

-----------

Create a repository. If the repository name contains "/", all needed repository

groups will be created. For example "foo/bar/baz" will create repository groups

"foo", "bar" (with "foo" as parent), and create "baz" repository with

"bar" as group.

This command can only be executed using the api_key of a user with admin rights,

or that of a regular user with create repository permission.

Regular users cannot specify owner parameter.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "create_repo"

    args:     {

                "repo_name" :        "<reponame>",

                "owner" :            "<onwer_name_or_id = Optional(=apiuser)>",

                "repo_type" :        "<repo_type> = Optional('hg')",

                "description" :      "<description> = Optional('')",

                "private" :          "<bool> = Optional(False)",

                "clone_uri" :        "<clone_uri> = Optional(None)",

                "landing_rev" :      "<landing_rev> = Optional('tip')",

                "enable_downloads":  "<bool> = Optional(False)",

                "enable_locking":    "<bool> = Optional(False)",

                "enable_statistics": "<bool> = Optional(False)",

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "msg": "Created new repository `<reponame>`",

              "repo": {

                "repo_id" :          "<repo_id>",

                "repo_name" :        "<reponame>"

                "repo_type" :        "<repo_type>",

                "clone_uri" :        "<clone_uri>",

                "private": :         "<bool>",

                "created_on" :       "<datetimecreated>",

                "description" :      "<description>",

                "landing_rev":       "<landing_rev>",

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

                "fork_of":           "<name_of_fork_parent>",

                "enable_downloads":  "<bool>",

                "enable_locking":    "<bool>",

                "enable_statistics": "<bool>",

              },

            }

    error:  null

fork_repo

---------

Create a fork of the given repo. If using Celery, this will

return success message immediately and a fork will be created

asynchronously.

Regular users cannot specify owner parameter.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "fork_repo"

    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

-----------

Delete a repository.

This command can only be executed using the api_key of a user with admin rights,

or that of a regular user with admin access to the repository.

When ``forks`` param is set it is possible to detach or delete forks of the deleted repository.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "delete_repo"

    args:     {

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

                "forks"  : "`delete` or `detach` = Optional(None)"

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

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

              "success": true

            }

    error:  null

grant_user_permission

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

Grant permission for a user on the given repository, or update the existing one if found.

This command can only be executed using the api_key of a user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "grant_user_permission"

    args:     {

                "repoid" : "<reponame or repo_id>"

                "userid" : "<username or user_id>"

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

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

              "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",

              "success": true

            }

    error:  null

revoke_user_permission

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

Revoke permission for a user on the given repository.

This command can only be executed using the api_key of a user with admin rights.

INPUT::

    id : <id_for_response>

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

"""

kallithea.__init__

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

Kallithea, a web based repository management based on pylons

versioning implementation: http://www.python.org/dev/peps/pep-0386/

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 9, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, (C) 2014 Bradley M. Kuhn, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import sys

import platform

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

CELERY_EAGER = False

# link to config for pylons

CONFIG = {}

# Linked module for extensions

EXTENSIONS = {}

# BRAND controls internal references in database and config to the products

# own name.

#

# NOTE: If you want compatibility with a database that was originally created

#  for use with the RhodeCode software product, change BRAND to "rhodecode",

#  either by editing here or by creating a new file:

#  echo "BRAND = 'rhodecode'" > kallithea/brand.py

BRAND = "kallithea"

try:

    from kallithea.brand import BRAND

except ImportError:

    pass

# Prefix for the ui and settings table names

DB_PREFIX = (BRAND + "_") if BRAND != "kallithea" else ""

# Users.extern_type and .extern_name value for local users

EXTERN_TYPE_INTERNAL = BRAND if BRAND != 'kallithea' else 'internal'

# db_migrate_version.repository_id value, same as kallithea/lib/dbmigrate/migrate.cfg

DB_MIGRATIONS = BRAND + "_db_migrations"

try:

    from kallithea.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('%s' % _rev[0],)

except ImportError:

    pass

__version__ = ('.'.join((str(each) for each in VERSION[:3])))

__dbversion__ = 31  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = "Various Authors"

__url__ = 'https://kallithea-scm.org/'

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

if len(VERSION) > 3:

    __version__ += '.'+VERSION[3]

    if len(VERSION) > 4:

        __version__ += VERSION[4]

    else:

        __version__ += '0'

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during update of user password'),

                        category='error')

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

    def my_account_repos(self):

        c.active = 'repos'

        self.__load_data()

        #json used to render the grid

        c.data = self._load_my_repos_data()

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

    def my_account_watched(self):

        c.active = 'watched'

        self.__load_data()

        #json used to render the grid

        c.data = self._load_my_repos_data(watched=True)

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

    def my_account_perms(self):

        c.active = 'perms'

        self.__load_data()

        c.perm_user = AuthUser(user_id=self.authuser.user_id)

        c.ip_addr = self.ip_addr

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

    def my_account_emails(self):

        c.active = 'emails'

        self.__load_data()

        c.user_email_map = UserEmailMap.query()\

            .filter(UserEmailMap.user == c.user).all()

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

    def my_account_emails_add(self):

        email = request.POST.get('new_email')

        try:

            UserModel().add_extra_email(self.authuser.user_id, email)

            Session().commit()

            h.flash(_("Added email %s to user") % email, category='success')

        except formencode.Invalid, error:

            msg = error.error_dict['email']

            h.flash(msg, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during email saving'),

                    category='error')

        return redirect(url('my_account_emails'))

    def my_account_emails_delete(self):

        email_id = request.POST.get('del_email_id')

        user_model = UserModel()

        user_model.delete_extra_email(self.authuser.user_id, email_id)

        Session().commit()

        h.flash(_("Removed email from user"), category='success')

        return redirect(url('my_account_emails'))

    def my_account_api_keys(self):

        c.active = 'api_keys'

        self.__load_data()

        show_expired = True

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

        c.user_api_keys = ApiKeyModel().get_api_keys(self.authuser.user_id,

                                                     show_expired=show_expired)

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

    def my_account_api_keys_add(self):

        lifetime = safe_int(request.POST.get('lifetime'), -1)

        description = request.POST.get('description')

        ApiKeyModel().create(self.authuser.user_id, description, lifetime)

        Session().commit()

        h.flash(_("API key successfully created"), category='success')

        return redirect(url('my_account_api_keys'))

    def my_account_api_keys_delete(self):

        api_key = request.POST.get('del_api_key')

        user_id = self.authuser.user_id

        if request.POST.get('del_api_key_builtin'):

            user = User.get(user_id)

            if user:

                Session().add(user)

                Session().commit()

                h.flash(_("API key successfully reset"), category='success')

        elif api_key:

            ApiKeyModel().delete(api_key, self.authuser.user_id)

            Session().commit()

            h.flash(_("API key successfully deleted"), category='success')

        return redirect(url('my_account_api_keys'))

            h.flash(_('Successfully deleted user'), category='success')

        except (UserOwnsReposException, DefaultUserException), e:

            h.flash(e, category='warning')

        except Exception:

            log.error(traceback.format_exc())

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

                    category='error')

        return redirect(url('users'))

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

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

        # url('user', id=ID)

        User.get_or_404(-1)

    def _get_user_or_raise_if_default(self, id):

        try:

            return User.get_or_404(id, allow_default=False)

        except DefaultUserException:

            h.flash(_("The default user cannot be edited"), category='warning')

            raise HTTPNotFound

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

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

        # url('edit_user', id=ID)

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'profile'

        c.extern_type = c.user.extern_type

        c.extern_name = c.user.extern_name

        c.perm_user = AuthUser(user_id=id)

        c.ip_addr = self.ip_addr

        defaults = c.user.get_dict()

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def edit_advanced(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'advanced'

        c.perm_user = AuthUser(user_id=id)

        c.ip_addr = self.ip_addr

        umodel = UserModel()

        defaults = c.user.get_dict()

        defaults.update({

            'create_repo_perm': umodel.has_perm(c.user, 'hg.create.repository'),

            'create_user_group_perm': umodel.has_perm(c.user,

                                                      'hg.usergroup.create.true'),

            'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'),

        })

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def edit_api_keys(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'api_keys'

        show_expired = True

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

        c.user_api_keys = ApiKeyModel().get_api_keys(c.user.user_id,

                                                     show_expired=show_expired)

        defaults = c.user.get_dict()

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def add_api_key(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        lifetime = safe_int(request.POST.get('lifetime'), -1)

        description = request.POST.get('description')

        ApiKeyModel().create(c.user.user_id, description, lifetime)

        Session().commit()

        h.flash(_("API key successfully created"), category='success')

        return redirect(url('edit_user_api_keys', id=c.user.user_id))

    def delete_api_key(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        api_key = request.POST.get('del_api_key')

        if request.POST.get('del_api_key_builtin'):

            user = User.get(c.user.user_id)

            if user:

                Session().add(user)

                Session().commit()

                h.flash(_("API key successfully reset"), category='success')

        elif api_key:

            ApiKeyModel().delete(api_key, c.user.user_id)

            Session().commit()

            h.flash(_("API key successfully deleted"), category='success')

        return redirect(url('edit_user_api_keys', id=c.user.user_id))

    def update_account(self, id):

        pass

    def edit_perms(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'perms'

        c.perm_user = AuthUser(user_id=id)

        c.ip_addr = self.ip_addr

        umodel = UserModel()

        defaults = c.user.get_dict()

        defaults.update({

            'create_repo_perm': umodel.has_perm(c.user, 'hg.create.repository'),

            'create_user_group_perm': umodel.has_perm(c.user,

                                                      'hg.usergroup.create.true'),

            'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'),

        })

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def update_perms(self, id):

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

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

        user = self._get_user_or_raise_if_default(id)

        try:

            form = CustomDefaultPermissionsForm()()

            form_result = form.to_python(request.POST)

            inherit_perms = form_result['inherit_default_permissions']

            user.inherit_default_permissions = inherit_perms

            Session().add(user)

            user_model = UserModel()

            defs = UserToPerm.query()\

                .filter(UserToPerm.user == user)\

                .all()

            for ug in defs:

                Session().delete(ug)

            if form_result['create_repo_perm']:

                user_model.grant_perm(id, 'hg.create.repository')

            else:

                user_model.grant_perm(id, 'hg.create.none')

            if form_result['create_user_group_perm']:

                user_model.grant_perm(id, 'hg.usergroup.create.true')

            else:

                user_model.grant_perm(id, 'hg.usergroup.create.false')

            if form_result['fork_repo_perm']:

                user_model.grant_perm(id, 'hg.fork.repository')

            else:

                user_model.grant_perm(id, 'hg.fork.none')

            h.flash(_("Updated permissions"), category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during permissions saving'),

                    category='error')

        return redirect(url('edit_user_perms', id=id))

    def edit_emails(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'emails'

        c.user_email_map = UserEmailMap.query()\

            .filter(UserEmailMap.user == c.user).all()

        defaults = c.user.get_dict()

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def add_email(self, id):

        """POST /user_emails:Add an existing item"""

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

        user = self._get_user_or_raise_if_default(id)

        email = request.POST.get('new_email')

        user_model = UserModel()

        try:

            user_model.add_extra_email(id, email)

            Session().commit()

            owner = apiuser.user_id

        owner = get_user_or_error(owner)

        if RepoModel().get_by_repo_name(repo_name):

            raise JSONRPCError("repo `%s` already exist" % repo_name)

        defs = Setting.get_default_repo_settings(strip_prefix=True)

        if isinstance(private, Optional):

            private = defs.get('repo_private') or Optional.extract(private)

        if isinstance(repo_type, Optional):

            repo_type = defs.get('repo_type')

        if isinstance(enable_statistics, Optional):

            enable_statistics = defs.get('repo_enable_statistics')

        if isinstance(enable_locking, Optional):

            enable_locking = defs.get('repo_enable_locking')

        if isinstance(enable_downloads, Optional):

            enable_downloads = defs.get('repo_enable_downloads')

        clone_uri = Optional.extract(clone_uri)

        description = Optional.extract(description)

        landing_rev = Optional.extract(landing_rev)

        copy_permissions = Optional.extract(copy_permissions)

        try:

            repo_name_cleaned = repo_name.split('/')[-1]

            # create structure of groups and return the last group

            repo_group = map_groups(repo_name)

            data = dict(

                repo_name=repo_name_cleaned,

                repo_name_full=repo_name,

                repo_type=repo_type,

                repo_description=description,

                owner=owner,

                repo_private=private,

                clone_uri=clone_uri,

                repo_group=repo_group,

                repo_landing_rev=landing_rev,

                enable_statistics=enable_statistics,

                enable_locking=enable_locking,

                enable_downloads=enable_downloads,

                repo_copy_permissions=copy_permissions,

            )

            task = RepoModel().create(form_data=data, cur_user=owner)

            from celery.result import BaseAsyncResult

            task_id = None

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

            # no commit, it's done in RepoModel, or async via celery

            return dict(

                msg="Created new repository `%s`" % (repo_name,),

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

                               # can be done async

                task=task_id

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

    def update_repo(self, apiuser, repoid, name=Optional(None),

                    owner=Optional(OAttr('apiuser')),

                    group=Optional(None),

                    description=Optional(''), private=Optional(False),

                    clone_uri=Optional(None), landing_rev=Optional('rev:tip'),

                    enable_statistics=Optional(False),

                    enable_locking=Optional(False),

                    enable_downloads=Optional(False)):

        """

        Updates repo

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param name:

        :param owner:

        :param group:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        :param enable_statistics:

        :param enable_locking:

        :param enable_downloads:

        """

        repo = get_repo_or_error(repoid)

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

            # check if we have admin permission for this repo !

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

                                                               repo_name=repo.repo_name):

                raise JSONRPCError('repository `%s` does not exist' % (repoid,))

        updates = {

            # update function requires this.

            'repo_name': repo.repo_name

        }

        repo_group = group

        if not isinstance(repo_group, Optional):

            repo_group = get_repo_group_or_error(repo_group)

            repo_group = repo_group.group_id

        try:

            store_update(updates, name, 'repo_name')

            store_update(updates, repo_group, 'repo_group')

            store_update(updates, owner, 'user')

            store_update(updates, description, 'repo_description')

            store_update(updates, private, 'repo_private')

            store_update(updates, clone_uri, 'clone_uri')

            store_update(updates, landing_rev, 'repo_landing_rev')

            store_update(updates, enable_statistics, 'repo_enable_statistics')

            store_update(updates, enable_locking, 'repo_enable_locking')

            store_update(updates, enable_downloads, 'repo_enable_downloads')

            RepoModel().update(repo, **updates)

            Session().commit()

            return dict(

                msg='updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),

                repository=repo.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update repo `%s`' % repoid)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    def fork_repo(self, apiuser, repoid, fork_name,

                  owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('rev:tip')):

        """

        Creates a fork of given repo. In case of using celery this will

        immediately return success message, while fork is going to be created

        asynchronous. This command can be executed only using api_key belonging to

        user with admin rights or regular user that have fork permission, and at least

        read access to forking repository. Regular users cannot specify owner parameter.

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param fork_name:

        :param owner:

        :param description:

        :param copy_permissions:

        :param private:

        :param landing_rev:

        INPUT::

            id : <id_for_response>

            api_key : "<api_key>"

            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,

                      "task": "<celery task id or None if done sync>"

                    }

            error:  null

        """

        repo = get_repo_or_error(repoid)

        repo_name = repo.repo_name

        _repo = RepoModel().get_by_repo_name(fork_name)

        if _repo:

            type_ = 'fork' if _repo.fork else 'repo'

            raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))

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