repo-schemas: refactor repository schemas and use it in API update/create functions.

- now it uses consistent way of serializing/validating data
- parent groups are consistenty handled by name parameter
- fixes  #4133
- fixes other problems with bad data
- changes API slightly
- validation chain ordering, first permissions, then uniqness.
  Helps prevent resource disvovery

rhodecode/tests/models/schemas/test_repo_schema.py

@@ -0,0 +1,128 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# 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 Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import colander
+import pytest
+
+from rhodecode.model.validation_schema import types
+from rhodecode.model.validation_schema.schemas import repo_schema
+
+
+class TestRepoSchema(object):
+
+    #TODO:
+    # test nested groups
+
+    @pytest.mark.parametrize('given, expected', [
+        ('my repo', 'my-repo'),
+        (' hello   world mike ', 'hello-world-mike'),
+
+        ('//group1/group2//', 'group1/group2'),
+        ('//group1///group2//', 'group1/group2'),
+        ('///group1/group2///group3', 'group1/group2/group3'),
+        ('word g1/group2///group3', 'word-g1/group2/group3'),
+
+        ('grou p1/gro;,,##up2//.../group3', 'grou-p1/group2/group3'),
+
+        ('group,,,/,,,/1/2/3', 'group/1/2/3'),
+        ('grou[]p1/gro;up2///gro up3', 'group1/group2/gro-up3'),
+        (u'grou[]p1/gro;up2///gro up3/ąć', u'group1/group2/gro-up3/ąć'),
+    ])
+    def test_deserialize_repo_name(self, app, user_admin, given, expected):
+
+        schema = repo_schema.RepoSchema().bind()
+        assert expected == schema.get('repo_name').deserialize(given)
+
+    def test_deserialize(self, app, user_admin):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        schema_data = schema.deserialize(dict(
+            repo_name='dupa',
+            repo_type='hg',
+            repo_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_name'] == 'dupa'
+        assert schema_data['repo_group'] == {
+            'repo_group_id': None,
+            'repo_group_name': types.RootLocation,
+            'repo_name_without_group': 'dupa'}
+
+    @pytest.mark.parametrize('given, err_key, expected_exc', [
+        ('xxx/dupa','repo_group', 'Repository group `xxx` does not exist'),
+        ('', 'repo_name', 'Name must start with a letter or number. Got ``'),
+    ])
+    def test_deserialize_with_bad_group_name(
+            self, app, user_admin, given, err_key, expected_exc):
+
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_name=given,
+                repo_type='hg',
+                repo_owner=user_admin.username
+            ))
+
+        assert excinfo.value.asdict()[err_key] == expected_exc
+
+    def test_deserialize_with_group_name(self, app, user_admin, test_repo_group):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        schema_data = schema.deserialize(dict(
+            repo_name=full_name,
+            repo_type='hg',
+            repo_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_name'] == full_name
+        assert schema_data['repo_group'] == {
+            'repo_group_id': test_repo_group.group_id,
+            'repo_group_name': test_repo_group.group_name,
+            'repo_name_without_group': 'dupa'}
+
+    def test_deserialize_with_group_name_regular_user_no_perms(
+            self, app, user_regular, test_repo_group):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_regular
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_name=full_name,
+                repo_type='hg',
+                repo_owner=user_regular.username
+            ))
+
+        expected = 'Repository group `{}` does not exist'.format(
+            test_repo_group.group_name)
+        assert excinfo.value.asdict()['repo_group'] == expected

rhodecode/api/tests/test_create_repo.py

@@ -1,270 +1,350 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 
 import mock
 import pytest
 
+from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs import settings
+from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateRepo(object):
-    def test_api_create_repo(self, backend):
-        repo_name = 'api-repo-1'
+
+    @pytest.mark.parametrize('given, expected_name, expected_exc', [
+        ('api repo-1', 'api-repo-1', False),
+        ('api-repo 1-ąć', 'api-repo-1-ąć', False),
+        (u'unicode-ąć', u'unicode-ąć', False),
+        ('some repo v1.2', 'some-repo-v1.2', False),
+        ('v2.0', 'v2.0', False),
+    ])
+    def test_api_create_repo(self, backend, given, expected_name, expected_exc):
+
         id_, params = build_data(
             self.apikey,
             'create_repo',
-            repo_name=repo_name,
+            repo_name=given,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
         )
         response = api_call(self.app, params)
 
-        repo = RepoModel().get_by_repo_name(repo_name)
-
-        assert repo is not None
         ret = {
-            'msg': 'Created new repository `%s`' % (repo_name,),
+            'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
-        id_, params = build_data(self.apikey, 'get_repo', repoid=repo_name)
+        repo = RepoModel().get_by_repo_name(safe_unicode(expected_name))
+        assert repo is not None
+
+        id_, params = build_data(self.apikey, 'get_repo', repoid=expected_name)
         response = api_call(self.app, params)
         body = json.loads(response.body)
 
         assert body['result']['enable_downloads'] is False
         assert body['result']['enable_locking'] is False
         assert body['result']['enable_statistics'] is False
 
-        fixture.destroy_repo(repo_name)
+        fixture.destroy_repo(safe_unicode(expected_name))
 
     def test_api_create_restricted_repo_type(self, backend):
         repo_name = 'api-repo-type-{0}'.format(backend.alias)
         id_, params = build_data(
             self.apikey,
             'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
         )
         git_backend = settings.BACKENDS['git']
         with mock.patch(
                 'rhodecode.lib.vcs.settings.BACKENDS', {'git': git_backend}):
             response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
 
         if backend.alias == 'git':
             assert repo is not None
             expected = {
                 'msg': 'Created new repository `{0}`'.format(repo_name,),
                 'success': True,
                 'task': None,
             }
             assert_ok(id_, expected, given=response.body)
         else:
             assert repo is None
 
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_with_booleans(self, backend):
         repo_name = 'api-repo-2'
         id_, params = build_data(
             self.apikey,
             'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
             enable_statistics=True,
             enable_locking=True,
             enable_downloads=True
         )
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
 
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
         id_, params = build_data(self.apikey, 'get_repo', repoid=repo_name)
         response = api_call(self.app, params)
         body = json.loads(response.body)
 
         assert body['result']['enable_downloads'] is True
         assert body['result']['enable_locking'] is True
         assert body['result']['enable_statistics'] is True
 
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_in_group(self, backend):
         repo_group_name = 'my_gr'
         # create the parent
         fixture.create_repo_group(repo_group_name)
 
         repo_name = '%s/api-repo-gr' % (repo_group_name,)
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         assert repo.group is not None
 
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
         fixture.destroy_repo_group(repo_group_name)
 
+    def test_create_repo_in_group_that_doesnt_exist(self, backend, user_util):
+        repo_group_name = 'fake_group'
+
+        repo_name = '%s/api-repo-gr' % (repo_group_name,)
+        id_, params = build_data(
+            self.apikey, 'create_repo',
+            repo_name=repo_name,
+            owner=TEST_USER_ADMIN_LOGIN,
+            repo_type=backend.alias,)
+        response = api_call(self.app, params)
+
+        expected = {'repo_group': 'Repository group `{}` does not exist'.format(
+            repo_group_name)}
+        assert_error(id_, expected, given=response.body)
+
     def test_api_create_repo_unknown_owner(self, backend):
         repo_name = 'api-repo-2'
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=owner,
             repo_type=backend.alias)
         response = api_call(self.app, params)
         expected = 'user `%s` does not exist' % (owner,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_dont_specify_owner(self, backend):
         repo_name = 'api-repo-3'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin(self, backend):
         repo_name = 'api-repo-4'
         id_, params = build_data(
             self.apikey_regular, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin_specify_owner(self, backend):
         repo_name = 'api-repo-5'
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey_regular, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias,
             owner=owner)
         response = api_call(self.app, params)
 
-        expected = 'Only RhodeCode admin can specify `owner` param'
+        expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
+    def test_api_create_repo_by_non_admin_no_parent_group_perms(self, backend):
+        repo_group_name = 'no-access'
+        fixture.create_repo_group(repo_group_name)
+        repo_name = 'no-access/api-repo'
+
+        id_, params = build_data(
+            self.apikey_regular, 'create_repo',
+            repo_name=repo_name,
+            repo_type=backend.alias)
+        response = api_call(self.app, params)
+
+        expected = {'repo_group': 'Repository group `{}` does not exist'.format(
+            repo_group_name)}
+        assert_error(id_, expected, given=response.body)
+        fixture.destroy_repo_group(repo_group_name)
+        fixture.destroy_repo(repo_name)
+
+    def test_api_create_repo_non_admin_no_permission_to_create_to_root_level(
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+
+        repo_name = backend.new_repo_name()
+        id_, params = build_data(
+            regular_user_api_key, 'create_repo',
+            repo_name=repo_name,
+            repo_type=backend.alias)
+        response = api_call(self.app, params)
+        expected = {
+            "repo_name": "You do not have the permission to "
+                         "store repositories in the root location."}
+        assert_error(id_, expected, given=response.body)
+
     def test_api_create_repo_exists(self, backend):
         repo_name = backend.repo_name
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
-        expected = "repo `%s` already exist" % (repo_name,)
+        expected = {
+            'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                repo_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create', crash)
     def test_api_create_repo_exception_occurred(self, backend):
         repo_name = 'api-repo-6'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
         expected = 'failed to create repository `%s`' % (repo_name,)
         assert_error(id_, expected, given=response.body)
 
-    def test_create_repo_with_extra_slashes_in_name(self, backend, user_util):
-        existing_repo_group = user_util.create_repo_group()
-        dirty_repo_name = '//{}/repo_name//'.format(
-            existing_repo_group.group_name)
-        cleaned_repo_name = '{}/repo_name'.format(
-            existing_repo_group.group_name)
+    @pytest.mark.parametrize('parent_group, dirty_name, expected_name', [
+        (None, 'foo bar x', 'foo-bar-x'),
+        ('foo', '/foo//bar x', 'foo/bar-x'),
+        ('foo-bar', 'foo-bar //bar x', 'foo-bar/bar-x'),
+    ])
+    def test_create_repo_with_extra_slashes_in_name(
+            self, backend, parent_group, dirty_name, expected_name):
+
+        if parent_group:
+            gr = fixture.create_repo_group(parent_group)
+            assert gr.group_name == parent_group
 
         id_, params = build_data(
             self.apikey, 'create_repo',
-            repo_name=dirty_repo_name,
+            repo_name=dirty_name,
             repo_type=backend.alias,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
-        repo = RepoModel().get_by_repo_name(cleaned_repo_name)
+        expected ={
+           "msg": "Created new repository `{}`".format(expected_name),
+           "task": None,
+           "success": True
+        }
+        assert_ok(id_, expected, response.body)
+
+        repo = RepoModel().get_by_repo_name(expected_name)
         assert repo is not None
 
         expected = {
-            'msg': 'Created new repository `%s`' % (cleaned_repo_name,),
+            'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         assert_ok(id_, expected, given=response.body)
-        fixture.destroy_repo(cleaned_repo_name)
+        fixture.destroy_repo(expected_name)
+        if parent_group:
+            fixture.destroy_repo_group(parent_group)

rhodecode/api/tests/test_fork_repo.py

@@ -1,224 +1,279 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import mock
 import pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiForkRepo(object):
     def test_api_fork_repo(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_into_group(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         fork_name = '%s/api-repo-fork' % repo_group.group_name
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
 
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
+    def test_api_fork_repo_non_admin_into_group_no_permission(self, backend, user_util):
+        source_name = backend['minimal'].repo_name
+        repo_group = user_util.create_repo_group()
+        repo_group_name = repo_group.group_name
+        fork_name = '%s/api-repo-fork' % repo_group_name
+
+        id_, params = build_data(
+            self.apikey_regular, 'fork_repo',
+            repoid=source_name,
+            fork_name=fork_name)
+        response = api_call(self.app, params)
+
+        expected = {
+            'repo_group': 'Repository group `{}` does not exist'.format(
+                repo_group_name)}
+        try:
+            assert_error(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo(fork_name)
+
     def test_api_fork_repo_non_admin_into_group(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         fork_name = '%s/api-repo-fork' % repo_group.group_name
 
+        RepoGroupModel().grant_user_permission(
+            repo_group, self.TEST_USER_LOGIN, 'group.admin')
+        Session().commit()
+
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_specify_owner(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
-        expected = 'Only RhodeCode admin can specify `owner` param'
+        expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
 
-    def test_api_fork_repo_non_admin_no_permission_to_fork(self, backend):
+    def test_api_fork_repo_non_admin_no_permission_of_source_repo(
+            self, backend):
         source_name = backend['minimal'].repo_name
         RepoModel().grant_user_permission(repo=source_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm='repository.none')
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=backend.repo_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
         expected = 'repository `%s` does not exist' % (backend.repo_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork_to_root_level(
-            self, backend):
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+        UserModel().grant_perm(regular_user.username, 'hg.fork.repository')
+
         source_name = backend['minimal'].repo_name
+        fork_name = backend.new_repo_name()
+        id_, params = build_data(
+            regular_user_api_key, 'fork_repo',
+            repoid=source_name,
+            fork_name=fork_name)
+        response = api_call(self.app, params)
+        expected = {
+            "repo_name": "You do not have the permission to "
+                         "store repositories in the root location."}
+        assert_error(id_, expected, given=response.body)
 
-        usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
+    def test_api_fork_repo_non_admin_no_permission_to_fork(
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+        usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
+        source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
-            self.apikey_regular, 'fork_repo',
+            regular_user_api_key, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
+
         expected = "Access was denied to this resource."
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_unknown_owner(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=owner)
         response = api_call(self.app, params)
         expected = 'user `%s` does not exist' % (owner,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_fork_exists(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         fork_repo = fixture.create_fork(source_name, fork_name)
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         try:
-            expected = "fork `%s` already exist" % (fork_name,)
+            expected = {
+                'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                    fork_name)}
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_repo.repo_name)
 
     def test_api_fork_repo_repo_exists(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = source_name
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
-        expected = "repo `%s` already exist" % (fork_name,)
+        expected = {
+            'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                fork_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create_fork', crash)
     def test_api_fork_repo_exception_occurred(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'failed to fork repository `%s` as `%s`' % (source_name,
                                                                fork_name)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_update_repo.py

@@ -1,163 +1,189 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 UPDATE_REPO_NAME = 'api_update_me'
 
-class SAME_AS_UPDATES(object): """ Constant used for tests below """
+
+class SAME_AS_UPDATES(object):
+    """ Constant used for tests below """
+
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepo(object):
 
     @pytest.mark.parametrize("updates, expected", [
-        ({'owner': TEST_USER_REGULAR_LOGIN}, SAME_AS_UPDATES),
-        ({'description': 'new description'}, SAME_AS_UPDATES),
-        ({'clone_uri': 'http://foo.com/repo'}, SAME_AS_UPDATES),
-        ({'clone_uri': None}, {'clone_uri': ''}),
-        ({'clone_uri': ''}, {'clone_uri': ''}),
-        ({'landing_rev': 'branch:master'}, {'landing_rev': ['branch','master']}),
-        ({'enable_statistics': True}, SAME_AS_UPDATES),
-        ({'enable_locking': True}, SAME_AS_UPDATES),
-        ({'enable_downloads': True}, SAME_AS_UPDATES),
-        ({'name': 'new_repo_name'}, {
+        ({'owner': TEST_USER_REGULAR_LOGIN},
+         SAME_AS_UPDATES),
+
+        ({'description': 'new description'},
+         SAME_AS_UPDATES),
+
+        ({'clone_uri': 'http://foo.com/repo'},
+         SAME_AS_UPDATES),
+
+        ({'clone_uri': None},
+         {'clone_uri': ''}),
+
+        ({'clone_uri': ''},
+         {'clone_uri': ''}),
+
+        ({'landing_rev': 'rev:tip'},
+         {'landing_rev': ['rev', 'tip']}),
+
+        ({'enable_statistics': True},
+         SAME_AS_UPDATES),
+
+        ({'enable_locking': True},
+         SAME_AS_UPDATES),
+
+        ({'enable_downloads': True},
+         SAME_AS_UPDATES),
+
+        ({'repo_name': 'new_repo_name'},
+         {
             'repo_name': 'new_repo_name',
-            'url': 'http://test.example.com:80/new_repo_name',
+            'url': 'http://test.example.com:80/new_repo_name'
         }),
-        ({'group': 'test_group_for_update'}, {
-            'repo_name': 'test_group_for_update/%s' % UPDATE_REPO_NAME,
-            'url': 'http://test.example.com:80/test_group_for_update/%s' % UPDATE_REPO_NAME
+
+        ({'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
+          '_group': 'test_group_for_update'},
+         {
+            'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
+            'url': 'http://test.example.com:80/test_group_for_update/{}'.format(UPDATE_REPO_NAME)
         }),
     ])
     def test_api_update_repo(self, updates, expected, backend):
         repo_name = UPDATE_REPO_NAME
         repo = fixture.create_repo(repo_name, repo_type=backend.alias)
-        if updates.get('group'):
-            fixture.create_repo_group(updates['group'])
+        if updates.get('_group'):
+            fixture.create_repo_group(updates['_group'])
 
         expected_api_data = repo.get_api_data(include_secrets=True)
         if expected is SAME_AS_UPDATES:
             expected_api_data.update(updates)
         else:
             expected_api_data.update(expected)
 
-
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
 
-        if updates.get('name'):
-            repo_name = updates['name']
-        if updates.get('group'):
-            repo_name = '/'.join([updates['group'], repo_name])
+        if updates.get('repo_name'):
+            repo_name = updates['repo_name']
 
         try:
             expected = {
                 'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),
                 'repository': jsonify(expected_api_data)
             }
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
-            if updates.get('group'):
-                fixture.destroy_repo_group(updates['group'])
+            if updates.get('_group'):
+                fixture.destroy_repo_group(updates['_group'])
 
     def test_api_update_repo_fork_of_field(self, backend):
         master_repo = backend.create_repo()
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo.repo_name
         }
         expected_api_data = repo.get_api_data(include_secrets=True)
         expected_api_data.update(updates)
 
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
         expected = {
             'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
             'repository': jsonify(expected_api_data)
         }
         assert_ok(id_, expected, given=response.body)
         result = response.json['result']['repository']
         assert result['fork_of'] == master_repo.repo_name
 
     def test_api_update_repo_fork_of_not_found(self, backend):
         master_repo_name = 'fake-parent-repo'
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo_name
         }
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
-        expected = 'repository `{}` does not exist'.format(master_repo_name)
+        expected = {
+            'repo_fork_of': 'Fork with id `{}` does not exists'.format(
+                master_repo_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_with_repo_group_not_existing(self):
         repo_name = 'admin_owned'
+        fake_repo_group = 'test_group_for_update'
         fixture.create_repo(repo_name)
-        updates = {'group': 'test_group_for_update'}
+        updates = {'repo_name': '{}/{}'.format(fake_repo_group, repo_name)}
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
-            expected = 'repository group `%s` does not exist' % (
-                updates['group'],)
+            expected = {
+                'repo_group': 'Repository group `{}` does not exist'.format(fake_repo_group)
+            }
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
 
     def test_api_update_repo_regular_user_not_allowed(self):
         repo_name = 'admin_owned'
         fixture.create_repo(repo_name)
         updates = {'active': False}
         id_, params = build_data(
             self.apikey_regular, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
             expected = 'repository `%s` does not exist' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
 
     @mock.patch.object(RepoModel, 'update', crash)
     def test_api_update_repo_exception_occurred(self, backend):
         repo_name = UPDATE_REPO_NAME
         fixture.create_repo(repo_name, repo_type=backend.alias)
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         try:
             expected = 'failed to update repo `%s`' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)

rhodecode/api/views/repo_api.py

@@ -1,1888 +1,1918 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import time
 
-import colander
-
-from rhodecode import BACKENDS
-from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCForbidden, json
+import rhodecode
+from rhodecode.api import (
+    jsonrpc_method, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
-    get_user_group_or_error, get_user_or_error, has_repo_permissions,
-    get_perm_or_error, store_update, get_repo_group_or_error, parse_args,
-    get_origin, build_commit_data)
-from rhodecode.lib.auth import (
-    HasPermissionAnyApi, HasRepoGroupPermissionAnyApi,
-    HasUserGroupPermissionAnyApi)
+    get_user_group_or_error, get_user_or_error, validate_repo_permissions,
+    get_perm_or_error, parse_args, get_origin, build_commit_data,
+    validate_set_owner_permissions)
+from rhodecode.lib.auth import HasPermissionAnyApi, HasUserGroupPermissionAnyApi
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
-from rhodecode.lib.utils import map_groups
 from rhodecode.lib.utils2 import str2bool, time_to_datetime
+from rhodecode.lib.ext_json import json
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.db import (
     Session, ChangesetStatus, RepositoryField, Repository)
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import ScmModel, RepoList
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
+from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import repo_schema
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_repo(request, apiuser, repoid, cache=Optional(True)):
     """
     Gets an existing repository by its name or repository_id.
 
     The members section so the output returns users groups or users
     associated with that repository.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param cache: use the cached value for last changeset
     :type: cache: Optional(bool)
 
     Example output:
 
     .. code-block:: bash
 
         {
           "error": null,
           "id": <repo_id>,
           "result": {
             "clone_uri": null,
             "created_on": "timestamp",
             "description": "repo description",
             "enable_downloads": false,
             "enable_locking": false,
             "enable_statistics": false,
             "followers": [
               {
                 "active": true,
                 "admin": false,
                 "api_key": "****************************************",
                 "api_keys": [
                   "****************************************"
                 ],
                 "email": "[e-mail]",
                 "emails": [
                   "[e-mail]"
                 ],
                 "extern_name": "rhodecode",
                 "extern_type": "rhodecode",
                 "firstname": "username",
                 "ip_addresses": [],
                 "language": null,
                 "last_login": "2015-09-16T17:16:35.854",
                 "lastname": "surname",
                 "user_id": <user_id>,
                 "username": "name"
               }
             ],
             "fork_of": "parent-repo",
             "landing_rev": [
               "rev",
               "tip"
             ],
             "last_changeset": {
               "author": "User <[e-mail]>",
               "branch": "default",
               "date": "timestamp",
               "message": "last commit message",
               "parents": [
                 {
                   "raw_id": "commit-id"
                 }
               ],
               "raw_id": "commit-id",
               "revision": <revision number>,
               "short_id": "short id"
             },
             "lock_reason": null,
             "locked_by": null,
             "locked_date": null,
             "members": [
               {
                 "name": "super-admin-name",
                 "origin": "super-admin",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "owner-name",
                 "origin": "owner",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "user-group-name",
                 "origin": "permission",
                 "permission": "repository.write",
                 "type": "user_group"
               }
             ],
             "owner": "owner-name",
             "permissions": [
               {
                 "name": "super-admin-name",
                 "origin": "super-admin",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "owner-name",
                 "origin": "owner",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "user-group-name",
                 "origin": "permission",
                 "permission": "repository.write",
                 "type": "user_group"
               }
             ],
             "private": true,
             "repo_id": 676,
             "repo_name": "user-group/repo-name",
             "repo_type": "hg"
           }
         }
     """
 
     repo = get_repo_or_error(repoid)
     cache = Optional.extract(cache)
+
     include_secrets = False
     if has_superadmin_permission(apiuser):
         include_secrets = True
     else:
         # check if we have at least read permission for this repo !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     permissions = []
     for _user in repo.permissions():
         user_data = {
             'name': _user.username,
             'permission': _user.permission,
             'origin': get_origin(_user),
             'type': "user",
         }
         permissions.append(user_data)
 
     for _user_group in repo.permission_user_groups():
         user_group_data = {
             'name': _user_group.users_group_name,
             'permission': _user_group.permission,
             'origin': get_origin(_user_group),
             'type': "user_group",
         }
         permissions.append(user_group_data)
 
     following_users = [
         user.user.get_api_data(include_secrets=include_secrets)
         for user in repo.followers]
 
     if not cache:
         repo.update_commit_cache()
     data = repo.get_api_data(include_secrets=include_secrets)
     data['members'] = permissions  # TODO: this should be deprecated soon
     data['permissions'] = permissions
     data['followers'] = following_users
     return data
 
 
 @jsonrpc_method()
 def get_repos(request, apiuser):
     """
     Lists all existing repositories.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: [
                   {
                     "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":             "<repo_owner>",
                     "fork_of":           "<name_of_fork_parent>",
                     "enable_downloads":  "<bool>",
                     "enable_locking":    "<bool>",
                     "enable_statistics": "<bool>",
                   },
                   ...
                 ]
         error:  null
     """
 
     include_secrets = has_superadmin_permission(apiuser)
     _perms = ('repository.read', 'repository.write', 'repository.admin',)
     extras = {'user': apiuser}
 
     repo_list = RepoList(
         RepoModel().get_all(), perm_set=_perms, extra_kwargs=extras)
     return [repo.get_api_data(include_secrets=include_secrets)
             for repo in repo_list]
 
 
 @jsonrpc_method()
 def get_repo_changeset(request, apiuser, repoid, revision,
                        details=Optional('basic')):
     """
     Returns information about a changeset.
 
     Additionally parameters define the amount of details returned by
     this function.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id
     :type repoid: str or int
     :param revision: revision for which listing should be done
     :type revision: str
     :param details: details can be 'basic|extended|full' full gives diff
         info details like the diff itself, and number of changed files etc.
     :type details: Optional(str)
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
     if changes_details not in _changes_details_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (
                 ','.join(_changes_details_types)))
 
     pre_load = ['author', 'branch', 'date', 'message', 'parents',
                 'status', '_commit', '_file_paths']
 
     try:
         cs = repo.get_commit(commit_id=revision, pre_load=pre_load)
     except TypeError as e:
         raise JSONRPCError(e.message)
     _cs_json = cs.__json__()
     _cs_json['diff'] = build_commit_data(cs, changes_details)
     if changes_details == 'full':
         _cs_json['refs'] = {
             'branches': [cs.branch],
             'bookmarks': getattr(cs, 'bookmarks', []),
             'tags': cs.tags
         }
     return _cs_json
 
 
 @jsonrpc_method()
 def get_repo_changesets(request, apiuser, repoid, start_rev, limit,
                         details=Optional('basic')):
     """
     Returns a set of commits limited by the number starting
     from the `start_rev` option.
 
     Additional parameters define the amount of details returned by this
     function.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param start_rev: The starting revision from where to get changesets.
     :type start_rev: str
     :param limit: Limit the number of commits to this amount
     :type limit: str or int
     :param details: Set the level of detail returned. Valid option are:
         ``basic``, ``extended`` and ``full``.
     :type details: Optional(str)
 
     .. note::
 
        Setting the parameter `details` to the value ``full`` is extensive
        and returns details like the diff itself, and the number
        of changed files.
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
     if changes_details not in _changes_details_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (
                 ','.join(_changes_details_types)))
 
     limit = int(limit)
     pre_load = ['author', 'branch', 'date', 'message', 'parents',
                 'status', '_commit', '_file_paths']
 
     vcs_repo = repo.scm_instance()
     # SVN needs a special case to distinguish its index and commit id
     if vcs_repo and vcs_repo.alias == 'svn' and (start_rev == '0'):
         start_rev = vcs_repo.commit_ids[0]
 
     try:
         commits = vcs_repo.get_commits(
             start_id=start_rev, pre_load=pre_load)
     except TypeError as e:
         raise JSONRPCError(e.message)
     except Exception:
         log.exception('Fetching of commits failed')
         raise JSONRPCError('Error occurred during commit fetching')
 
     ret = []
     for cnt, commit in enumerate(commits):
         if cnt >= limit != -1:
             break
         _cs_json = commit.__json__()
         _cs_json['diff'] = build_commit_data(commit, changes_details)
         if changes_details == 'full':
             _cs_json['refs'] = {
                 'branches': [commit.branch],
                 'bookmarks': getattr(commit, 'bookmarks', []),
                 'tags': commit.tags
             }
         ret.append(_cs_json)
     return ret
 
 
 @jsonrpc_method()
 def get_repo_nodes(request, apiuser, repoid, revision, root_path,
                    ret_type=Optional('all'), details=Optional('basic'),
                    max_file_bytes=Optional(None)):
     """
     Returns a list of nodes and children in a flat list for a given
     path at given revision.
 
     It's possible to specify ret_type to show only `files` or `dirs`.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param revision: The revision for which listing should be done.
     :type revision: str
     :param root_path: The path from which to start displaying.
     :type root_path: str
     :param ret_type: Set the return type. Valid options are
         ``all`` (default), ``files`` and ``dirs``.
     :type ret_type: Optional(str)
     :param details: Returns extended information about nodes, such as
         md5, binary, and or content.  The valid options are ``basic`` and
         ``full``.
     :type details: Optional(str)
     :param max_file_bytes: Only return file content under this file size bytes
     :type details: Optional(int)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: [
                   {
                     "name" : "<name>"
                     "type" : "<type>",
                     "binary": "<true|false>" (only in extended mode)
                     "md5"  : "<md5 of file content>" (only in extended mode)
                   },
                   ...
                 ]
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     ret_type = Optional.extract(ret_type)
     details = Optional.extract(details)
     _extended_types = ['basic', 'full']
     if details not in _extended_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (','.join(_extended_types)))
     extended_info = False
     content = False
     if details == 'basic':
         extended_info = True
 
     if details == 'full':
         extended_info = content = True
 
     _map = {}
     try:
         # check if repo is not empty by any chance, skip quicker if it is.
         _scm = repo.scm_instance()
         if _scm.is_empty():
             return []
 
         _d, _f = ScmModel().get_nodes(
             repo, revision, root_path, flat=False,
             extended_info=extended_info, content=content,
             max_file_bytes=max_file_bytes)
         _map = {
             'all': _d + _f,
             'files': _f,
             'dirs': _d,
         }
         return _map[ret_type]
     except KeyError:
         raise JSONRPCError(
             'ret_type must be one of %s' % (','.join(sorted(_map.keys()))))
     except Exception:
         log.exception("Exception occurred while trying to get repo nodes")
         raise JSONRPCError(
             'failed to get repo: `%s` nodes' % repo.repo_name
         )
 
 
 @jsonrpc_method()
 def get_repo_refs(request, apiuser, repoid):
     """
     Returns a dictionary of current references. It returns
     bookmarks, branches, closed_branches, and tags for given repository
 
     It's possible to specify ret_type to show only `files` or `dirs`.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: [
                   TODO...
                 ]
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         # check if repo is not empty by any chance, skip quicker if it is.
         vcs_instance = repo.scm_instance()
         refs = vcs_instance.refs()
         return refs
     except Exception:
         log.exception("Exception occurred while trying to get repo refs")
         raise JSONRPCError(
             'failed to get repo: `%s` references' % repo.repo_name
         )
 
 
 @jsonrpc_method()
-def create_repo(request, apiuser, repo_name, repo_type,
-                owner=Optional(OAttr('apiuser')), description=Optional(''),
-                private=Optional(False), clone_uri=Optional(None),
+def create_repo(
+        request, apiuser, repo_name, repo_type,
+        owner=Optional(OAttr('apiuser')),
+        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),
                 copy_permissions=Optional(False)):
     """
     Creates a repository.
 
-    * If the repository name contains "/", all the required repository
-      groups will be created.
+    * If the repository name contains "/", repository will be created inside
+      a repository group or nested repository groups
 
-      For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-      (with "foo" as parent). It will also create the "baz" repository
-      with "bar" as |repo| group.
+      For example "foo/bar/repo1" will create |repo| called "repo1" inside
+      group "foo/bar". You have to have permissions to access and write to
+      the last repository group ("bar" in this example)
 
     This command can only be run using an |authtoken| with at least
-    write permissions to the |repo|.
+    permissions to create repositories, or write permissions to
+    parent repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repo_name: Set the repository name.
     :type repo_name: str
     :param repo_type: Set the repository type; 'hg','git', or 'svn'.
     :type repo_type: str
     :param owner: user_id or username
     :type owner: Optional(str)
     :param description: Set the repository description.
     :type description: Optional(str)
-    :param private:
+    :param private: set repository as private
     :type private: bool
-    :param clone_uri:
+    :param clone_uri: set clone_uri
     :type clone_uri: str
     :param landing_rev: <rev_type>:<rev>
     :type landing_rev: str
     :param enable_locking:
     :type enable_locking: bool
     :param enable_downloads:
     :type enable_downloads: bool
     :param enable_statistics:
     :type enable_statistics: bool
     :param copy_permissions: Copy permission from group in which the
         repository is being created.
     :type copy_permissions: bool
 
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg": "Created new repository `<reponame>`",
                   "success": true,
                   "task": "<celery task id or None if done sync>"
                 }
         error:  null
 
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
          'failed to create repository `<repo_name>`'
       }
 
     """
-    schema = repo_schema.RepoSchema()
-    try:
-        data = schema.deserialize({
-            'repo_name': repo_name
-        })
-    except colander.Invalid as e:
-        raise JSONRPCError("Validation failed: %s" % (e.asdict(),))
-    repo_name = data['repo_name']
 
-    (repo_name_cleaned,
-     parent_group_name) = RepoGroupModel()._get_group_name_and_parent(
-        repo_name)
-
-    if not HasPermissionAnyApi(
-            'hg.admin', 'hg.create.repository')(user=apiuser):
-        # check if we have admin permission for this repo group if given !
-
-        if parent_group_name:
-            repogroupid = parent_group_name
-            repo_group = get_repo_group_or_error(parent_group_name)
+    owner = validate_set_owner_permissions(apiuser, owner)
 
-            _perms = ('group.admin',)
-            if not HasRepoGroupPermissionAnyApi(*_perms)(
-                    user=apiuser, group_name=repo_group.group_name):
-                raise JSONRPCError(
-                    'repository group `%s` does not exist' % (
-                        repogroupid,))
-        else:
-            raise JSONRPCForbidden()
-
-    if not has_superadmin_permission(apiuser):
-        if not isinstance(owner, Optional):
-            # forbid setting owner for non-admins
-            raise JSONRPCError(
-                'Only RhodeCode admin can specify `owner` param')
-
-    if isinstance(owner, Optional):
-        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)
+    description = Optional.extract(description)
+    copy_permissions = Optional.extract(copy_permissions)
+    clone_uri = Optional.extract(clone_uri)
+    landing_commit_ref = Optional.extract(landing_rev)
 
     defs = SettingsModel().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)
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        # user caller
+        user=apiuser)
 
     try:
-        # create structure of groups and return the last group
-        repo_group = map_groups(repo_name)
+        schema_data = schema.deserialize(dict(
+            repo_name=repo_name,
+            repo_type=repo_type,
+            repo_owner=owner.username,
+            repo_description=description,
+            repo_landing_commit_ref=landing_commit_ref,
+            repo_clone_uri=clone_uri,
+            repo_private=private,
+            repo_copy_permissions=copy_permissions,
+            repo_enable_statistics=enable_statistics,
+            repo_enable_downloads=enable_downloads,
+            repo_enable_locking=enable_locking))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    try:
         data = {
-            '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.group_id if repo_group else None,
-            'repo_landing_rev': landing_rev,
-            'enable_statistics': enable_statistics,
-            'enable_locking': enable_locking,
-            'enable_downloads': enable_downloads,
-            'repo_copy_permissions': copy_permissions,
+            'repo_name': schema_data['repo_group']['repo_name_without_group'],
+            'repo_name_full': schema_data['repo_name'],
+            'repo_group': schema_data['repo_group']['repo_group_id'],
+            'repo_type': schema_data['repo_type'],
+            'repo_description': schema_data['repo_description'],
+            'repo_private': schema_data['repo_private'],
+            'clone_uri': schema_data['repo_clone_uri'],
+            'repo_landing_rev': schema_data['repo_landing_commit_ref'],
+            'enable_statistics': schema_data['repo_enable_statistics'],
+            'enable_locking': schema_data['repo_enable_locking'],
+            'enable_downloads': schema_data['repo_enable_downloads'],
+            'repo_copy_permissions': schema_data['repo_copy_permissions'],
         }
 
-        if repo_type not in BACKENDS.keys():
-            raise Exception("Invalid backend type %s" % repo_type)
         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 {
-            'msg': "Created new repository `%s`" % (repo_name,),
+            'msg': "Created new repository `%s`" % (schema_data['repo_name'],),
             'success': True,  # cannot return the repo data here since fork
-            # cann be done async
+            # can be done async
             'task': task_id
         }
     except Exception:
         log.exception(
             u"Exception while trying to create the repository %s",
-            repo_name)
+            schema_data['repo_name'])
         raise JSONRPCError(
-            'failed to create repository `%s`' % (repo_name,))
+            'failed to create repository `%s`' % (schema_data['repo_name'],))
 
 
 @jsonrpc_method()
 def add_field_to_repo(request, apiuser, repoid, key, label=Optional(''),
                       description=Optional('')):
     """
     Adds an extra field to a repository.
 
     This command can only be run using an |authtoken| with at least
     write permissions to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository id.
     :type repoid: str or int
     :param key: Create a unique field key for this repository.
     :type key: str
     :param label:
     :type label: Optional(str)
     :param description:
     :type description: Optional(str)
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     label = Optional.extract(label) or key
     description = Optional.extract(description)
 
     field = RepositoryField.get_by_key_name(key, repo)
     if field:
         raise JSONRPCError('Field with key '
                            '`%s` exists for repo `%s`' % (key, repoid))
 
     try:
         RepoModel().add_repo_field(repo, key, field_label=label,
                                    field_desc=description)
         Session().commit()
         return {
             'msg': "Added new repository field `%s`" % (key,),
             'success': True,
         }
     except Exception:
         log.exception("Exception occurred while trying to add field to repo")
         raise JSONRPCError(
             'failed to create new field for repository `%s`' % (repoid,))
 
 
 @jsonrpc_method()
 def remove_field_from_repo(request, apiuser, repoid, key):
     """
     Removes an extra field from a repository.
 
     This command can only be run using an |authtoken| with at least
     write permissions to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param key: Set the unique field key for this repository.
     :type key: str
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     field = RepositoryField.get_by_key_name(key, repo)
     if not field:
         raise JSONRPCError('Field with key `%s` does not '
                            'exists for repo `%s`' % (key, repoid))
 
     try:
         RepoModel().delete_repo_field(repo, field_key=key)
         Session().commit()
         return {
             'msg': "Deleted repository field `%s`" % (key,),
             'success': True,
         }
     except Exception:
         log.exception(
             "Exception occurred while trying to delete field from repo")
         raise JSONRPCError(
             'failed to delete field for repository `%s`' % (repoid,))
 
 
 @jsonrpc_method()
-def update_repo(request, apiuser, repoid, name=Optional(None),
-                owner=Optional(OAttr('apiuser')),
-                group=Optional(None),
-                fork_of=Optional(None),
-                description=Optional(''), private=Optional(False),
-                clone_uri=Optional(None), landing_rev=Optional('rev:tip'),
+def update_repo(
+        request, apiuser, repoid, repo_name=Optional(None),
+        owner=Optional(OAttr('apiuser')), description=Optional(''),
+        private=Optional(False), clone_uri=Optional(None),
+        landing_rev=Optional('rev:tip'), fork_of=Optional(None),
                 enable_statistics=Optional(False),
                 enable_locking=Optional(False),
-                enable_downloads=Optional(False),
-                fields=Optional('')):
+        enable_downloads=Optional(False), fields=Optional('')):
     """
     Updates a repository with the given information.
 
     This command can only be run using an |authtoken| with at least
-    write permissions to the |repo|.
+    admin permissions to the |repo|.
+
+    * If the repository name contains "/", repository will be updated
+      accordingly with a repository group or nested repository groups
+
+      For example repoid=repo-test name="foo/bar/repo-test" will update |repo|
+      called "repo-test" and place it inside group "foo/bar".
+      You have to have permissions to access and write to the last repository
+      group ("bar" in this example)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: repository name or repository ID.
     :type repoid: str or int
-    :param name: Update the |repo| name.
-    :type name: str
+    :param repo_name: Update the |repo| name, including the
+        repository group it's in.
+    :type repo_name: str
     :param owner: Set the |repo| owner.
     :type owner: str
-    :param group: Set the |repo| group the |repo| belongs to.
-    :type group: str
-    :param fork_of: Set the master |repo| name.
+    :param fork_of: Set the |repo| as fork of another |repo|.
     :type fork_of: str
     :param description: Update the |repo| description.
     :type description: str
     :param private: Set the |repo| as private. (True | False)
     :type private: bool
     :param clone_uri: Update the |repo| clone URI.
     :type clone_uri: str
-    :param landing_rev: Set the |repo| landing revision. Default is
-        ``tip``.
+    :param landing_rev: Set the |repo| landing revision. Default is ``rev:tip``.
     :type landing_rev: str
-    :param enable_statistics: Enable statistics on the |repo|,
-        (True | False).
+    :param enable_statistics: Enable statistics on the |repo|, (True | False).
     :type enable_statistics: bool
     :param enable_locking: Enable |repo| locking.
     :type enable_locking: bool
-    :param enable_downloads: Enable downloads from the |repo|,
-        (True | False).
+    :param enable_downloads: Enable downloads from the |repo|, (True | False).
     :type enable_downloads: bool
     :param fields: Add extra fields to the |repo|. Use the following
         example format: ``field_key=field_val,field_key2=fieldval2``.
         Escape ', ' with \,
     :type fields: str
     """
+
     repo = get_repo_or_error(repoid)
+
     include_secrets = False
-    if has_superadmin_permission(apiuser):
+    if not has_superadmin_permission(apiuser):
+        validate_repo_permissions(apiuser, repoid, repo, ('repository.admin',))
+    else:
         include_secrets = True
-    else:
-        _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+
+    updates = dict(
+        repo_name=repo_name
+        if not isinstance(repo_name, Optional) else repo.repo_name,
+
+        fork_id=fork_of
+        if not isinstance(fork_of, Optional) else repo.fork.repo_name if repo.fork else None,
+
+        user=owner
+        if not isinstance(owner, Optional) else repo.user.username,
 
-    updates = {
-        # update function requires this.
-        'repo_name': repo.just_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
+        repo_description=description
+        if not isinstance(description, Optional) else repo.description,
+
+        repo_private=private
+        if not isinstance(private, Optional) else repo.private,
+
+        clone_uri=clone_uri
+        if not isinstance(clone_uri, Optional) else repo.clone_uri,
+
+        repo_landing_rev=landing_rev
+        if not isinstance(landing_rev, Optional) else repo._landing_revision,
+
+        repo_enable_statistics=enable_statistics
+        if not isinstance(enable_statistics, Optional) else repo.enable_statistics,
+
+        repo_enable_locking=enable_locking
+        if not isinstance(enable_locking, Optional) else repo.enable_locking,
+
+        repo_enable_downloads=enable_downloads
+        if not isinstance(enable_downloads, Optional) else repo.enable_downloads)
+
+    ref_choices, _labels = ScmModel().get_repo_landing_revs(repo=repo)
 
-    repo_fork_of = fork_of
-    if not isinstance(repo_fork_of, Optional):
-        repo_fork_of = get_repo_or_error(repo_fork_of)
-        repo_fork_of = repo_fork_of.repo_id
-
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        repo_ref_options=ref_choices,
+        # user caller
+        user=apiuser,
+        old_values=repo.get_api_data())
     try:
-        store_update(updates, name, 'repo_name')
-        store_update(updates, repo_group, 'repo_group')
-        store_update(updates, repo_fork_of, 'fork_id')
-        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')
+        schema_data = schema.deserialize(dict(
+            # we save old value, users cannot change type
+            repo_type=repo.repo_type,
+
+            repo_name=updates['repo_name'],
+            repo_owner=updates['user'],
+            repo_description=updates['repo_description'],
+            repo_clone_uri=updates['clone_uri'],
+            repo_fork_of=updates['fork_id'],
+            repo_private=updates['repo_private'],
+            repo_landing_commit_ref=updates['repo_landing_rev'],
+            repo_enable_statistics=updates['repo_enable_statistics'],
+            repo_enable_downloads=updates['repo_enable_downloads'],
+            repo_enable_locking=updates['repo_enable_locking']))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    # save validated data back into the updates dict
+    validated_updates = dict(
+        repo_name=schema_data['repo_group']['repo_name_without_group'],
+        repo_group=schema_data['repo_group']['repo_group_id'],
+
+        user=schema_data['repo_owner'],
+        repo_description=schema_data['repo_description'],
+        repo_private=schema_data['repo_private'],
+        clone_uri=schema_data['repo_clone_uri'],
+        repo_landing_rev=schema_data['repo_landing_commit_ref'],
+        repo_enable_statistics=schema_data['repo_enable_statistics'],
+        repo_enable_locking=schema_data['repo_enable_locking'],
+        repo_enable_downloads=schema_data['repo_enable_downloads'],
+    )
+
+    if schema_data['repo_fork_of']:
+        fork_repo = get_repo_or_error(schema_data['repo_fork_of'])
+        validated_updates['fork_id'] = fork_repo.repo_id
 
         # extra fields
         fields = parse_args(Optional.extract(fields), key_prefix='ex_')
         if fields:
-            updates.update(fields)
+        validated_updates.update(fields)
 
-        RepoModel().update(repo, **updates)
+    try:
+        RepoModel().update(repo, **validated_updates)
         Session().commit()
         return {
-            'msg': 'updated repo ID:%s %s' % (
-                repo.repo_id, repo.repo_name),
-            'repository': repo.get_api_data(
-                include_secrets=include_secrets)
+            'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
+            'repository': repo.get_api_data(include_secrets=include_secrets)
         }
     except Exception:
         log.exception(
             u"Exception while trying to update the repository %s",
             repoid)
         raise JSONRPCError('failed to update repo `%s`' % repoid)
 
 
 @jsonrpc_method()
 def fork_repo(request, apiuser, repoid, fork_name,
               owner=Optional(OAttr('apiuser')),
-              description=Optional(''), copy_permissions=Optional(False),
-              private=Optional(False), landing_rev=Optional('rev:tip')):
+              description=Optional(''),
+              private=Optional(False),
+              clone_uri=Optional(None),
+              landing_rev=Optional('rev:tip'),
+              copy_permissions=Optional(False)):
     """
     Creates a fork of the specified |repo|.
 
-    * If using |RCE| with Celery this will immediately return a success
-      message, even though the fork will be created asynchronously.
+    * If the fork_name contains "/", fork will be created inside
+      a repository group or nested repository groups
 
-    This command can only be run using an |authtoken| with fork
-    permissions on the |repo|.
+      For example "foo/bar/fork-repo" will create fork called "fork-repo"
+      inside group "foo/bar". You have to have permissions to access and
+      write to the last repository group ("bar" in this example)
+
+    This command can only be run using an |authtoken| with minimum
+    read permissions of the forked repo, create fork permissions for an user.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set repository name or repository ID.
     :type repoid: str or int
-    :param fork_name: Set the fork name.
+    :param fork_name: Set the fork name, including it's repository group membership.
     :type fork_name: str
     :param owner: Set the fork owner.
     :type owner: str
-    :param description: Set the fork descripton.
+    :param description: Set the fork description.
     :type description: str
     :param copy_permissions: Copy permissions from parent |repo|. The
         default is False.
     :type copy_permissions: bool
     :param private: Make the fork private. The default is False.
     :type private: bool
     :param landing_rev: Set the landing revision. The default is tip.
 
     Example output:
 
     .. code-block:: bash
 
         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>"
                   }
 
     Example error output:
 
     .. code-block:: bash
 
         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
 
     """
-    if not has_superadmin_permission(apiuser):
-        if not HasPermissionAnyApi('hg.fork.repository')(user=apiuser):
-            raise JSONRPCForbidden()
 
     repo = get_repo_or_error(repoid)
     repo_name = repo.repo_name
 
-    (fork_name_cleaned,
-     parent_group_name) = RepoGroupModel()._get_group_name_and_parent(
-        fork_name)
-
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for
         # this repo that we fork !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read')
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
-        if not isinstance(owner, Optional):
-            # forbid setting owner for non super admins
-            raise JSONRPCError(
-                'Only RhodeCode admin can specify `owner` param'
-            )
-        # check if we have a create.repo permission if not maybe the parent
-        # group permission
-        if not HasPermissionAnyApi('hg.create.repository')(user=apiuser):
-            if parent_group_name:
-                repogroupid = parent_group_name
-                repo_group = get_repo_group_or_error(parent_group_name)
-
-                _perms = ('group.admin',)
-                if not HasRepoGroupPermissionAnyApi(*_perms)(
-                        user=apiuser, group_name=repo_group.group_name):
-                    raise JSONRPCError(
-                        'repository group `%s` does not exist' % (
-                            repogroupid,))
-            else:
+        # check if the regular user has at least fork permissions as well
+        if not HasPermissionAnyApi('hg.fork.repository')(user=apiuser):
                 raise JSONRPCForbidden()
 
-    _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))
+    # check if user can set owner parameter
+    owner = validate_set_owner_permissions(apiuser, owner)
 
-    if isinstance(owner, Optional):
-        owner = apiuser.user_id
+    description = Optional.extract(description)
+    copy_permissions = Optional.extract(copy_permissions)
+    clone_uri = Optional.extract(clone_uri)
+    landing_commit_ref = Optional.extract(landing_rev)
+    private = Optional.extract(private)
 
-    owner = get_user_or_error(owner)
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        # user caller
+        user=apiuser)
 
     try:
-        # create structure of groups and return the last group
-        repo_group = map_groups(fork_name)
-        form_data = {
-            'repo_name': fork_name_cleaned,
-            'repo_name_full': fork_name,
-            'repo_group': repo_group.group_id if repo_group else None,
-            '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),
+        schema_data = schema.deserialize(dict(
+            repo_name=fork_name,
+            repo_type=repo.repo_type,
+            repo_owner=owner.username,
+            repo_description=description,
+            repo_landing_commit_ref=landing_commit_ref,
+            repo_clone_uri=clone_uri,
+            repo_private=private,
+            repo_copy_permissions=copy_permissions))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    try:
+        data = {
             'fork_parent_id': repo.repo_id,
+
+            'repo_name': schema_data['repo_group']['repo_name_without_group'],
+            'repo_name_full': schema_data['repo_name'],
+            'repo_group': schema_data['repo_group']['repo_group_id'],
+            'repo_type': schema_data['repo_type'],
+            'description': schema_data['repo_description'],
+            'private': schema_data['repo_private'],
+            'copy_permissions': schema_data['repo_copy_permissions'],
+            'landing_rev': schema_data['repo_landing_commit_ref'],
         }
 
-        task = RepoModel().create_fork(form_data, cur_user=owner)
+        task = RepoModel().create_fork(data, cur_user=owner)
         # no commit, it's done in RepoModel, or async via celery
         from celery.result import BaseAsyncResult
         task_id = None
         if isinstance(task, BaseAsyncResult):
             task_id = task.task_id
         return {
             'msg': 'Created fork of `%s` as `%s`' % (
-                repo.repo_name, fork_name),
+                repo.repo_name, schema_data['repo_name']),
             'success': True,  # cannot return the repo data here since fork
             # can be done async
             'task': task_id
         }
     except Exception:
-        log.exception("Exception occurred while trying to fork a repo")
+        log.exception(
+            u"Exception while trying to create fork %s",
+            schema_data['repo_name'])
         raise JSONRPCError(
             'failed to fork repository `%s` as `%s`' % (
-                repo_name, fork_name))
+                repo_name, schema_data['repo_name']))
 
 
 @jsonrpc_method()
 def delete_repo(request, apiuser, repoid, forks=Optional('')):
     """
     Deletes a repository.
 
     * When the `forks` parameter is set it's possible to detach or delete
       forks of deleted repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param forks: Set to `detach` or `delete` forks from the |repo|.
     :type forks: Optional(str)
 
     Example error output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg": "Deleted repository `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         handle_forks = Optional.extract(forks)
         _forks_msg = ''
         _forks = [f for f in repo.forks]
         if handle_forks == 'detach':
             _forks_msg = ' ' + 'Detached %s forks' % len(_forks)
         elif handle_forks == 'delete':
             _forks_msg = ' ' + 'Deleted %s forks' % len(_forks)
         elif _forks:
             raise JSONRPCError(
                 'Cannot delete `%s` it still contains attached forks' %
                 (repo.repo_name,)
             )
 
         RepoModel().delete(repo, forks=forks)
         Session().commit()
         return {
             'msg': 'Deleted repository `%s`%s' % (
                 repo.repo_name, _forks_msg),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying to delete repo")
         raise JSONRPCError(
             'failed to delete repository `%s`' % (repo.repo_name,)
         )
 
 
 #TODO: marcink, change name ?
 @jsonrpc_method()
 def invalidate_cache(request, apiuser, repoid, delete_keys=Optional(False)):
     """
     Invalidates the cache for the specified repository.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Sets the repository name or repository ID.
     :type repoid: str or int
     :param delete_keys: This deletes the invalidated keys instead of
         just flagging them.
     :type delete_keys: Optional(``True`` | ``False``)
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'msg': Cache for repository `<repository name>` was invalidated,
         'repository': <repository name>
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error : {
          'Error occurred during cache invalidation action'
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     delete = Optional.extract(delete_keys)
     try:
         ScmModel().mark_for_invalidation(repo.repo_name, delete=delete)
         return {
             'msg': 'Cache for repository `%s` was invalidated' % (repoid,),
             'repository': repo.repo_name
         }
     except Exception:
         log.exception(
             "Exception occurred while trying to invalidate repo cache")
         raise JSONRPCError(
             'Error occurred during cache invalidation action'
         )
 
 
 #TODO: marcink, change name ?
 @jsonrpc_method()
 def lock(request, apiuser, repoid, locked=Optional(None),
          userid=Optional(OAttr('apiuser'))):
     """
     Sets the lock state of the specified |repo| by the given user.
     From more information, see :ref:`repo-locking`.
 
     * If the ``userid`` option is not set, the repository is locked to the
       user who called the method.
     * If the ``locked`` parameter is not set, the current lock state of the
       repository is displayed.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Sets the repository name or repository ID.
     :type repoid: str or int
     :param locked: Sets the lock state.
     :type locked: Optional(``True`` | ``False``)
     :param userid: Set the repository lock to this user.
     :type userid: Optional(str or int)
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'repo': '<reponame>',
         'locked': <bool: lock state>,
         'locked_since': <int: lock timestamp>,
         'locked_by': <username of person who made the lock>,
         'lock_reason': <str: reason for locking>,
         'lock_state_changed': <bool: True if lock state has been changed in this request>,
         'msg': 'Repo `<reponame>` locked by `<username>` on <timestamp>.'
         or
         'msg': 'Repo `<repository name>` not locked.'
         or
         'msg': 'User `<user name>` set lock state for repo `<repository name>` to `<new lock state>`'
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         'Error occurred locking repository `<reponame>`'
       }
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least write permission for this repo !
         _perms = ('repository.admin', 'repository.write',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
         # make sure normal user does not pass someone else userid,
         # he is not allowed to do that
         if not isinstance(userid, Optional) and userid != apiuser.user_id:
             raise JSONRPCError('userid is not the same as your user')
 
     if isinstance(userid, Optional):
         userid = apiuser.user_id
 
     user = get_user_or_error(userid)
 
     if isinstance(locked, Optional):
         lockobj = repo.locked
 
         if lockobj[0] is None:
             _d = {
                 'repo': repo.repo_name,
                 'locked': False,
                 'locked_since': None,
                 'locked_by': None,
                 'lock_reason': None,
                 'lock_state_changed': False,
                 'msg': 'Repo `%s` not locked.' % repo.repo_name
             }
             return _d
         else:
             _user_id, _time, _reason = lockobj
             lock_user = get_user_or_error(userid)
             _d = {
                 'repo': repo.repo_name,
                 'locked': True,
                 'locked_since': _time,
                 'locked_by': lock_user.username,
                 'lock_reason': _reason,
                 'lock_state_changed': False,
                 'msg': ('Repo `%s` locked by `%s` on `%s`.'
                         % (repo.repo_name, lock_user.username,
                            json.dumps(time_to_datetime(_time))))
             }
             return _d
 
     # force locked state through a flag
     else:
         locked = str2bool(locked)
         lock_reason = Repository.LOCK_API
         try:
             if locked:
                 lock_time = time.time()
                 Repository.lock(repo, user.user_id, lock_time, lock_reason)
             else:
                 lock_time = None
                 Repository.unlock(repo)
             _d = {
                 'repo': repo.repo_name,
                 'locked': locked,
                 'locked_since': lock_time,
                 'locked_by': user.username,
                 'lock_reason': lock_reason,
                 'lock_state_changed': True,
                 'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                         % (user.username, repo.repo_name, locked))
             }
             return _d
         except Exception:
             log.exception(
                 "Exception occurred while trying to lock repository")
             raise JSONRPCError(
                 'Error occurred locking repository `%s`' % repo.repo_name
             )
 
 
 @jsonrpc_method()
 def comment_commit(
         request, apiuser, repoid, commit_id, message,
         userid=Optional(OAttr('apiuser')), status=Optional(None)):
     """
     Set a commit comment, and optionally change the status of the commit.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param commit_id: Specify the commit_id for which to set a comment.
     :type commit_id: str
     :param message: The comment text.
     :type message: str
     :param userid: Set the user name of the comment creator.
     :type userid: Optional(str or int)
     :param status: status, one of 'not_reviewed', 'approved', 'rejected',
        'under_review'
     :type status: str
 
     Example error output:
 
     .. code-block:: json
 
         {
             "id" : <id_given_in_input>,
             "result" : {
                 "msg": "Commented on commit `<commit_id>` for repository `<repoid>`",
                 "status_change": null or <status>,
                 "success": true
             },
             "error" :  null
         }
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.read', 'repository.write', 'repository.admin')
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     if isinstance(userid, Optional):
         userid = apiuser.user_id
 
     user = get_user_or_error(userid)
     status = Optional.extract(status)
 
     allowed_statuses = [x[0] for x in ChangesetStatus.STATUSES]
     if status and status not in allowed_statuses:
         raise JSONRPCError('Bad status, must be on '
                            'of %s got %s' % (allowed_statuses, status,))
 
     try:
         rc_config = SettingsModel().get_all_settings()
         renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
         status_change_label = ChangesetStatus.get_status_lbl(status)
         comm = ChangesetCommentsModel().create(
             message, repo, user, revision=commit_id,
             status_change=status_change_label,
             status_change_type=status,
             renderer=renderer)
         if status:
             # also do a status change
             try:
                 ChangesetStatusModel().set_status(
                     repo, status, user, comm, revision=commit_id,
                     dont_allow_on_closed_pull_request=True
                 )
             except StatusChangeOnClosedPullRequestError:
                 log.exception(
                     "Exception occurred while trying to change repo commit status")
                 msg = ('Changing status on a changeset associated with '
                        'a closed pull request is not allowed')
                 raise JSONRPCError(msg)
 
         Session().commit()
         return {
             'msg': (
                 'Commented on commit `%s` for repository `%s`' % (
                     comm.revision, repo.repo_name)),
             'status_change': status,
             'success': True,
         }
     except JSONRPCError:
         # catch any inside errors, and re-raise them to prevent from
         # below global catch to silence them
         raise
     except Exception:
         log.exception("Exception occurred while trying to comment on commit")
         raise JSONRPCError(
             'failed to set comment on repository `%s`' % (repo.repo_name,)
         )
 
 
 @jsonrpc_method()
 def grant_user_permission(request, apiuser, repoid, userid, perm):
     """
     Grant permissions for the specified user on the given repository,
     or update existing permissions if found.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param userid: Set the user name.
     :type userid: str
     :param perm: Set the user permissions, using the following format
         ``(repository.(none|read|write|admin))``
     :type perm: str
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     user = get_user_or_error(userid)
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
 
         RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
 
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                 perm.permission_name, user.username, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying edit permissions for repo")
         raise JSONRPCError(
             'failed to edit permission for user: `%s` in repo: `%s`' % (
                 userid, repoid
             )
         )
 
 
 @jsonrpc_method()
 def revoke_user_permission(request, apiuser, repoid, userid):
     """
     Revoke permission for a user on the specified repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param userid: Set the user name of revoked user.
     :type userid: str or int
 
     Example error output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     user = get_user_or_error(userid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         RepoModel().revoke_user_permission(repo=repo, user=user)
         Session().commit()
         return {
             'msg': 'Revoked perm for user: `%s` in repo: `%s`' % (
                 user.username, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying revoke permissions to repo")
         raise JSONRPCError(
             'failed to edit permission for user: `%s` in repo: `%s`' % (
                 userid, repoid
             )
         )
 
 
 @jsonrpc_method()
 def grant_user_group_permission(request, apiuser, repoid, usergroupid, perm):
     """
     Grant permission for a user group on the specified repository,
     or update existing permissions.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param usergroupid: Specify the ID of the user group.
     :type usergroupid: str or int
     :param perm: Set the user group permissions using the following
         format: (repository.(none|read|write|admin))
     :type perm: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
         "success": true
 
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     try:
         RepoModel().grant_user_group_permission(
             repo=repo, group_name=user_group, perm=perm)
 
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` for user group: `%s` in '
                    'repo: `%s`' % (
                        perm.permission_name, user_group.users_group_name,
                        repo.repo_name
                    ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying change permission on repo")
         raise JSONRPCError(
             'failed to edit permission for user group: `%s` in '
             'repo: `%s`' % (
                 usergroupid, repo.repo_name
             )
         )
 
 
 @jsonrpc_method()
 def revoke_user_group_permission(request, apiuser, repoid, usergroupid):
     """
     Revoke the permissions of a user group on a given repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param usergroupid: Specify the user group ID.
     :type usergroupid: str or int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     try:
         RepoModel().revoke_user_group_permission(
             repo=repo, group_name=user_group)
 
         Session().commit()
         return {
             'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (
                 user_group.users_group_name, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying revoke "
                       "user group permission on repo")
         raise JSONRPCError(
             'failed to edit permission for user group: `%s` in '
             'repo: `%s`' % (
                 user_group.users_group_name, repo.repo_name
             )
         )
 
 
 @jsonrpc_method()
 def pull(request, apiuser, repoid):
     """
     Triggers a pull on the given repository from a remote location. You
     can use this to keep remote repositories up-to-date.
 
     This command can only be run using an |authtoken| with admin
     rights to the specified repository. For more information,
     see :ref:`config-token-ref`.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "Pulled from `<repository name>`"
         "repository": "<repository name>"
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "Unable to pull changes from `<reponame>`"
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().pull_changes(repo.repo_name, apiuser.username)
         return {
             'msg': 'Pulled from `%s`' % repo.repo_name,
             'repository': repo.repo_name
         }
     except Exception:
         log.exception("Exception occurred while trying to "
                       "pull changes from remote location")
         raise JSONRPCError(
             'Unable to pull changes from `%s`' % repo.repo_name
         )
 
 
 @jsonrpc_method()
 def strip(request, apiuser, repoid, revision, branch):
     """
     Strips the given revision from the specified repository.
 
     * This will remove the revision and all of its decendants.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param revision: The revision you wish to strip.
     :type revision: str
     :param branch: The branch from which to strip the revision.
     :type branch: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "'Stripped commit <commit_hash> from repo `<repository name>`'"
         "repository": "<repository name>"
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "Unable to strip commit <commit_hash> from repo `<repository name>`"
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().strip(repo, revision, branch)
         return {
             'msg': 'Stripped commit %s from repo `%s`' % (
                 revision, repo.repo_name),
             'repository': repo.repo_name
         }
     except Exception:
         log.exception("Exception while trying to strip")
         raise JSONRPCError(
             'Unable to strip commit %s from repo `%s`' % (
                 revision, repo.repo_name)
         )
 
 
 @jsonrpc_method()
 def get_repo_settings(request, apiuser, repoid, key=Optional(None)):
     """
     Returns all settings for a repository. If key is given it only returns the
     setting identified by the key or null.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param key: Key of the setting to return.
     :type: key: Optional(str)
 
     Example output:
 
     .. code-block:: bash
 
         {
             "error": null,
             "id": 237,
             "result": {
                 "extensions_largefiles": true,
                 "hooks_changegroup_push_logger": true,
                 "hooks_changegroup_repo_size": false,
                 "hooks_outgoing_pull_logger": true,
                 "phases_publish": "True",
                 "rhodecode_hg_use_rebase_for_merging": true,
                 "rhodecode_pr_merge_enabled": true,
                 "rhodecode_use_outdated_comments": true
             }
         }
     """
 
     # Restrict access to this api method to admins only.
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     try:
         repo = get_repo_or_error(repoid)
         settings_model = VcsSettingsModel(repo=repo)
         settings = settings_model.get_global_settings()
         settings.update(settings_model.get_repo_settings())
 
         # If only a single setting is requested fetch it from all settings.
         key = Optional.extract(key)
         if key is not None:
             settings = settings.get(key, None)
     except Exception:
         msg = 'Failed to fetch settings for repository `{}`'.format(repoid)
         log.exception(msg)
         raise JSONRPCError(msg)
 
     return settings
 
 
 @jsonrpc_method()
 def set_repo_settings(request, apiuser, repoid, settings):
     """
     Update repository settings. Returns true on success.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param settings: The new settings for the repository.
     :type: settings: dict
 
     Example output:
 
     .. code-block:: bash
 
         {
             "error": null,
             "id": 237,
             "result": true
         }
     """
     # Restrict access to this api method to admins only.
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     if type(settings) is not dict:
         raise JSONRPCError('Settings have to be a JSON Object.')
 
     try:
         settings_model = VcsSettingsModel(repo=repoid)
 
         # Merge global, repo and incoming settings.
         new_settings = settings_model.get_global_settings()
         new_settings.update(settings_model.get_repo_settings())
         new_settings.update(settings)
 
         # Update the settings.
         inherit_global_settings = new_settings.get(
             'inherit_global_settings', False)
         settings_model.create_or_update_repo_settings(
             new_settings, inherit_global_settings=inherit_global_settings)
         Session().commit()
     except Exception:
         msg = 'Failed to update settings for repository `{}`'.format(repoid)
         log.exception(msg)
         raise JSONRPCError(msg)
 
     # Indicate success.
     return True

rhodecode/model/repo.py

@@ -1,1057 +1,1057 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Repository model for rhodecode
 """
 
 import logging
 import os
 import re
 import shutil
 import time
 import traceback
 from datetime import datetime
 
 from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import true, or_
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode import events
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import HasUserGroupPermissionAny
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.exceptions import AttachedForksError
 from rhodecode.lib.hooks_base import log_delete_repository
 from rhodecode.lib.markup_renderer import MarkupRenderer
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.utils2 import (
     safe_str, safe_unicode, remove_prefix, obfuscate_url_pw,
     get_current_rhodecode_user, safe_int, datetime_to_time, action_logger_generic)
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     Repository, UserRepoToPerm, UserGroupRepoToPerm, UserRepoGroupToPerm,
     UserGroupRepoGroupToPerm, User, Permission, Statistics, UserGroup,
     RepoGroup, RepositoryField)
 from rhodecode.model.scm import UserGroupList
 from rhodecode.model.settings import VcsSettingsModel
 
 
 log = logging.getLogger(__name__)
 
 
 class RepoModel(BaseModel):
 
     cls = Repository
 
     def _get_user_group(self, users_group):
         return self._get_instance(UserGroup, users_group,
                                   callback=UserGroup.get_by_group_name)
 
     def _get_repo_group(self, repo_group):
         return self._get_instance(RepoGroup, repo_group,
                                   callback=RepoGroup.get_by_group_name)
 
     def _create_default_perms(self, repository, private):
         # create default permission
         default = 'repository.read'
         def_user = User.get_default_user()
         for p in def_user.user_perms:
             if p.permission.permission_name.startswith('repository.'):
                 default = p.permission.permission_name
                 break
 
         default_perm = 'repository.none' if private else default
 
         repo_to_perm = UserRepoToPerm()
         repo_to_perm.permission = Permission.get_by_key(default_perm)
 
         repo_to_perm.repository = repository
         repo_to_perm.user_id = def_user.user_id
 
         return repo_to_perm
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def get(self, repo_id, cache=False):
         repo = self.sa.query(Repository) \
             .filter(Repository.repo_id == repo_id)
 
         if cache:
             repo = repo.options(FromCache("sql_cache_short",
                                           "get_repo_%s" % repo_id))
         return repo.scalar()
 
     def get_repo(self, repository):
         return self._get_repo(repository)
 
     def get_by_repo_name(self, repo_name, cache=False):
         repo = self.sa.query(Repository) \
             .filter(Repository.repo_name == repo_name)
 
         if cache:
             repo = repo.options(FromCache("sql_cache_short",
                                           "get_repo_%s" % repo_name))
         return repo.scalar()
 
     def _extract_id_from_repo_name(self, repo_name):
         if repo_name.startswith('/'):
             repo_name = repo_name.lstrip('/')
         by_id_match = re.match(r'^_(\d{1,})', repo_name)
         if by_id_match:
             return by_id_match.groups()[0]
 
     def get_repo_by_id(self, repo_name):
         """
         Extracts repo_name by id from special urls.
         Example url is _11/repo_name
 
         :param repo_name:
         :return: repo object if matched else None
         """
         try:
             _repo_id = self._extract_id_from_repo_name(repo_name)
             if _repo_id:
                 return self.get(_repo_id)
         except Exception:
             log.exception('Failed to extract repo_name from URL')
 
         return None
 
     def get_url(self, repo):
         return h.url('summary_home', repo_name=safe_str(repo.repo_name),
             qualified=True)
 
     def get_users(self, name_contains=None, limit=20, only_active=True):
 
         # TODO: mikhail: move this method to the UserModel.
         query = self.sa.query(User)
         if only_active:
             query = query.filter(User.active == true())
 
         if name_contains:
             ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
             query = query.filter(
                 or_(
                     User.name.ilike(ilike_expression),
                     User.lastname.ilike(ilike_expression),
                     User.username.ilike(ilike_expression)
                 )
             )
             query = query.limit(limit)
         users = query.all()
 
         _users = [
             {
                 'id': user.user_id,
                 'first_name': user.name,
                 'last_name': user.lastname,
                 'username': user.username,
                 'email': user.email,
                 'icon_link': h.gravatar_url(user.email, 30),
                 'value_display': h.person(user),
                 'value': user.username,
                 'value_type': 'user',
                 'active': user.active,
             }
             for user in users
         ]
         return _users
 
     def get_user_groups(self, name_contains=None, limit=20, only_active=True):
         # TODO: mikhail: move this method to the UserGroupModel.
         query = self.sa.query(UserGroup)
         if only_active:
             query = query.filter(UserGroup.users_group_active == true())
 
         if name_contains:
             ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
             query = query.filter(
                 UserGroup.users_group_name.ilike(ilike_expression))\
                 .order_by(func.length(UserGroup.users_group_name))\
                 .order_by(UserGroup.users_group_name)
 
             query = query.limit(limit)
         user_groups = query.all()
         perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']
         user_groups = UserGroupList(user_groups, perm_set=perm_set)
 
         _groups = [
             {
                 'id': group.users_group_id,
                 # TODO: marcink figure out a way to generate the url for the
                 # icon
                 'icon_link': '',
                 'value_display': 'Group: %s (%d members)' % (
                     group.users_group_name, len(group.members),),
                 'value': group.users_group_name,
                 'value_type': 'user_group',
                 'active': group.users_group_active,
             }
             for group in user_groups
         ]
         return _groups
 
     @classmethod
     def update_repoinfo(cls, repositories=None):
         if not repositories:
             repositories = Repository.getAll()
         for repo in repositories:
             repo.update_commit_cache()
 
     def get_repos_as_dict(self, repo_list=None, admin=False,
                           super_user_actions=False):
 
         from rhodecode.lib.utils import PartialRenderer
         _render = PartialRenderer('data_table/_dt_elements.html')
         c = _render.c
 
         def quick_menu(repo_name):
             return _render('quick_menu', repo_name)
 
         def repo_lnk(name, rtype, rstate, private, fork_of):
             return _render('repo_name', name, rtype, rstate, private, fork_of,
                            short_name=not admin, admin=False)
 
         def last_change(last_change):
             return _render("last_change", last_change)
 
         def rss_lnk(repo_name):
             return _render("rss", repo_name)
 
         def atom_lnk(repo_name):
             return _render("atom", repo_name)
 
         def last_rev(repo_name, cs_cache):
             return _render('revision', repo_name, cs_cache.get('revision'),
                            cs_cache.get('raw_id'), cs_cache.get('author'),
                            cs_cache.get('message'))
 
         def desc(desc):
             if c.visual.stylify_metatags:
                 desc = h.urlify_text(h.escaped_stylize(desc))
             else:
                 desc = h.urlify_text(h.html_escape(desc))
 
             return _render('repo_desc', desc)
 
         def state(repo_state):
             return _render("repo_state", repo_state)
 
         def repo_actions(repo_name):
             return _render('repo_actions', repo_name, super_user_actions)
 
         def user_profile(username):
             return _render('user_profile', username)
 
         repos_data = []
         for repo in repo_list:
             cs_cache = repo.changeset_cache
             row = {
                 "menu": quick_menu(repo.repo_name),
 
                 "name": repo_lnk(repo.repo_name, repo.repo_type,
                                  repo.repo_state, repo.private, repo.fork),
                 "name_raw": repo.repo_name.lower(),
 
                 "last_change": last_change(repo.last_db_change),
                 "last_change_raw": datetime_to_time(repo.last_db_change),
 
                 "last_changeset": last_rev(repo.repo_name, cs_cache),
                 "last_changeset_raw": cs_cache.get('revision'),
 
                 "desc": desc(repo.description),
                 "owner": user_profile(repo.user.username),
 
                 "state": state(repo.repo_state),
                 "rss": rss_lnk(repo.repo_name),
 
                 "atom": atom_lnk(repo.repo_name),
             }
             if admin:
                 row.update({
                     "action": repo_actions(repo.repo_name),
                 })
             repos_data.append(row)
 
         return repos_data
 
     def _get_defaults(self, repo_name):
         """
         Gets information about repository, and returns a dict for
         usage in forms
 
         :param repo_name:
         """
 
         repo_info = Repository.get_by_repo_name(repo_name)
 
         if repo_info is None:
             return None
 
         defaults = repo_info.get_dict()
         defaults['repo_name'] = repo_info.just_name
 
         groups  = repo_info.groups_with_parents
         parent_group = groups[-1] if groups else None
 
         # we use -1 as this is how in HTML, we mark an empty group
         defaults['repo_group'] = getattr(parent_group, 'group_id', -1)
 
         keys_to_process = (
             {'k': 'repo_type', 'strip': False},
             {'k': 'repo_enable_downloads', 'strip': True},
             {'k': 'repo_description', 'strip': True},
             {'k': 'repo_enable_locking', 'strip': True},
             {'k': 'repo_landing_rev', 'strip': True},
             {'k': 'clone_uri', 'strip': False},
             {'k': 'repo_private', 'strip': True},
             {'k': 'repo_enable_statistics', 'strip': True}
         )
 
         for item in keys_to_process:
             attr = item['k']
             if item['strip']:
                 attr = remove_prefix(item['k'], 'repo_')
 
             val = defaults[attr]
             if item['k'] == 'repo_landing_rev':
                 val = ':'.join(defaults[attr])
             defaults[item['k']] = val
             if item['k'] == 'clone_uri':
                 defaults['clone_uri_hidden'] = repo_info.clone_uri_hidden
 
         # fill owner
         if repo_info.user:
             defaults.update({'user': repo_info.user.username})
         else:
             replacement_user = User.get_first_super_admin().username
             defaults.update({'user': replacement_user})
 
         # fill repository users
         for p in repo_info.repo_to_perm:
             defaults.update({'u_perm_%s' % p.user.user_id:
                             p.permission.permission_name})
 
         # fill repository groups
         for p in repo_info.users_group_to_perm:
             defaults.update({'g_perm_%s' % p.users_group.users_group_id:
                             p.permission.permission_name})
 
         return defaults
 
     def update(self, repo, **kwargs):
         try:
             cur_repo = self._get_repo(repo)
             source_repo_name = cur_repo.repo_name
             if 'user' in kwargs:
                 cur_repo.user = User.get_by_username(kwargs['user'])
 
             if 'repo_group' in kwargs:
                 cur_repo.group = RepoGroup.get(kwargs['repo_group'])
             log.debug('Updating repo %s with params:%s', cur_repo, kwargs)
 
             update_keys = [
-                (1, 'repo_enable_downloads'),
                 (1, 'repo_description'),
-                (1, 'repo_enable_locking'),
                 (1, 'repo_landing_rev'),
                 (1, 'repo_private'),
+                (1, 'repo_enable_downloads'),
+                (1, 'repo_enable_locking'),
                 (1, 'repo_enable_statistics'),
                 (0, 'clone_uri'),
                 (0, 'fork_id')
             ]
             for strip, k in update_keys:
                 if k in kwargs:
                     val = kwargs[k]
                     if strip:
                         k = remove_prefix(k, 'repo_')
                     if k == 'clone_uri':
                         from rhodecode.model.validators import Missing
                         _change = kwargs.get('clone_uri_change')
                         if _change in [Missing, 'OLD']:
                             # we don't change the value, so use original one
                             val = cur_repo.clone_uri
 
                     setattr(cur_repo, k, val)
 
             new_name = cur_repo.get_new_name(kwargs['repo_name'])
             cur_repo.repo_name = new_name
 
             # if private flag is set, reset default permission to NONE
             if kwargs.get('repo_private'):
                 EMPTY_PERM = 'repository.none'
                 RepoModel().grant_user_permission(
                     repo=cur_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM
                 )
 
             # handle extra fields
             for field in filter(lambda k: k.startswith(RepositoryField.PREFIX),
                                 kwargs):
                 k = RepositoryField.un_prefix_key(field)
                 ex_field = RepositoryField.get_by_key_name(
                     key=k, repo=cur_repo)
                 if ex_field:
                     ex_field.field_value = kwargs[field]
                     self.sa.add(ex_field)
             self.sa.add(cur_repo)
 
             if source_repo_name != new_name:
                 # rename repository
                 self._rename_filesystem_repo(
                     old=source_repo_name, new=new_name)
 
             return cur_repo
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def _create_repo(self, repo_name, repo_type, description, owner,
                      private=False, clone_uri=None, repo_group=None,
                      landing_rev='rev:tip', fork_of=None,
                      copy_fork_permissions=False, enable_statistics=False,
                      enable_locking=False, enable_downloads=False,
                      copy_group_permissions=False,
                      state=Repository.STATE_PENDING):
         """
         Create repository inside database with PENDING state, this should be
         only executed by create() repo. With exception of importing existing
         repos
         """
         from rhodecode.model.scm import ScmModel
 
         owner = self._get_user(owner)
         fork_of = self._get_repo(fork_of)
         repo_group = self._get_repo_group(safe_int(repo_group))
 
         try:
             repo_name = safe_unicode(repo_name)
             description = safe_unicode(description)
             # repo name is just a name of repository
             # while repo_name_full is a full qualified name that is combined
             # with name and path of group
             repo_name_full = repo_name
             repo_name = repo_name.split(Repository.NAME_SEP)[-1]
 
             new_repo = Repository()
             new_repo.repo_state = state
             new_repo.enable_statistics = False
             new_repo.repo_name = repo_name_full
             new_repo.repo_type = repo_type
             new_repo.user = owner
             new_repo.group = repo_group
             new_repo.description = description or repo_name
             new_repo.private = private
             new_repo.clone_uri = clone_uri
             new_repo.landing_rev = landing_rev
 
             new_repo.enable_statistics = enable_statistics
             new_repo.enable_locking = enable_locking
             new_repo.enable_downloads = enable_downloads
 
             if repo_group:
                 new_repo.enable_locking = repo_group.enable_locking
 
             if fork_of:
                 parent_repo = fork_of
                 new_repo.fork = parent_repo
 
             events.trigger(events.RepoPreCreateEvent(new_repo))
 
             self.sa.add(new_repo)
 
             EMPTY_PERM = 'repository.none'
             if fork_of and copy_fork_permissions:
                 repo = fork_of
                 user_perms = UserRepoToPerm.query() \
                     .filter(UserRepoToPerm.repository == repo).all()
                 group_perms = UserGroupRepoToPerm.query() \
                     .filter(UserGroupRepoToPerm.repository == repo).all()
 
                 for perm in user_perms:
                     UserRepoToPerm.create(
                         perm.user, new_repo, perm.permission)
 
                 for perm in group_perms:
                     UserGroupRepoToPerm.create(
                         perm.users_group, new_repo, perm.permission)
                 # in case we copy permissions and also set this repo to private
                 # override the default user permission to make it a private
                 # repo
                 if private:
                     RepoModel(self.sa).grant_user_permission(
                         repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
 
             elif repo_group and copy_group_permissions:
                 user_perms = UserRepoGroupToPerm.query() \
                     .filter(UserRepoGroupToPerm.group == repo_group).all()
 
                 group_perms = UserGroupRepoGroupToPerm.query() \
                     .filter(UserGroupRepoGroupToPerm.group == repo_group).all()
 
                 for perm in user_perms:
                     perm_name = perm.permission.permission_name.replace(
                         'group.', 'repository.')
                     perm_obj = Permission.get_by_key(perm_name)
                     UserRepoToPerm.create(perm.user, new_repo, perm_obj)
 
                 for perm in group_perms:
                     perm_name = perm.permission.permission_name.replace(
                         'group.', 'repository.')
                     perm_obj = Permission.get_by_key(perm_name)
                     UserGroupRepoToPerm.create(
                         perm.users_group, new_repo, perm_obj)
 
                 if private:
                     RepoModel(self.sa).grant_user_permission(
                         repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
 
             else:
                 perm_obj = self._create_default_perms(new_repo, private)
                 self.sa.add(perm_obj)
 
             # now automatically start following this repository as owner
             ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,
                                                     owner.user_id)
 
             # we need to flush here, in order to check if database won't
             # throw any exceptions, create filesystem dirs at the very end
             self.sa.flush()
             events.trigger(events.RepoCreateEvent(new_repo))
             return new_repo
 
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def create(self, form_data, cur_user):
         """
         Create repository using celery tasks
 
         :param form_data:
         :param cur_user:
         """
         from rhodecode.lib.celerylib import tasks, run_task
         return run_task(tasks.create_repo, form_data, cur_user)
 
     def update_permissions(self, repo, perm_additions=None, perm_updates=None,
                            perm_deletions=None, check_perms=True,
                            cur_user=None):
         if not perm_additions:
             perm_additions = []
         if not perm_updates:
             perm_updates = []
         if not perm_deletions:
             perm_deletions = []
 
         req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')
 
         # update permissions
         for member_id, perm, member_type in perm_updates:
             member_id = int(member_id)
             if member_type == 'user':
                 # this updates also current one if found
                 self.grant_user_permission(
                     repo=repo, user=member_id, perm=perm)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
                         repo=repo, group_name=member_id, perm=perm)
 
         # set new permissions
         for member_id, perm, member_type in perm_additions:
             member_id = int(member_id)
             if member_type == 'user':
                 self.grant_user_permission(
                     repo=repo, user=member_id, perm=perm)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
                         repo=repo, group_name=member_id, perm=perm)
 
         # delete permissions
         for member_id, perm, member_type in perm_deletions:
             member_id = int(member_id)
             if member_type == 'user':
                 self.revoke_user_permission(repo=repo, user=member_id)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.revoke_user_group_permission(
                         repo=repo, group_name=member_id)
 
     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
         return run_task(tasks.create_repo_fork, form_data, cur_user)
 
     def delete(self, repo, forks=None, fs_remove=True, cur_user=None):
         """
         Delete given repository, forks parameter defines what do do with
         attached forks. Throws AttachedForksError if deleted repo has attached
         forks
 
         :param repo:
         :param forks: str 'delete' or 'detach'
         :param fs_remove: remove(archive) repo from filesystem
         """
         if not cur_user:
             cur_user = getattr(get_current_rhodecode_user(), 'username', None)
         repo = self._get_repo(repo)
         if repo:
             if forks == 'detach':
                 for r in repo.forks:
                     r.fork = None
                     self.sa.add(r)
             elif forks == 'delete':
                 for r in repo.forks:
                     self.delete(r, forks='delete')
             elif [f for f in repo.forks]:
                 raise AttachedForksError()
 
             old_repo_dict = repo.get_dict()
             events.trigger(events.RepoPreDeleteEvent(repo))
             try:
                 self.sa.delete(repo)
                 if fs_remove:
                     self._delete_filesystem_repo(repo)
                 else:
                     log.debug('skipping removal from filesystem')
                 old_repo_dict.update({
                     'deleted_by': cur_user,
                     'deleted_on': time.time(),
                 })
                 log_delete_repository(**old_repo_dict)
                 events.trigger(events.RepoDeleteEvent(repo))
             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)
 
         # check if we have that permission already
         obj = self.sa.query(UserRepoToPerm) \
             .filter(UserRepoToPerm.user == user) \
             .filter(UserRepoToPerm.repository == repo) \
             .scalar()
         if obj is None:
             # create new !
             obj = UserRepoToPerm()
         obj.repository = repo
         obj.user = user
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, user, repo)
         action_logger_generic(
             'granted permission: {} to user: {} on repo: {}'.format(
                 perm, user, repo), namespace='security.repo')
         return obj
 
     def revoke_user_permission(self, repo, user):
         """
         Revoke permission for user on given repository
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param user: Instance of User, user_id or username
         """
 
         user = self._get_user(user)
         repo = self._get_repo(repo)
 
         obj = self.sa.query(UserRepoToPerm) \
             .filter(UserRepoToPerm.repository == repo) \
             .filter(UserRepoToPerm.user == user) \
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm on %s on %s', repo, user)
             action_logger_generic(
                 'revoked permission from user: {} on repo: {}'.format(
                     user, repo), namespace='security.repo')
 
     def grant_user_group_permission(self, repo, group_name, perm):
         """
         Grant permission for user group on given repository, or update
         existing one if found
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         :param perm: Instance of Permission, or permission_name
         """
         repo = self._get_repo(repo)
         group_name = self._get_user_group(group_name)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserGroupRepoToPerm) \
             .filter(UserGroupRepoToPerm.users_group == group_name) \
             .filter(UserGroupRepoToPerm.repository == repo) \
             .scalar()
 
         if obj is None:
             # create new
             obj = UserGroupRepoToPerm()
 
         obj.repository = repo
         obj.users_group = group_name
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, group_name, repo)
         action_logger_generic(
             'granted permission: {} to usergroup: {} on repo: {}'.format(
                 perm, group_name, repo), namespace='security.repo')
 
         return obj
 
     def revoke_user_group_permission(self, repo, group_name):
         """
         Revoke permission for user group on given repository
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         """
         repo = self._get_repo(repo)
         group_name = self._get_user_group(group_name)
 
         obj = self.sa.query(UserGroupRepoToPerm) \
             .filter(UserGroupRepoToPerm.repository == repo) \
             .filter(UserGroupRepoToPerm.users_group == group_name) \
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm to %s on %s', repo, group_name)
             action_logger_generic(
                 'revoked permission from usergroup: {} on repo: {}'.format(
                     group_name, repo), namespace='security.repo')
 
     def delete_stats(self, repo_name):
         """
         removes stats for given repo
 
         :param repo_name:
         """
         repo = self._get_repo(repo_name)
         try:
             obj = self.sa.query(Statistics) \
                 .filter(Statistics.repository == repo).scalar()
             if obj:
                 self.sa.delete(obj)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def add_repo_field(self, repo_name, field_key, field_label, field_value='',
                        field_type='str', field_desc=''):
 
         repo = self._get_repo(repo_name)
 
         new_field = RepositoryField()
         new_field.repository = repo
         new_field.field_key = field_key
         new_field.field_type = field_type  # python type
         new_field.field_value = field_value
         new_field.field_desc = field_desc
         new_field.field_label = field_label
         self.sa.add(new_field)
         return new_field
 
     def delete_repo_field(self, repo_name, field_key):
         repo = self._get_repo(repo_name)
         field = RepositoryField.get_by_key_name(field_key, repo)
         if field:
             self.sa.delete(field)
 
     def _create_filesystem_repo(self, repo_name, repo_type, repo_group,
                                 clone_uri=None, repo_store_location=None,
                                 use_global_config=False):
         """
         makes repository on filesystem. It's group aware means it'll create
         a repository within a group, and alter the paths accordingly of
         group location
 
         :param repo_name:
         :param alias:
         :param parent:
         :param clone_uri:
         :param repo_store_location:
         """
         from rhodecode.lib.utils import is_valid_repo, is_valid_repo_group
         from rhodecode.model.scm import ScmModel
 
         if Repository.NAME_SEP in repo_name:
             raise ValueError(
                 'repo_name must not contain groups got `%s`' % repo_name)
 
         if isinstance(repo_group, RepoGroup):
             new_parent_path = os.sep.join(repo_group.full_path_splitted)
         else:
             new_parent_path = repo_group or ''
 
         if repo_store_location:
             _paths = [repo_store_location]
         else:
             _paths = [self.repos_path, new_parent_path, repo_name]
             # we need to make it str for mercurial
         repo_path = os.path.join(*map(lambda x: safe_str(x), _paths))
 
         # check if this path is not a repository
         if is_valid_repo(repo_path, self.repos_path):
             raise Exception('This path %s is a valid repository' % repo_path)
 
         # check if this path is a group
         if is_valid_repo_group(repo_path, self.repos_path):
             raise Exception('This path %s is a valid group' % repo_path)
 
         log.info('creating repo %s in %s from url: `%s`',
                  repo_name, safe_unicode(repo_path),
                  obfuscate_url_pw(clone_uri))
 
         backend = get_backend(repo_type)
 
         config_repo = None if use_global_config else repo_name
         if config_repo and new_parent_path:
             config_repo = Repository.NAME_SEP.join(
                 (new_parent_path, config_repo))
         config = make_db_config(clear_session=False, repo=config_repo)
         config.set('extensions', 'largefiles', '')
 
         # patch and reset hooks section of UI config to not run any
         # hooks on creating remote repo
         config.clear_section('hooks')
 
         # TODO: johbo: Unify this, hardcoded "bare=True" does not look nice
         if repo_type == 'git':
             repo = backend(
                 repo_path, config=config, create=True, src_url=clone_uri,
                 bare=True)
         else:
             repo = backend(
                 repo_path, config=config, create=True, src_url=clone_uri)
 
         ScmModel().install_hooks(repo, repo_type=repo_type)
 
         log.debug('Created repo %s with %s backend',
                   safe_unicode(repo_name), safe_unicode(repo_type))
         return repo
 
     def _rename_filesystem_repo(self, old, new):
         """
         renames repository on filesystem
 
         :param old: old name
         :param new: new name
         """
         log.info('renaming repo from %s to %s', old, new)
 
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
         if os.path.isdir(new_path):
             raise Exception(
                 'Was trying to rename to already existing dir %s' % new_path
             )
         shutil.move(old_path, new_path)
 
     def _delete_filesystem_repo(self, repo):
         """
         removes repo from filesystem, the removal is acctually made by
         added rm__ prefix into dir, and rename internat .hg/.git dirs so this
         repository is no longer valid for rhodecode, can be undeleted later on
         by reverting the renames on this repository
 
         :param repo: repo object
         """
         rm_path = os.path.join(self.repos_path, repo.repo_name)
         repo_group = repo.group
         log.info("Removing repository %s", rm_path)
         # disable hg/git internal that it doesn't get detected as repo
         alias = repo.repo_type
 
         config = make_db_config(clear_session=False)
         config.set('extensions', 'largefiles', '')
         bare = getattr(repo.scm_instance(config=config), 'bare', False)
 
         # skip this for bare git repos
         if not bare:
             # disable VCS repo
             vcs_path = os.path.join(rm_path, '.%s' % alias)
             if os.path.exists(vcs_path):
                 shutil.move(vcs_path, os.path.join(rm_path, 'rm__.%s' % alias))
 
         _now = datetime.now()
         _ms = str(_now.microsecond).rjust(6, '0')
         _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),
                              repo.just_name)
         if repo_group:
             # if repository is in group, prefix the removal path with the group
             args = repo_group.full_path_splitted + [_d]
             _d = os.path.join(*args)
 
         if os.path.isdir(rm_path):
             shutil.move(rm_path, os.path.join(self.repos_path, _d))
 
 
 class ReadmeFinder:
     """
     Utility which knows how to find a readme for a specific commit.
 
     The main idea is that this is a configurable algorithm. When creating an
     instance you can define parameters, currently only the `default_renderer`.
     Based on this configuration the method :meth:`search` behaves slightly
     different.
     """
 
     readme_re = re.compile(r'^readme(\.[^\.]+)?$', re.IGNORECASE)
     path_re = re.compile(r'^docs?', re.IGNORECASE)
 
     default_priorities = {
         None: 0,
         '.text': 2,
         '.txt': 3,
         '.rst': 1,
         '.rest': 2,
         '.md': 1,
         '.mkdn': 2,
         '.mdown': 3,
         '.markdown': 4,
     }
 
     path_priority = {
         'doc': 0,
         'docs': 1,
     }
 
     FALLBACK_PRIORITY = 99
 
     RENDERER_TO_EXTENSION = {
         'rst': ['.rst', '.rest'],
         'markdown': ['.md', 'mkdn', '.mdown', '.markdown'],
     }
 
     def __init__(self, default_renderer=None):
         self._default_renderer = default_renderer
         self._renderer_extensions = self.RENDERER_TO_EXTENSION.get(
             default_renderer, [])
 
     def search(self, commit, path='/'):
         """
         Find a readme in the given `commit`.
         """
         nodes = commit.get_nodes(path)
         matches = self._match_readmes(nodes)
         matches = self._sort_according_to_priority(matches)
         if matches:
             return matches[0].node
 
         paths = self._match_paths(nodes)
         paths = self._sort_paths_according_to_priority(paths)
         for path in paths:
             match = self.search(commit, path=path)
             if match:
                 return match
 
         return None
 
     def _match_readmes(self, nodes):
         for node in nodes:
             if not node.is_file():
                 continue
             path = node.path.rsplit('/', 1)[-1]
             match = self.readme_re.match(path)
             if match:
                 extension = match.group(1)
                 yield ReadmeMatch(node, match, self._priority(extension))
 
     def _match_paths(self, nodes):
         for node in nodes:
             if not node.is_dir():
                 continue
             match = self.path_re.match(node.path)
             if match:
                 yield node.path
 
     def _priority(self, extension):
         renderer_priority = (
             0 if extension in self._renderer_extensions else 1)
         extension_priority = self.default_priorities.get(
             extension, self.FALLBACK_PRIORITY)
         return (renderer_priority, extension_priority)
 
     def _sort_according_to_priority(self, matches):
 
         def priority_and_path(match):
             return (match.priority, match.path)
 
         return sorted(matches, key=priority_and_path)
 
     def _sort_paths_according_to_priority(self, paths):
 
         def priority_and_path(path):
             return (self.path_priority.get(path, self.FALLBACK_PRIORITY), path)
 
         return sorted(paths, key=priority_and_path)
 
 
 class ReadmeMatch:
 
     def __init__(self, node, match, priority):
         self.node = node
         self._match = match
         self.priority = priority
 
     @property
     def path(self):
         return self.node.path
 
     def __repr__(self):
         return '<ReadmeMatch {} priority={}'.format(self.path, self.priority)

rhodecode/model/scm.py

@@ -1,911 +1,915 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Scm model for RhodeCode
 """
 
 import os.path
 import re
 import sys
 import traceback
 import logging
 import cStringIO
 import pkg_resources
 
 from pylons.i18n.translation import _
 from sqlalchemy import func
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
 from rhodecode.lib.vcs import get_backend
 from rhodecode.lib.vcs.exceptions import RepositoryError, NodeNotChangedError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib import helpers as h
 
 from rhodecode.lib.auth import (
     HasRepoPermissionAny, HasRepoGroupPermissionAny,
     HasUserGroupPermissionAny)
 from rhodecode.lib.exceptions import NonRelativePathError, IMCCommitError
 from rhodecode.lib import hooks_utils, caches
 from rhodecode.lib.utils import (
     get_filesystem_repos, action_logger, make_db_config)
 from rhodecode.lib.utils2 import (safe_str, safe_unicode)
 from rhodecode.lib.system_info import get_system_info
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     Repository, CacheKey, UserFollowing, UserLog, User, RepoGroup,
     PullRequest)
 from rhodecode.model.settings import VcsSettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
 
 
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
 
 
 class SimpleCachedRepoList(object):
     """
     Lighter version of of iteration of repos without the scm initialisation,
     and with cache usage
     """
     def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):
         self.db_repo_list = db_repo_list
         self.repos_path = repos_path
         self.order_by = order_by
         self.reversed = (order_by or '').startswith('-')
         if not perm_set:
             perm_set = ['repository.read', 'repository.write',
                         'repository.admin']
         self.perm_set = perm_set
 
     def __len__(self):
         return len(self.db_repo_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         for dbr in self.db_repo_list:
             # check permission at this level
             has_perm = HasRepoPermissionAny(*self.perm_set)(
                 dbr.repo_name, 'SimpleCachedRepoList check')
             if not has_perm:
                 continue
 
             tmp_d = {
                 'name': dbr.repo_name,
                 'dbrepo': dbr.get_dict(),
                 'dbrepo_fork': dbr.fork.get_dict() if dbr.fork else {}
             }
             yield tmp_d
 
 
 class _PermCheckIterator(object):
 
     def __init__(
             self, obj_list, obj_attr, perm_set, perm_checker,
             extra_kwargs=None):
         """
         Creates iterator from given list of objects, additionally
         checking permission for them from perm_set var
 
         :param obj_list: list of db objects
         :param obj_attr: attribute of object to pass into perm_checker
         :param perm_set: list of permissions to check
         :param perm_checker: callable to check permissions against
         """
         self.obj_list = obj_list
         self.obj_attr = obj_attr
         self.perm_set = perm_set
         self.perm_checker = perm_checker
         self.extra_kwargs = extra_kwargs or {}
 
     def __len__(self):
         return len(self.obj_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         checker = self.perm_checker(*self.perm_set)
         for db_obj in self.obj_list:
             # check permission at this level
             name = getattr(db_obj, self.obj_attr, None)
             if not checker(name, self.__class__.__name__, **self.extra_kwargs):
                 continue
 
             yield db_obj
 
 
 class RepoList(_PermCheckIterator):
 
     def __init__(self, db_repo_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = [
                 'repository.read', 'repository.write', 'repository.admin']
 
         super(RepoList, self).__init__(
             obj_list=db_repo_list,
             obj_attr='repo_name', perm_set=perm_set,
             perm_checker=HasRepoPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class RepoGroupList(_PermCheckIterator):
 
     def __init__(self, db_repo_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['group.read', 'group.write', 'group.admin']
 
         super(RepoGroupList, self).__init__(
             obj_list=db_repo_group_list,
             obj_attr='group_name', perm_set=perm_set,
             perm_checker=HasRepoGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class UserGroupList(_PermCheckIterator):
 
     def __init__(self, db_user_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']
 
         super(UserGroupList, self).__init__(
             obj_list=db_user_group_list,
             obj_attr='users_group_name', perm_set=perm_set,
             perm_checker=HasUserGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class ScmModel(BaseModel):
     """
     Generic Scm Model
     """
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
 
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def repo_scan(self, repos_path=None):
         """
         Listing of repositories in given path. This path should not be a
         repository itself. Return a dictionary of repository objects
 
         :param repos_path: path to directory containing repositories
         """
 
         if repos_path is None:
             repos_path = self.repos_path
 
         log.info('scanning for repositories in %s', repos_path)
 
         config = make_db_config()
         config.set('extensions', 'largefiles', '')
         repos = {}
 
         for name, path in get_filesystem_repos(repos_path, recursive=True):
             # name need to be decomposed and put back together using the /
             # since this is internal storage separator for rhodecode
             name = Repository.normalize_repo_name(name)
 
             try:
                 if name in repos:
                     raise RepositoryError('Duplicate repository name %s '
                                           'found in %s' % (name, path))
                 elif path[0] in rhodecode.BACKENDS:
                     klass = get_backend(path[0])
                     repos[name] = klass(path[1], config=config)
             except OSError:
                 continue
         log.debug('found %s paths with repositories', len(repos))
         return repos
 
     def get_repos(self, all_repos=None, sort_key=None):
         """
         Get all repositories from db and for each repo create it's
         backend instance and fill that backed with information from database
 
         :param all_repos: list of repository names as strings
             give specific repositories list, good for filtering
 
         :param sort_key: initial sorting of repositories
         """
         if all_repos is None:
             all_repos = self.sa.query(Repository)\
                 .filter(Repository.group_id == None)\
                 .order_by(func.lower(Repository.repo_name)).all()
         repo_iter = SimpleCachedRepoList(
             all_repos, repos_path=self.repos_path, order_by=sort_key)
         return repo_iter
 
     def get_repo_groups(self, all_groups=None):
         if all_groups is None:
             all_groups = RepoGroup.query()\
                 .filter(RepoGroup.group_parent_id == None).all()
         return [x for x in RepoGroupList(all_groups)]
 
     def mark_for_invalidation(self, repo_name, delete=False):
         """
         Mark caches of this repo invalid in the database. `delete` flag
         removes the cache entries
 
         :param repo_name: the repo_name for which caches should be marked
             invalid, or deleted
         :param delete: delete the entry keys instead of setting bool
             flag on them
         """
         CacheKey.set_invalidate(repo_name, delete=delete)
         repo = Repository.get_by_repo_name(repo_name)
 
         if repo:
             config = repo._config
             config.set('extensions', 'largefiles', '')
             repo.update_commit_cache(config=config, cs_cache=None)
             caches.clear_repo_caches(repo_name)
 
     def toggle_following_repo(self, follow_repo_id, user_id):
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repo_id == follow_repo_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 action_logger(UserTemp(user_id),
                               'stopped_following_repo',
                               RepoTemp(follow_repo_id))
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_repo_id = follow_repo_id
             self.sa.add(f)
 
             action_logger(UserTemp(user_id),
                           'started_following_repo',
                           RepoTemp(follow_repo_id))
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def toggle_following_user(self, follow_user_id, user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def is_following_user(self, username, user_id, cache=False):
         u = User.get_by_username(username)
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def get_followers(self, repo):
         repo = self._get_repo(repo)
 
         return self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == repo).count()
 
     def get_forks(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(Repository)\
             .filter(Repository.fork == repo).count()
 
     def get_pull_requests(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(PullRequest)\
             .filter(PullRequest.target_repo == repo)\
             .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()
 
     def mark_as_fork(self, repo, fork, user):
         repo = self._get_repo(repo)
         fork = self._get_repo(fork)
         if fork and repo.repo_id == fork.repo_id:
             raise Exception("Cannot set repository as fork of itself")
 
         if fork and repo.repo_type != fork.repo_type:
             raise RepositoryError(
                 "Cannot set repository as fork of repository with other type")
 
         repo.fork = fork
         self.sa.add(repo)
         return repo
 
     def pull_changes(self, repo, username):
         dbrepo = self._get_repo(repo)
         clone_uri = dbrepo.clone_uri
         if not clone_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         # TODO: marcink fix this an re-enable since we need common logic
         # for hg/git remove hooks so we don't trigger them on fetching
         # commits from remote
         repo.config.clear_section('hooks')
 
         repo_name = dbrepo.repo_name
         try:
             # TODO: we need to make sure those operations call proper hooks !
             repo.pull(clone_uri)
 
             self.mark_for_invalidation(repo_name)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def commit_change(self, repo, repo_name, commit, user, author, message,
                       content, f_path):
         """
         Commits changes
 
         :param repo: SCM instance
 
         """
         user = self._get_user(user)
 
         # decoding here will force that we have proper encoded values
         # in any other case this will throw exceptions and deny commit
         content = safe_str(content)
         path = safe_str(f_path)
         # message and author needs to be unicode
         # proper backend should then translate that into required type
         message = safe_unicode(message)
         author = safe_unicode(author)
         imc = repo.in_memory_commit
         imc.change(FileNode(path, content, mode=commit.get_file_mode(f_path)))
         try:
             # TODO: handle pre-push action !
             tip = imc.commit(
                 message=message, author=author, parents=[commit],
                 branch=commit.branch)
         except Exception as e:
             log.error(traceback.format_exc())
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo_name)
 
         # We trigger the post-push action
         hooks_utils.trigger_post_push_hook(
             username=user.username, action='push_local', repo_name=repo_name,
             repo_alias=repo.alias, commit_ids=[tip.raw_id])
         return tip
 
     def _sanitize_path(self, f_path):
         if f_path.startswith('/') or f_path.startswith('./') or '../' in f_path:
             raise NonRelativePathError('%s is not an relative path' % f_path)
         if f_path:
             f_path = os.path.normpath(f_path)
         return f_path
 
     def get_dirnode_metadata(self, commit, dir_node):
         if not dir_node.is_dir():
             return []
 
         data = []
         for node in dir_node:
             if not node.is_file():
                 # we skip file-nodes
                 continue
 
             last_commit = node.last_commit
             last_commit_date = last_commit.date
             data.append({
                 'name': node.name,
                 'size': h.format_byte_size_binary(node.size),
                 'modified_at': h.format_date(last_commit_date),
                 'modified_ts': last_commit_date.isoformat(),
                 'revision': last_commit.revision,
                 'short_id': last_commit.short_id,
                 'message': h.escape(last_commit.message),
                 'author': h.escape(last_commit.author),
                 'user_profile': h.gravatar_with_user(last_commit.author),
             })
 
         return data
 
     def get_nodes(self, repo_name, commit_id, root_path='/', flat=True,
                   extended_info=False, content=False, max_file_bytes=None):
         """
         recursive walk in root dir and return a set of all path in that dir
         based on repository walk function
 
         :param repo_name: name of repository
         :param commit_id: commit id for which to list nodes
         :param root_path: root path to list
         :param flat: return as a list, if False returns a dict with description
         :param max_file_bytes: will not return file contents over this limit
 
         """
         _files = list()
         _dirs = list()
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
             for __, dirs, files in commit.walk(root_path):
                 for f in files:
                     _content = None
                     _data = f.unicode_path
                     over_size_limit = (max_file_bytes is not None
                                        and f.size > max_file_bytes)
 
                     if not flat:
                         _data = {
                             "name": f.unicode_path,
                             "type": "file",
                             }
                         if extended_info:
                             _data.update({
                                 "md5": f.md5,
                                 "binary": f.is_binary,
                                 "size": f.size,
                                 "extension": f.extension,
                                 "mimetype": f.mimetype,
                                 "lines": f.lines()[0]
                             })
 
                         if content:
                             full_content = None
                             if not f.is_binary and not over_size_limit:
                                 full_content = safe_str(f.content)
 
                             _data.update({
                                 "content": full_content,
                             })
                     _files.append(_data)
                 for d in dirs:
                     _data = d.unicode_path
                     if not flat:
                         _data = {
                             "name": d.unicode_path,
                             "type": "dir",
                             }
                     if extended_info:
                         _data.update({
                             "md5": None,
                             "binary": None,
                             "size": None,
                             "extension": None,
                         })
                     if content:
                         _data.update({
                             "content": None
                         })
                     _dirs.append(_data)
         except RepositoryError:
             log.debug("Exception in get_nodes", exc_info=True)
             raise
 
         return _dirs, _files
 
     def create_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Commits given multiple nodes into repo
 
         :param user: RhodeCode User object or user_id, the commiter
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's
            initial commit
         :param author: author of commit, cna be different that commiter
            only for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commited commit
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             content = nodes[f_path]['content']
             f_path = safe_str(f_path)
             # decoding here will force that we have proper encoded values
             # in any other case this will throw exceptions and deny commit
             if isinstance(content, (basestring,)):
                 content = safe_str(content)
             elif isinstance(content, (file, cStringIO.OutputType,)):
                 content = content.read()
             else:
                 raise Exception('Content is of unrecognized type %s' % (
                     type(content)
                 ))
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.add(FileNode(path, content=content))
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def update_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
 
         # add multiple nodes
         for _filename, data in nodes.items():
             # new filename, can be renamed from the old one, also sanitaze
             # the path for any hack around relative paths like ../../ etc.
             filename = self._sanitize_path(data['filename'])
             old_filename = self._sanitize_path(_filename)
             content = data['content']
 
             filenode = FileNode(old_filename, content=content)
             op = data['op']
             if op == 'add':
                 imc.add(filenode)
             elif op == 'del':
                 imc.remove(filenode)
             elif op == 'mod':
                 if filename != old_filename:
                     # TODO: handle renames more efficient, needs vcs lib
                     # changes
                     imc.remove(filenode)
                     imc.add(FileNode(filename, content=content))
                 else:
                     imc.change(filenode)
 
         try:
             # TODO: handle pre push scenario
             # commit changes
             tip = imc.commit(message=message,
                              author=author,
                              parents=parents,
                              branch=parent_commit.branch)
         except NodeNotChangedError:
             raise
         except Exception as e:
             log.exception("Unexpected exception during call to imc.commit")
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo.repo_name)
 
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
 
     def delete_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Deletes given multiple nodes into `repo`
 
         :param user: RhodeCode User object or user_id, the committer
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's initial
            commit
         :param author: author of commit, cna be different that commiter only
            for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commit after deletion
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             # content can be empty but for compatabilty it allows same dicts
             # structure as add_nodes
             content = nodes[f_path].get('content')
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.remove(FileNode(path, content=content))
 
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def strip(self, repo, commit_id, branch):
         scm_instance = repo.scm_instance(cache=False)
         scm_instance.config.clear_section('hooks')
         scm_instance.strip(commit_id, branch)
         self.mark_for_invalidation(repo.repo_name)
 
     def get_unread_journal(self):
         return self.sa.query(UserLog).count()
 
     def get_repo_landing_revs(self, repo=None):
         """
         Generates select option with tags branches and bookmarks (for hg only)
         grouped by type
 
         :param repo:
         """
 
-        hist_l = []
-        choices = []
         repo = self._get_repo(repo)
-        hist_l.append(['rev:tip', _('latest tip')])
-        choices.append('rev:tip')
+
+        hist_l = [
+            ['rev:tip', _('latest tip')]
+        ]
+        choices = [
+            'rev:tip'
+        ]
+
         if not repo:
             return choices, hist_l
 
         repo = repo.scm_instance()
 
         branches_group = (
             [(u'branch:%s' % safe_unicode(b), safe_unicode(b))
                 for b in repo.branches],
             _("Branches"))
         hist_l.append(branches_group)
         choices.extend([x[0] for x in branches_group[0]])
 
         if repo.alias == 'hg':
             bookmarks_group = (
                 [(u'book:%s' % safe_unicode(b), safe_unicode(b))
                     for b in repo.bookmarks],
                 _("Bookmarks"))
             hist_l.append(bookmarks_group)
             choices.extend([x[0] for x in bookmarks_group[0]])
 
         tags_group = (
             [(u'tag:%s' % safe_unicode(t), safe_unicode(t))
                 for t in repo.tags],
             _("Tags"))
         hist_l.append(tags_group)
         choices.extend([x[0] for x in tags_group[0]])
 
         return choices, hist_l
 
     def install_git_hook(self, repo, force_create=False):
         """
         Creates a rhodecode hook inside a git repository
 
         :param repo: Instance of VCS repo
         :param force_create: Create even if same name hook exists
         """
 
         loc = os.path.join(repo.path, 'hooks')
         if not repo.bare:
             loc = os.path.join(repo.path, '.git', 'hooks')
         if not os.path.isdir(loc):
             os.makedirs(loc, mode=0777)
 
         tmpl_post = pkg_resources.resource_string(
             'rhodecode', '/'.join(
                 ('config', 'hook_templates', 'git_post_receive.py.tmpl')))
         tmpl_pre = pkg_resources.resource_string(
             'rhodecode', '/'.join(
                 ('config', 'hook_templates', 'git_pre_receive.py.tmpl')))
 
         for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:
             _hook_file = os.path.join(loc, '%s-receive' % h_type)
             log.debug('Installing git hook in repo %s', repo)
             _rhodecode_hook = _check_rhodecode_hook(_hook_file)
 
             if _rhodecode_hook or force_create:
                 log.debug('writing %s hook file !', h_type)
                 try:
                     with open(_hook_file, 'wb') as f:
                         tmpl = tmpl.replace('_TMPL_', rhodecode.__version__)
                         tmpl = tmpl.replace('_ENV_', sys.executable)
                         f.write(tmpl)
                     os.chmod(_hook_file, 0755)
                 except IOError:
                     log.exception('error writing hook file %s', _hook_file)
             else:
                 log.debug('skipping writing hook file')
 
     def install_svn_hooks(self, repo, force_create=False):
         """
         Creates rhodecode hooks inside a svn repository
 
         :param repo: Instance of VCS repo
         :param force_create: Create even if same name hook exists
         """
         hooks_path = os.path.join(repo.path, 'hooks')
         if not os.path.isdir(hooks_path):
             os.makedirs(hooks_path)
         post_commit_tmpl = pkg_resources.resource_string(
             'rhodecode', '/'.join(
                 ('config', 'hook_templates', 'svn_post_commit_hook.py.tmpl')))
         pre_commit_template = pkg_resources.resource_string(
             'rhodecode', '/'.join(
                 ('config', 'hook_templates', 'svn_pre_commit_hook.py.tmpl')))
         templates = {
             'post-commit': post_commit_tmpl,
             'pre-commit': pre_commit_template
         }
         for filename in templates:
             _hook_file = os.path.join(hooks_path, filename)
             _rhodecode_hook = _check_rhodecode_hook(_hook_file)
             if _rhodecode_hook or force_create:
                 log.debug('writing %s hook file !', filename)
                 template = templates[filename]
                 try:
                     with open(_hook_file, 'wb') as f:
                         template = template.replace(
                             '_TMPL_', rhodecode.__version__)
                         template = template.replace('_ENV_', sys.executable)
                         f.write(template)
                     os.chmod(_hook_file, 0755)
                 except IOError:
                     log.exception('error writing hook file %s', filename)
             else:
                 log.debug('skipping writing hook file')
 
     def install_hooks(self, repo, repo_type):
         if repo_type == 'git':
             self.install_git_hook(repo)
         elif repo_type == 'svn':
             self.install_svn_hooks(repo)
 
     def get_server_info(self, environ=None):
         server_info = get_system_info(environ)
         return server_info
 
 
 def _check_rhodecode_hook(hook_path):
     """
     Check if the hook was created by RhodeCode
     """
     if not os.path.exists(hook_path):
         return True
 
     log.debug('hook exists, checking if it is from rhodecode')
     hook_content = _read_hook(hook_path)
     matches = re.search(r'(?:RC_HOOK_VER)\s*=\s*(.*)', hook_content)
     if matches:
         try:
             version = matches.groups()[0]
             log.debug('got %s, it is rhodecode', version)
             return True
         except Exception:
             log.exception("Exception while reading the hook version.")
 
     return False
 
 
 def _read_hook(hook_path):
     with open(hook_path, 'rb') as f:
         content = f.read()
     return content

rhodecode/model/validation_schema/preparers.py

@@ -1,89 +1,88 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import unicodedata
 
 
-
 def strip_preparer(value):
     """
     strips given values using .strip() function
     """
 
     if value:
         value = value.strip()
     return value
 
 
 def slugify_preparer(value):
     """
     Slugify given value to a safe representation for url/id
     """
     from rhodecode.lib.utils import repo_name_slug
     if value:
         value = repo_name_slug(value.lower())
     return value
 
 
 def non_ascii_strip_preparer(value):
     """
     trie to replace non-ascii letters to their ascii representation
     eg::
 
         `żołw` converts into `zolw`
     """
     if value:
         value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
     return value
 
 
 def unique_list_preparer(value):
     """
     Converts an list to a list with only unique values
     """
 
     def make_unique(value):
         seen = []
         return [c for c in value if
                 not (c in seen or seen.append(c))]
 
     if isinstance(value, list):
         ret_val = make_unique(value)
     elif isinstance(value, set):
         ret_val = list(value)
     elif isinstance(value, tuple):
         ret_val = make_unique(value)
     elif value is None:
         ret_val = []
     else:
         ret_val = [value]
 
     return ret_val
 
 
 def unique_list_from_str_preparer(value):
     """
     Converts an list to a list with only unique values
     """
     from rhodecode.lib.utils2 import aslist
 
     if isinstance(value, basestring):
         value = aslist(value, ',')
     return unique_list_preparer(value)
  No newline at end of file

rhodecode/model/validation_schema/schemas/repo_schema.py

@@ -1,27 +1,321 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 
+from rhodecode.translation import _
 from rhodecode.model.validation_schema import validators, preparers, types
 
+DEFAULT_LANDING_REF = 'rev:tip'
+
+
+def get_group_and_repo(repo_name):
+    from rhodecode.model.repo_group import RepoGroupModel
+    return RepoGroupModel()._get_group_name_and_parent(
+        repo_name, get_object=True)
+
+
[e-mail]
+def deferred_repo_type_validator(node, kw):
+    options = kw.get('repo_type_options', [])
+    return colander.OneOf([x for x in options])
+
+
[e-mail]
+def deferred_repo_owner_validator(node, kw):
+
+    def repo_owner_validator(node, value):
+        from rhodecode.model.db import User
+        existing = User.get_by_username(value)
+        if not existing:
+            msg = _(u'Repo owner with id `{}` does not exists').format(value)
+            raise colander.Invalid(node, msg)
+
+    return repo_owner_validator
+
+
[e-mail]
+def deferred_landing_ref_validator(node, kw):
+    options = kw.get('repo_ref_options', [DEFAULT_LANDING_REF])
+    return colander.OneOf([x for x in options])
+
+
[e-mail]
+def deferred_fork_of_validator(node, kw):
+    old_values = kw.get('old_values') or {}
+
+    def fork_of_validator(node, value):
+        from rhodecode.model.db import Repository, RepoGroup
+        existing = Repository.get_by_repo_name(value)
+        if not existing:
+            msg = _(u'Fork with id `{}` does not exists').format(value)
+            raise colander.Invalid(node, msg)
+        elif old_values['repo_name'] == existing.repo_name:
+            msg = _(u'Cannot set fork of '
+                    u'parameter of this repository to itself').format(value)
+            raise colander.Invalid(node, msg)
+
+    return fork_of_validator
+
+
[e-mail]
+def deferred_can_write_to_group_validator(node, kw):
+    request_user = kw.get('user')
+    old_values = kw.get('old_values') or {}
+
+    def can_write_to_group_validator(node, value):
+        """
+        Checks if given repo path is writable by user. This includes checks if
+        user is allowed to create repositories under root path or under
+        repo group paths
+        """
+
+        from rhodecode.lib.auth import (
+            HasPermissionAny, HasRepoGroupPermissionAny)
+        from rhodecode.model.repo_group import RepoGroupModel
+
+        messages = {
+            'invalid_repo_group':
+                _(u"Repository group `{}` does not exist"),
+            # permissions denied we expose as not existing, to prevent
+            # resource discovery
+            'permission_denied':
+                _(u"Repository group `{}` does not exist"),
+            'permission_denied_root':
+                _(u"You do not have the permission to store "
+                  u"repositories in the root location.")
+        }
+
+        value = value['repo_group_name']
+
+        is_root_location = value is types.RootLocation
+        # NOT initialized validators, we must call them
+        can_create_repos_at_root = HasPermissionAny(
+            'hg.admin', 'hg.create.repository')
+
+        # if values is root location, we simply need to check if we can write
+        # to root location !
+        if is_root_location:
+            if can_create_repos_at_root(user=request_user):
+                # we can create repo group inside tool-level. No more checks
+                # are required
+                return
+            else:
+                # "fake" node name as repo_name, otherwise we oddly report
+                # the error as if it was coming form repo_group
+                # however repo_group is empty when using root location.
+                node.name = 'repo_name'
+                raise colander.Invalid(node, messages['permission_denied_root'])
+
+        # parent group not exists ? throw an error
+        repo_group = RepoGroupModel().get_by_group_name(value)
+        if value and not repo_group:
+            raise colander.Invalid(
+                node, messages['invalid_repo_group'].format(value))
+
+        gr_name = repo_group.group_name
+
+        # create repositories with write permission on group is set to true
+        create_on_write = HasPermissionAny(
+            'hg.create.write_on_repogroup.true')(user=request_user)
+
+        group_admin = HasRepoGroupPermissionAny('group.admin')(
+            gr_name, 'can write into group validator', user=request_user)
+        group_write = HasRepoGroupPermissionAny('group.write')(
+            gr_name, 'can write into group validator', user=request_user)
+
+        forbidden = not (group_admin or (group_write and create_on_write))
+
+        # TODO: handling of old values, and detecting no-change in path
+        # to skip permission checks in such cases. This only needs to be
+        # implemented if we use this schema in forms as well
+
+        # gid = (old_data['repo_group'].get('group_id')
+        #        if (old_data and 'repo_group' in old_data) else None)
+        # value_changed = gid != safe_int(value)
+        # new = not old_data
+
+        # do check if we changed the value, there's a case that someone got
+        # revoked write permissions to a repository, he still created, we
+        # don't need to check permission if he didn't change the value of
+        # groups in form box
+        # if value_changed or new:
+        #     # parent group need to be existing
+        # TODO: ENDS HERE
+
+        if repo_group and forbidden:
+            msg = messages['permission_denied'].format(value)
+            raise colander.Invalid(node, msg)
+
+    return can_write_to_group_validator
+
 
-class RepoSchema(colander.Schema):
-    repo_name = colander.SchemaNode(types.GroupNameType())
[e-mail]
+def deferred_unique_name_validator(node, kw):
+    request_user = kw.get('user')
+    old_values = kw.get('old_values') or {}
+
+    def unique_name_validator(node, value):
+        from rhodecode.model.db import Repository, RepoGroup
+        name_changed = value != old_values.get('repo_name')
+
+        existing = Repository.get_by_repo_name(value)
+        if name_changed and existing:
+            msg = _(u'Repository with name `{}` already exists').format(value)
+            raise colander.Invalid(node, msg)
+
+        existing_group = RepoGroup.get_by_group_name(value)
+        if name_changed and existing_group:
+            msg = _(u'Repository group with name `{}` already exists').format(
+                value)
+            raise colander.Invalid(node, msg)
+    return unique_name_validator
+
+
[e-mail]
+def deferred_repo_name_validator(node, kw):
+    return validators.valid_name_validator
+
+
+class GroupType(colander.Mapping):
+    def _validate(self, node, value):
+        try:
+            return dict(repo_group_name=value)
+        except Exception as e:
+            raise colander.Invalid(
+                node, '"${val}" is not a mapping type: ${err}'.format(
+                    val=value, err=e))
+
+    def deserialize(self, node, cstruct):
+        if cstruct is colander.null:
+            return cstruct
+
+        appstruct = super(GroupType, self).deserialize(node, cstruct)
+        validated_name = appstruct['repo_group_name']
+
+        # inject group based on once deserialized data
+        (repo_name_without_group,
+         parent_group_name,
+         parent_group) = get_group_and_repo(validated_name)
+
+        appstruct['repo_name_without_group'] = repo_name_without_group
+        appstruct['repo_group_name'] = parent_group_name or types.RootLocation
+        if parent_group:
+            appstruct['repo_group_id'] = parent_group.group_id
+
+        return appstruct
+
+
+class GroupSchema(colander.SchemaNode):
+    schema_type = GroupType
+    validator = deferred_can_write_to_group_validator
+    missing = colander.null
+
+
+class RepoGroup(GroupSchema):
+    repo_group_name = colander.SchemaNode(
+        types.GroupNameType())
+    repo_group_id = colander.SchemaNode(
+        colander.String(), missing=None)
+    repo_name_without_group = colander.SchemaNode(
+        colander.String(), missing=None)
+
+
+class RepoGroupAccessSchema(colander.MappingSchema):
+    repo_group = RepoGroup()
+
+
+class RepoNameUniqueSchema(colander.MappingSchema):
+    unique_repo_name = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_unique_name_validator)
+
+
+class RepoSchema(colander.MappingSchema):
+
+    repo_name = colander.SchemaNode(
+        types.RepoNameType(),
+        validator=deferred_repo_name_validator)
+
+    repo_type = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_repo_type_validator)
+
+    repo_owner = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_repo_owner_validator)
+
+    repo_description = colander.SchemaNode(
+        colander.String(), missing='')
+
+    repo_landing_commit_ref = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_landing_ref_validator,
+        preparers=[preparers.strip_preparer],
+        missing=DEFAULT_LANDING_REF)
+
+    repo_clone_uri = colander.SchemaNode(
+        colander.String(),
+        validator=colander.All(colander.Length(min=1)),
+        preparers=[preparers.strip_preparer],
+        missing='')
+
+    repo_fork_of = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_fork_of_validator,
+        missing=None)
+
+    repo_private = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_copy_permissions = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_statistics = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_downloads = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_locking = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+
+    def deserialize(self, cstruct):
+        """
+        Custom deserialize that allows to chain validation, and verify
+        permissions, and as last step uniqueness
+        """
+
+        # first pass, to validate given data
+        appstruct = super(RepoSchema, self).deserialize(cstruct)
+        validated_name = appstruct['repo_name']
+
+        # second pass to validate permissions to repo_group
+        second = RepoGroupAccessSchema().bind(**self.bindings)
+        appstruct_second = second.deserialize({'repo_group': validated_name})
+        # save result
+        appstruct['repo_group'] = appstruct_second['repo_group']
+
+        # thirds to validate uniqueness
+        third = RepoNameUniqueSchema().bind(**self.bindings)
+        third.deserialize({'unique_repo_name': validated_name})
+
+        return appstruct

rhodecode/model/validation_schema/schemas/search_schema.py

@@ -1,44 +1,43 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import colander
 
 
 class SearchParamsSchema(colander.MappingSchema):
     search_query = colander.SchemaNode(
         colander.String(),
         missing='')
     search_type = colander.SchemaNode(
         colander.String(),
         missing='content',
         validator=colander.OneOf(['content', 'path', 'commit', 'repository']))
     search_sort = colander.SchemaNode(
         colander.String(),
         missing='newfirst',
-        validator=colander.OneOf(
-            ['oldfirst', 'newfirst']))
+        validator=colander.OneOf(['oldfirst', 'newfirst']))
     page_limit = colander.SchemaNode(
         colander.Integer(),
         missing=10,
         validator=colander.Range(1, 500))
     requested_page = colander.SchemaNode(
         colander.Integer(),
         missing=1)

rhodecode/model/validation_schema/types.py

@@ -1,137 +1,188 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import re
+
 import colander
+from rhodecode.model.validation_schema import preparers
+from rhodecode.model.db import User, UserGroup
+
+
+class _RootLocation(object):
+    pass
+
+RootLocation = _RootLocation()
+
+
+def _normalize(seperator, path):
+
+    if not path:
+        return ''
+    elif path is colander.null:
+        return colander.null
+
+    parts = path.split(seperator)
 
-from rhodecode.model.db import User, UserGroup
+    def bad_parts(value):
+        if not value:
+            return False
+        if re.match(r'^[.]+$', value):
+            return False
+
+        return True
+
+    def slugify(value):
+        value = preparers.slugify_preparer(value)
+        value = re.sub(r'[.]{2,}', '.', value)
+        return value
+
+    clean_parts = [slugify(item) for item in parts if item]
+    path = filter(bad_parts, clean_parts)
+    return seperator.join(path)
+
+
+class RepoNameType(colander.String):
+    SEPARATOR = '/'
+
+    def deserialize(self, node, cstruct):
+        result = super(RepoNameType, self).deserialize(node, cstruct)
+        if cstruct is colander.null:
+            return colander.null
+        return self._normalize(result)
+
+    def _normalize(self, path):
+        return _normalize(self.SEPARATOR, path)
 
 
 class GroupNameType(colander.String):
     SEPARATOR = '/'
 
     def deserialize(self, node, cstruct):
-        result = super(GroupNameType, self).deserialize(node, cstruct)
-        return self._replace_extra_slashes(result)
+        if cstruct is RootLocation:
+            return cstruct
 
-    def _replace_extra_slashes(self, path):
-        path = path.split(self.SEPARATOR)
-        path = [item for item in path if item]
-        return self.SEPARATOR.join(path)
+        result = super(GroupNameType, self).deserialize(node, cstruct)
+        if cstruct is colander.null:
+            return colander.null
+        return self._normalize(result)
+
+    def _normalize(self, path):
+        return _normalize(self.SEPARATOR, path)
 
 
 class StringBooleanType(colander.String):
     true_values = ['true', 't', 'yes', 'y', 'on', '1']
     false_values = ['false', 'f', 'no', 'n', 'off', '0']
 
     def serialize(self, node, appstruct):
         if appstruct is colander.null:
             return colander.null
         if not isinstance(appstruct, bool):
             raise colander.Invalid(node, '%r is not a boolean' % appstruct)
 
         return appstruct and 'true' or 'false'
 
     def deserialize(self, node, cstruct):
         if cstruct is colander.null:
             return colander.null
 
         if isinstance(cstruct, bool):
             return cstruct
 
         if not isinstance(cstruct, basestring):
             raise colander.Invalid(node, '%r is not a string' % cstruct)
 
         value = cstruct.lower()
         if value in self.true_values:
             return True
         elif value in self.false_values:
             return False
         else:
             raise colander.Invalid(
                 node, '{} value cannot be translated to bool'.format(value))
 
 
 class UserOrUserGroupType(colander.SchemaType):
     """ colander Schema type for valid rhodecode user and/or usergroup """
     scopes = ('user', 'usergroup')
 
     def __init__(self):
         self.users = 'user' in self.scopes
         self.usergroups = 'usergroup' in self.scopes
 
     def serialize(self, node, appstruct):
         if appstruct is colander.null:
             return colander.null
 
         if self.users:
             if isinstance(appstruct, User):
                 if self.usergroups:
                     return 'user:%s' % appstruct.username
                 return appstruct.username
 
         if self.usergroups:
             if isinstance(appstruct, UserGroup):
                 if self.users:
                     return 'usergroup:%s' % appstruct.users_group_name
                 return appstruct.users_group_name
 
         raise colander.Invalid(
             node, '%s is not a valid %s' % (appstruct, ' or '.join(self.scopes)))
 
     def deserialize(self, node, cstruct):
         if cstruct is colander.null:
             return colander.null
 
         user, usergroup = None, None
         if self.users:
             if cstruct.startswith('user:'):
                 user = User.get_by_username(cstruct.split(':')[1])
             else:
                 user = User.get_by_username(cstruct)
 
         if self.usergroups:
             if cstruct.startswith('usergroup:'):
                 usergroup = UserGroup.get_by_group_name(cstruct.split(':')[1])
             else:
                 usergroup = UserGroup.get_by_group_name(cstruct)
 
         if self.users and self.usergroups:
             if user and usergroup:
                 raise colander.Invalid(node, (
                     '%s is both a user and usergroup, specify which '
                     'one was wanted by prepending user: or usergroup: to the '
                     'name') % cstruct)
 
         if self.users and user:
             return user
 
         if self.usergroups and usergroup:
             return usergroup
 
         raise colander.Invalid(
             node, '%s is not a valid %s' % (cstruct, ' or '.join(self.scopes)))
 
 
 class UserType(UserOrUserGroupType):
     scopes = ('user',)
 
 
 class UserGroupType(UserOrUserGroupType):
     scopes = ('usergroup',)

rhodecode/model/validation_schema/validators.py

@@ -1,38 +1,48 b''
 import os
 import re
 
 import ipaddress
 import colander
 
 from rhodecode.translation import _
 from rhodecode.lib.utils2 import glob2re
 
 
 def ip_addr_validator(node, value):
     try:
         # this raises an ValueError if address is not IpV4 or IpV6
         ipaddress.ip_network(value, strict=False)
     except ValueError:
         msg = _(u'Please enter a valid IPv4 or IpV6 address')
         raise colander.Invalid(node, msg)
 
 
 class IpAddrValidator(object):
     def __init__(self, strict=True):
         self.strict = strict
 
     def __call__(self, node, value):
         try:
             # this raises an ValueError if address is not IpV4 or IpV6
             ipaddress.ip_network(value, strict=self.strict)
         except ValueError:
             msg = _(u'Please enter a valid IPv4 or IpV6 address')
             raise colander.Invalid(node, msg)
 
 
 def glob_validator(node, value):
     try:
         re.compile('^' + glob2re(value) + '$')
     except Exception:
         msg = _(u'Invalid glob pattern')
         raise colander.Invalid(node, msg)
+
+
+def valid_name_validator(node, value):
+    from rhodecode.model.validation_schema import types
+    if value is types.RootLocation:
+        return
+
+    msg = _('Name must start with a letter or number. Got `{}`').format(value)
+    if not re.match(r'^[a-zA-z0-9]{1,}', value):
+        raise colander.Invalid(node, msg)

rhodecode/tests/models/schemas/test_integration_schema.py

@@ -1,171 +1,167 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import pytest
 
-from rhodecode.model import validation_schema
-
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.model.validation_schema.schemas.integration_schema import (
     make_integration_schema
 )
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationSchema(object):
 
-    def test_deserialize_integration_schema_perms(self, backend_random,
-                                                  test_repo_group,
-                                                  StubIntegrationType):
+    def test_deserialize_integration_schema_perms(
+            self, backend_random, test_repo_group, StubIntegrationType):
 
         repo = backend_random.repo
         repo_group = test_repo_group
 
-
         empty_perms_dict = {
             'global': [],
             'repositories': {},
             'repositories_groups': {},
         }
 
         perms_tests = [
             (
                 'repo:%s' % repo.repo_name,
                 {
                     'child_repos_only': None,
                     'repo_group': None,
                     'repo': repo,
                 },
                 [
                     ({},  False),
                     ({'global': ['hg.admin']},  True),
                     ({'global': []},  False),
                     ({'repositories': {repo.repo_name: 'repository.admin'}}, True),
                     ({'repositories': {repo.repo_name: 'repository.read'}}, False),
                     ({'repositories': {repo.repo_name: 'repository.write'}}, False),
                     ({'repositories': {repo.repo_name: 'repository.none'}}, False),
                 ]
             ),
             (
                 'repogroup:%s' % repo_group.group_name,
                 {
                     'repo': None,
                     'repo_group': repo_group,
                     'child_repos_only': True,
                 },
                 [
                     ({},  False),
                     ({'global': ['hg.admin']},  True),
                     ({'global': []},  False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.admin'}}, True),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.read'}}, False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.write'}}, False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.none'}}, False),
                 ]
             ),
             (
                 'repogroup-recursive:%s' % repo_group.group_name,
                 {
                     'repo': None,
                     'repo_group': repo_group,
                     'child_repos_only': False,
                 },
                 [
                     ({},  False),
                     ({'global': ['hg.admin']},  True),
                     ({'global': []},  False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.admin'}}, True),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.read'}}, False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.write'}}, False),
                     ({'repositories_groups':
                         {repo_group.group_name: 'group.none'}}, False),
                 ]
             ),
             (
                 'global',
                 {
                     'repo': None,
                     'repo_group': None,
                     'child_repos_only': False,
                 }, [
                     ({},  False),
                     ({'global': ['hg.admin']},  True),
                     ({'global': []},  False),
                 ]
             ),
             (
                 'root-repos',
                 {
                     'repo': None,
                     'repo_group': None,
                     'child_repos_only': True,
                 }, [
                     ({},  False),
                     ({'global': ['hg.admin']},  True),
                     ({'global': []},  False),
                 ]
             ),
         ]
 
         for scope_input, scope_output, perms_allowed in perms_tests:
             for perms_update, allowed in perms_allowed:
                 perms = dict(empty_perms_dict, **perms_update)
 
                 schema = make_integration_schema(
                     IntegrationType=StubIntegrationType
                 ).bind(permissions=perms)
 
                 input_data = {
                     'options': {
                         'enabled': 'true',
                         'scope': scope_input,
                         'name': 'test integration',
                     },
                     'settings': {
                         'test_string_field': 'stringy',
                         'test_int_field': '100',
                     }
                 }
 
                 if not allowed:
                     with pytest.raises(colander.Invalid):
                         schema.deserialize(input_data)
                 else:
                     assert schema.deserialize(input_data) == {
                         'options': {
                             'enabled': True,
                             'scope': scope_output,
                             'name': 'test integration',
                         },
                         'settings': {
                             'test_string_field': 'stringy',
                             'test_int_field': 100,
                         }
                     }
 

rhodecode/tests/models/schemas/test_schema_types.py

@@ -1,46 +1,102 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import pytest
 
-from rhodecode.model.validation_schema.types import GroupNameType
+from rhodecode.model.validation_schema.types import (
+    GroupNameType, RepoNameType, StringBooleanType)
 
 
 class TestGroupNameType(object):
     @pytest.mark.parametrize('given, expected', [
         ('//group1/group2//', 'group1/group2'),
         ('//group1///group2//', 'group1/group2'),
-        ('group1/group2///group3', 'group1/group2/group3')
+        ('group1/group2///group3', 'group1/group2/group3'),
     ])
-    def test_replace_extra_slashes_cleans_up_extra_slashes(
-            self, given, expected):
-        type_ = GroupNameType()
-        result = type_._replace_extra_slashes(given)
+    def test_normalize_path(self, given, expected):
+        result = GroupNameType()._normalize(given)
         assert result == expected
 
-    def test_deserialize_cleans_up_extra_slashes(self):
+    @pytest.mark.parametrize('given, expected', [
+        ('//group1/group2//', 'group1/group2'),
+        ('//group1///group2//', 'group1/group2'),
+        ('group1/group2///group3', 'group1/group2/group3'),
+        ('v1.2', 'v1.2'),
+        ('/v1.2', 'v1.2'),
+        ('.dirs', '.dirs'),
+        ('..dirs', '.dirs'),
+        ('./..dirs', '.dirs'),
+        ('dir/;name;/;[];/sub', 'dir/name/sub'),
+        (',/,/,d,,,', 'd'),
+        ('/;/#/,d,,,', 'd'),
+        ('long../../..name', 'long./.name'),
+        ('long../..name', 'long./.name'),
+        ('../', ''),
+        ('\'../"../', ''),
+        ('c,/,/..//./,c,,,/.d/../.........c', 'c/c/.d/.c'),
+        ('c,/,/..//./,c,,,', 'c/c'),
+        ('d../..d', 'd./.d'),
+        ('d../../d', 'd./d'),
+
+        ('d\;\./\,\./d', 'd./d'),
+        ('d\.\./\.\./d', 'd./d'),
+        ('d\.\./\..\../d', 'd./d'),
+    ])
+    def test_deserialize_clean_up_name(self, given, expected):
         class TestSchema(colander.Schema):
-            field = colander.SchemaNode(GroupNameType())
+            field_group = colander.SchemaNode(GroupNameType())
+            field_repo = colander.SchemaNode(RepoNameType())
 
         schema = TestSchema()
-        cleaned_data = schema.deserialize(
-            {'field': '//group1/group2///group3//'})
-        assert cleaned_data['field'] == 'group1/group2/group3'
+        cleaned_data = schema.deserialize({
+            'field_group': given,
+            'field_repo': given
+        })
+        assert cleaned_data['field_group'] == expected
+        assert cleaned_data['field_repo'] == expected
+
+
+class TestStringBooleanType(object):
+
+    def _get_schema(self):
+        class Schema(colander.MappingSchema):
+            bools = colander.SchemaNode(StringBooleanType())
+        return Schema()
+
+    @pytest.mark.parametrize('given, expected', [
+        ('1', True),
+        ('yEs', True),
+        ('true', True),
+
+        ('0', False),
+        ('NO', False),
+        ('FALSE', False),
+
+    ])
+    def test_convert_type(self, given, expected):
+        schema = self._get_schema()
+        result = schema.deserialize({'bools':given})
+        assert result['bools'] == expected
+
+    def test_try_convert_bad_type(self):
+        schema = self._get_schema()
+        with pytest.raises(colander.Invalid):
+            result = schema.deserialize({'bools': 'boom'})