repositories: ported repo_creating checks to pyramid.

- fixed security issues with resource discovery.
- ported repository creating check into base view for repos.

rhodecode/apps/repository/views/repo_checks.py

@@ -0,0 +1,110 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011-2017 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
+
+from pyramid.view import view_config
+from pyramid.httpexceptions import HTTPFound, HTTPNotFound
+
+from rhodecode.apps._base import BaseAppView
+from rhodecode.lib import helpers as h
+from rhodecode.lib.auth import (NotAnonymous, HasRepoPermissionAny)
+from rhodecode.model.db import Repository
+
+log = logging.getLogger(__name__)
+
+
+class RepoChecksView(BaseAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
+
+    @NotAnonymous()
+    @view_config(
+        route_name='repo_creating', request_method='GET',
+        renderer='rhodecode:templates/admin/repos/repo_creating.mako')
+    def repo_creating(self):
+        c = self.load_default_context()
+
+        repo_name = self.request.matchdict['repo_name']
+        db_repo = Repository.get_by_repo_name(repo_name)
+        if not db_repo:
+            raise HTTPNotFound()
+
+        # check if maybe repo is already created
+        if db_repo.repo_state in [Repository.STATE_CREATED]:
+            # re-check permissions before redirecting to prevent resource
+            # discovery by checking the 302 code
+            perm_set = ['repository.read', 'repository.write', 'repository.admin']
+            has_perm = HasRepoPermissionAny(*perm_set)(
+                db_repo.repo_name, 'Repo Creating check')
+            if not has_perm:
+                raise HTTPNotFound()
+
+            raise HTTPFound(h.route_path(
+                'repo_summary', repo_name=db_repo.repo_name))
+
+        c.task_id = self.request.GET.get('task_id')
+        c.repo_name = repo_name
+
+        return self._get_template_context(c)
+
+    @NotAnonymous()
+    @view_config(
+        route_name='repo_creating_check', request_method='GET',
+        renderer='json_ext')
+    def repo_creating_check(self):
+        _ = self.request.translate
+        task_id = self.request.GET.get('task_id')
+        self.load_default_context()
+
+        repo_name = self.request.matchdict['repo_name']
+
+        if task_id and task_id not in ['None']:
+            import rhodecode
+            from celery.result import AsyncResult
+            if rhodecode.CELERY_ENABLED:
+                task = AsyncResult(task_id)
+                if task.failed():
+                    msg = self._log_creation_exception(task.result, repo_name)
+                    h.flash(msg, category='error')
+                    raise HTTPFound(h.route_path('home'), code=501)
+
+        db_repo = Repository.get_by_repo_name(repo_name)
+        if db_repo and db_repo.repo_state == Repository.STATE_CREATED:
+            if db_repo.clone_uri:
+                clone_uri = db_repo.clone_uri_hidden
+                h.flash(_('Created repository %s from %s')
+                        % (db_repo.repo_name, clone_uri), category='success')
+            else:
+                repo_url = h.link_to(
+                    db_repo.repo_name,
+                    h.route_path('repo_summary', repo_name=db_repo.repo_name))
+                fork = db_repo.fork
+                if fork:
+                    fork_name = fork.repo_name
+                    h.flash(h.literal(_('Forked repository %s as %s')
+                                      % (fork_name, repo_url)), category='success')
+                else:
+                    h.flash(h.literal(_('Created repository %s') % repo_url),
+                            category='success')
+            return {'result': True}
+        return {'result': False}

rhodecode/apps/_base/__init__.py

@@ -1,446 +1,454 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017 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 time
 import logging
 
 from pyramid.httpexceptions import HTTPFound
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import StrictAttributeDict, safe_int, datetime_to_time
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model import repo
 from rhodecode.model import repo_group
 from rhodecode.model.db import User
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 
 ADMIN_PREFIX = '/_admin'
 STATIC_FILE_PREFIX = '/_static'
 
 URL_NAME_REQUIREMENTS = {
     # group name can have a slash in them, but they must not end with a slash
     'group_name': r'.*?[^/]',
     'repo_group_name': r'.*?[^/]',
     # repo names can have a slash in them, but they must not end with a slash
     'repo_name': r'.*?[^/]',
     # file path eats up everything at the end
     'f_path': r'.*',
     # reference types
     'source_ref_type': '(branch|book|tag|rev|\%\(source_ref_type\)s)',
     'target_ref_type': '(branch|book|tag|rev|\%\(target_ref_type\)s)',
 }
 
 
 def add_route_with_slash(config,name, pattern, **kw):
     config.add_route(name, pattern, **kw)
     if not pattern.endswith('/'):
         config.add_route(name + '_slash', pattern + '/', **kw)
 
 
 def add_route_requirements(route_path, requirements=URL_NAME_REQUIREMENTS):
     """
     Adds regex requirements to pyramid routes using a mapping dict
     e.g::
         add_route_requirements('{repo_name}/settings')
     """
     for key, regex in requirements.items():
         route_path = route_path.replace('{%s}' % key, '{%s:%s}' % (key, regex))
     return route_path
 
 
 def get_format_ref_id(repo):
     """Returns a `repo` specific reference formatter function"""
     if h.is_svn(repo):
         return _format_ref_id_svn
     else:
         return _format_ref_id
 
 
 def _format_ref_id(name, raw_id):
     """Default formatting of a given reference `name`"""
     return name
 
 
 def _format_ref_id_svn(name, raw_id):
     """Special way of formatting a reference for Subversion including path"""
     return '%s@%s' % (name, raw_id)
 
 
 class TemplateArgs(StrictAttributeDict):
     pass
 
 
 class BaseAppView(object):
 
     def __init__(self, context, request):
         self.request = request
         self.context = context
         self.session = request.session
         self._rhodecode_user = request.user  # auth user
         self._rhodecode_db_user = self._rhodecode_user.get_instance()
         self._maybe_needs_password_change(
             request.matched_route.name, self._rhodecode_db_user)
 
     def _maybe_needs_password_change(self, view_name, user_obj):
         log.debug('Checking if user %s needs password change on view %s',
                   user_obj, view_name)
         skip_user_views = [
             'logout', 'login',
             'my_account_password', 'my_account_password_update'
         ]
 
         if not user_obj:
             return
 
         if user_obj.username == User.DEFAULT_USER:
             return
 
         now = time.time()
         should_change = user_obj.user_data.get('force_password_change')
         change_after = safe_int(should_change) or 0
         if should_change and now > change_after:
             log.debug('User %s requires password change', user_obj)
             h.flash('You are required to change your password', 'warning',
                     ignore_duplicate=True)
 
             if view_name not in skip_user_views:
                 raise HTTPFound(
                     self.request.route_path('my_account_password'))
 
     def _log_creation_exception(self, e, repo_name):
         _ = self.request.translate
         reason = None
         if len(e.args) == 2:
             reason = e.args[1]
 
         if reason == 'INVALID_CERTIFICATE':
             log.exception(
                 'Exception creating a repository: invalid certificate')
             msg = (_('Error creating repository %s: invalid certificate')
                    % repo_name)
         else:
             log.exception("Exception creating a repository")
             msg = (_('Error creating repository %s')
                    % repo_name)
         return msg
 
     def _get_local_tmpl_context(self, include_app_defaults=False):
         c = TemplateArgs()
         c.auth_user = self.request.user
         # TODO(marcink): migrate the usage of c.rhodecode_user to c.auth_user
         c.rhodecode_user = self.request.user
 
         if include_app_defaults:
             # NOTE(marcink): after full pyramid migration include_app_defaults
             # should be turned on by default
             from rhodecode.lib.base import attach_context_attributes
             attach_context_attributes(c, self.request, self.request.user.user_id)
 
         return c
 
     def _register_global_c(self, tmpl_args):
         """
         Registers attributes to pylons global `c`
         """
 
         # TODO(marcink): remove once pyramid migration is finished
         from pylons import tmpl_context as c
         try:
             for k, v in tmpl_args.items():
                 setattr(c, k, v)
         except TypeError:
             log.exception('Failed to register pylons C')
             pass
 
     def _get_template_context(self, tmpl_args):
         self._register_global_c(tmpl_args)
 
         local_tmpl_args = {
             'defaults': {},
             'errors': {},
             # register a fake 'c' to be used in templates instead of global
             # pylons c, after migration to pyramid we should rename it to 'c'
             # make sure we replace usage of _c in templates too
             '_c': tmpl_args
         }
         local_tmpl_args.update(tmpl_args)
         return local_tmpl_args
 
     def load_default_context(self):
         """
         example:
 
         def load_default_context(self):
             c = self._get_local_tmpl_context()
             c.custom_var = 'foobar'
             self._register_global_c(c)
             return c
         """
         raise NotImplementedError('Needs implementation in view class')
 
 
 class RepoAppView(BaseAppView):
 
     def __init__(self, context, request):
         super(RepoAppView, self).__init__(context, request)
         self.db_repo = request.db_repo
         self.db_repo_name = self.db_repo.repo_name
         self.db_repo_pull_requests = ScmModel().get_pull_requests(self.db_repo)
 
     def _handle_missing_requirements(self, error):
         log.error(
             'Requirements are missing for repository %s: %s',
             self.db_repo_name, error.message)
 
     def _get_local_tmpl_context(self, include_app_defaults=False):
         _ = self.request.translate
         c = super(RepoAppView, self)._get_local_tmpl_context(
             include_app_defaults=include_app_defaults)
 
         # register common vars for this type of view
         c.rhodecode_db_repo = self.db_repo
         c.repo_name = self.db_repo_name
         c.repository_pull_requests = self.db_repo_pull_requests
 
         c.repository_requirements_missing = False
         try:
             self.rhodecode_vcs_repo = self.db_repo.scm_instance()
         except RepositoryRequirementError as e:
             c.repository_requirements_missing = True
             self._handle_missing_requirements(e)
             self.rhodecode_vcs_repo = None
 
         if (not c.repository_requirements_missing
             and self.rhodecode_vcs_repo is None):
             # unable to fetch this repo as vcs instance, report back to user
             h.flash(_(
                 "The repository `%(repo_name)s` cannot be loaded in filesystem. "
                 "Please check if it exist, or is not damaged.") %
                     {'repo_name': c.repo_name},
                     category='error', ignore_duplicate=True)
             raise HTTPFound(h.route_path('home'))
 
         return c
 
     def _get_f_path(self, matchdict, default=None):
         f_path = matchdict.get('f_path')
         if f_path:
             # fix for multiple initial slashes that causes errors for GIT
             return f_path.lstrip('/')
 
         return default
 
 
 class DataGridAppView(object):
     """
     Common class to have re-usable grid rendering components
     """
 
     def _extract_ordering(self, request, column_map=None):
         column_map = column_map or {}
         column_index = safe_int(request.GET.get('order[0][column]'))
         order_dir = request.GET.get(
             'order[0][dir]', 'desc')
         order_by = request.GET.get(
             'columns[%s][data][sort]' % column_index, 'name_raw')
 
         # translate datatable to DB columns
         order_by = column_map.get(order_by) or order_by
 
         search_q = request.GET.get('search[value]')
         return search_q, order_by, order_dir
 
     def _extract_chunk(self, request):
         start = safe_int(request.GET.get('start'), 0)
         length = safe_int(request.GET.get('length'), 25)
         draw = safe_int(request.GET.get('draw'))
         return draw, start, length
 
 
 class BaseReferencesView(RepoAppView):
     """
     Base for reference view for branches, tags and bookmarks.
     """
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         # TODO(marcink): remove repo_info and use c.rhodecode_db_repo instead
         c.repo_info = self.db_repo
 
         self._register_global_c(c)
         return c
 
     def load_refs_context(self, ref_items, partials_template):
         _render = self.request.get_partial_renderer(partials_template)
         pre_load = ["author", "date", "message"]
 
         is_svn = h.is_svn(self.rhodecode_vcs_repo)
         is_hg = h.is_hg(self.rhodecode_vcs_repo)
 
         format_ref_id = get_format_ref_id(self.rhodecode_vcs_repo)
 
         closed_refs = {}
         if is_hg:
             closed_refs = self.rhodecode_vcs_repo.branches_closed
 
         data = []
         for ref_name, commit_id in ref_items:
             commit = self.rhodecode_vcs_repo.get_commit(
                 commit_id=commit_id, pre_load=pre_load)
             closed = ref_name in closed_refs
 
             # TODO: johbo: Unify generation of reference links
             use_commit_id = '/' in ref_name or is_svn
 
             if use_commit_id:
                 files_url = h.route_path(
                     'repo_files',
                     repo_name=self.db_repo_name,
                     f_path=ref_name if is_svn else '',
                     commit_id=commit_id)
 
             else:
                 files_url = h.route_path(
                     'repo_files',
                     repo_name=self.db_repo_name,
                     f_path=ref_name if is_svn else '',
                     commit_id=ref_name,
                     _query=dict(at=ref_name))
 
             data.append({
                 "name": _render('name', ref_name, files_url, closed),
                 "name_raw": ref_name,
                 "date": _render('date', commit.date),
                 "date_raw": datetime_to_time(commit.date),
                 "author": _render('author', commit.author),
                 "commit": _render(
                     'commit', commit.message, commit.raw_id, commit.idx),
                 "commit_raw": commit.idx,
                 "compare": _render(
                     'compare', format_ref_id(ref_name, commit.raw_id)),
             })
 
         return data
 
 
 class RepoRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'repo_route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
 
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         repo_name = info['match']['repo_name']
         repo_model = repo.RepoModel()
         by_name_match = repo_model.get_by_repo_name(repo_name, cache=True)
 
+        def redirect_if_creating(db_repo):
+            if db_repo.repo_state in [repo.Repository.STATE_PENDING]:
+                raise HTTPFound(
+                    request.route_path('repo_creating',
+                                       repo_name=db_repo.repo_name))
+
         if by_name_match:
             # register this as request object we can re-use later
             request.db_repo = by_name_match
+            redirect_if_creating(by_name_match)
             return True
 
         by_id_match = repo_model.get_repo_by_id(repo_name)
         if by_id_match:
             request.db_repo = by_id_match
+            redirect_if_creating(by_id_match)
             return True
 
         return False
 
 
 class RepoTypeRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val or ['hg', 'git', 'svn']
 
     def text(self):
         return 'repo_accepted_type = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         rhodecode_db_repo = request.db_repo
 
         log.debug(
             '%s checking repo type for %s in %s',
             self.__class__.__name__, rhodecode_db_repo.repo_type, self.val)
 
         if rhodecode_db_repo.repo_type in self.val:
             return True
         else:
             log.warning('Current view is not supported for repo type:%s',
                         rhodecode_db_repo.repo_type)
             #
             # h.flash(h.literal(
             #     _('Action not supported for %s.' % rhodecode_repo.alias)),
             #     category='warning')
             # return redirect(
             #     route_path('repo_summary', repo_name=cls.rhodecode_db_repo.repo_name))
 
             return False
 
 
 class RepoGroupRoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'repo_group_route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if hasattr(request, 'vcs_call'):
             # skip vcs calls
             return
 
         repo_group_name = info['match']['repo_group_name']
         repo_group_model = repo_group.RepoGroupModel()
         by_name_match = repo_group_model.get_by_group_name(
             repo_group_name, cache=True)
 
         if by_name_match:
             # register this as request object we can re-use later
             request.db_repo_group = by_name_match
             return True
 
         return False
 
 
 def includeme(config):
     config.add_route_predicate(
         'repo_route', RepoRoutePredicate)
     config.add_route_predicate(
         'repo_accepted_types', RepoTypeRoutePredicate)
     config.add_route_predicate(
         'repo_group_route', RepoGroupRoutePredicate)

rhodecode/apps/repository/__init__.py

@@ -1,357 +1,366 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017 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/
 from rhodecode.apps._base import add_route_with_slash
 
 
 def includeme(config):
 
+    # repo creating checks, special cases that aren't repo routes
+    config.add_route(
+        name='repo_creating',
+        pattern='/{repo_name:.*?[^/]}/repo_creating')
+
+    config.add_route(
+        name='repo_creating_check',
+        pattern='/{repo_name:.*?[^/]}/repo_creating_check')
+
     # Summary
     # NOTE(marcink): one additional route is defined in very bottom, catch
     # all pattern
     config.add_route(
         name='repo_summary_explicit',
         pattern='/{repo_name:.*?[^/]}/summary', repo_route=True)
     config.add_route(
         name='repo_summary_commits',
         pattern='/{repo_name:.*?[^/]}/summary-commits', repo_route=True)
 
     # Commits
     config.add_route(
         name='repo_commit',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_children',
         pattern='/{repo_name:.*?[^/]}/changeset_children/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_parents',
         pattern='/{repo_name:.*?[^/]}/changeset_parents/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_raw',
         pattern='/{repo_name:.*?[^/]}/changeset-diff/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_patch',
         pattern='/{repo_name:.*?[^/]}/changeset-patch/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_download',
         pattern='/{repo_name:.*?[^/]}/changeset-download/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_data',
         pattern='/{repo_name:.*?[^/]}/changeset-data/{commit_id}', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_create',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/create', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_preview',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/preview', repo_route=True)
 
     config.add_route(
         name='repo_commit_comment_delete',
         pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/{comment_id}/delete', repo_route=True)
 
     # still working url for backward compat.
     config.add_route(
         name='repo_commit_raw_deprecated',
         pattern='/{repo_name:.*?[^/]}/raw-changeset/{commit_id}', repo_route=True)
 
     # Files
     config.add_route(
         name='repo_archivefile',
         pattern='/{repo_name:.*?[^/]}/archive/{fname}', repo_route=True)
 
     config.add_route(
         name='repo_files_diff',
         pattern='/{repo_name:.*?[^/]}/diff/{f_path:.*}', repo_route=True)
     config.add_route(  # legacy route to make old links work
         name='repo_files_diff_2way_redirect',
         pattern='/{repo_name:.*?[^/]}/diff-2way/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files',
         pattern='/{repo_name:.*?[^/]}/files/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_files:default_path',
         pattern='/{repo_name:.*?[^/]}/files/{commit_id}/', repo_route=True)
     config.add_route(
         name='repo_files:default_commit',
         pattern='/{repo_name:.*?[^/]}/files', repo_route=True)
 
     config.add_route(
         name='repo_files:rendered',
         pattern='/{repo_name:.*?[^/]}/render/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files:annotated',
         pattern='/{repo_name:.*?[^/]}/annotate/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_files:annotated_previous',
         pattern='/{repo_name:.*?[^/]}/annotate-previous/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_nodetree_full',
         pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_nodetree_full:default_path',
         pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/', repo_route=True)
 
     config.add_route(
         name='repo_files_nodelist',
         pattern='/{repo_name:.*?[^/]}/nodelist/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_raw',
         pattern='/{repo_name:.*?[^/]}/raw/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_download',
         pattern='/{repo_name:.*?[^/]}/download/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(  # backward compat to keep old links working
         name='repo_file_download:legacy',
         pattern='/{repo_name:.*?[^/]}/rawfile/{commit_id}/{f_path:.*}',
         repo_route=True)
 
     config.add_route(
         name='repo_file_history',
         pattern='/{repo_name:.*?[^/]}/history/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_file_authors',
         pattern='/{repo_name:.*?[^/]}/authors/{commit_id}/{f_path:.*}', repo_route=True)
 
     config.add_route(
         name='repo_files_remove_file',
         pattern='/{repo_name:.*?[^/]}/remove_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_delete_file',
         pattern='/{repo_name:.*?[^/]}/delete_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_edit_file',
         pattern='/{repo_name:.*?[^/]}/edit_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_update_file',
         pattern='/{repo_name:.*?[^/]}/update_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_add_file',
         pattern='/{repo_name:.*?[^/]}/add_file/{commit_id}/{f_path:.*}',
         repo_route=True)
     config.add_route(
         name='repo_files_create_file',
         pattern='/{repo_name:.*?[^/]}/create_file/{commit_id}/{f_path:.*}',
         repo_route=True)
 
     # Refs data
     config.add_route(
         name='repo_refs_data',
         pattern='/{repo_name:.*?[^/]}/refs-data', repo_route=True)
 
     config.add_route(
         name='repo_refs_changelog_data',
         pattern='/{repo_name:.*?[^/]}/refs-data-changelog', repo_route=True)
 
     config.add_route(
         name='repo_stats',
         pattern='/{repo_name:.*?[^/]}/repo_stats/{commit_id}', repo_route=True)
 
     # Changelog
     config.add_route(
         name='repo_changelog',
         pattern='/{repo_name:.*?[^/]}/changelog', repo_route=True)
     config.add_route(
         name='repo_changelog_file',
         pattern='/{repo_name:.*?[^/]}/changelog/{commit_id}/{f_path:.*}', repo_route=True)
     config.add_route(
         name='repo_changelog_elements',
         pattern='/{repo_name:.*?[^/]}/changelog_elements', repo_route=True)
 
     # Compare
     config.add_route(
         name='repo_compare_select',
         pattern='/{repo_name:.*?[^/]}/compare', repo_route=True)
 
     config.add_route(
         name='repo_compare',
         pattern='/{repo_name:.*?[^/]}/compare/{source_ref_type}@{source_ref:.*?}...{target_ref_type}@{target_ref:.*?}', repo_route=True)
 
     # Tags
     config.add_route(
         name='tags_home',
         pattern='/{repo_name:.*?[^/]}/tags', repo_route=True)
 
     # Branches
     config.add_route(
         name='branches_home',
         pattern='/{repo_name:.*?[^/]}/branches', repo_route=True)
 
     config.add_route(
         name='bookmarks_home',
         pattern='/{repo_name:.*?[^/]}/bookmarks', repo_route=True)
 
     # Pull Requests
     config.add_route(
         name='pullrequest_show',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_show_all',
         pattern='/{repo_name:.*?[^/]}/pull-request',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_show_all_data',
         pattern='/{repo_name:.*?[^/]}/pull-request-data',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_repo_refs',
         pattern='/{repo_name:.*?[^/]}/pull-request/refs/{target_repo_name:.*?[^/]}',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_repo_destinations',
         pattern='/{repo_name:.*?[^/]}/pull-request/repo-destinations',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_new',
         pattern='/{repo_name:.*?[^/]}/pull-request/new',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_create',
         pattern='/{repo_name:.*?[^/]}/pull-request/create',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     config.add_route(
         name='pullrequest_update',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/update',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_merge',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/merge',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_delete',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/delete',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_comment_create',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment',
         repo_route=True)
 
     config.add_route(
         name='pullrequest_comment_delete',
         pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment/{comment_id}/delete',
         repo_route=True, repo_accepted_types=['hg', 'git'])
 
     # Settings
     config.add_route(
         name='edit_repo',
         pattern='/{repo_name:.*?[^/]}/settings', repo_route=True)
 
     # Settings advanced
     config.add_route(
         name='edit_repo_advanced',
         pattern='/{repo_name:.*?[^/]}/settings/advanced', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_delete',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/delete', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_locking',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/locking', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_journal',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/journal', repo_route=True)
     config.add_route(
         name='edit_repo_advanced_fork',
         pattern='/{repo_name:.*?[^/]}/settings/advanced/fork', repo_route=True)
 
     # Caches
     config.add_route(
         name='edit_repo_caches',
         pattern='/{repo_name:.*?[^/]}/settings/caches', repo_route=True)
 
     # Permissions
     config.add_route(
         name='edit_repo_perms',
         pattern='/{repo_name:.*?[^/]}/settings/permissions', repo_route=True)
 
     # Repo Review Rules
     config.add_route(
         name='repo_reviewers',
         pattern='/{repo_name:.*?[^/]}/settings/review/rules', repo_route=True)
 
     config.add_route(
         name='repo_default_reviewers_data',
         pattern='/{repo_name:.*?[^/]}/settings/review/default-reviewers', repo_route=True)
 
     # Maintenance
     config.add_route(
         name='repo_maintenance',
         pattern='/{repo_name:.*?[^/]}/settings/maintenance', repo_route=True)
 
     config.add_route(
         name='repo_maintenance_execute',
         pattern='/{repo_name:.*?[^/]}/settings/maintenance/execute', repo_route=True)
 
     # Strip
     config.add_route(
         name='strip',
         pattern='/{repo_name:.*?[^/]}/settings/strip', repo_route=True)
 
     config.add_route(
         name='strip_check',
         pattern='/{repo_name:.*?[^/]}/settings/strip_check', repo_route=True)
 
     config.add_route(
         name='strip_execute',
         pattern='/{repo_name:.*?[^/]}/settings/strip_execute', repo_route=True)
 
     # ATOM/RSS Feed
     config.add_route(
         name='rss_feed_home',
         pattern='/{repo_name:.*?[^/]}/feed/rss', repo_route=True)
 
     config.add_route(
         name='atom_feed_home',
         pattern='/{repo_name:.*?[^/]}/feed/atom', repo_route=True)
 
     # NOTE(marcink): needs to be at the end for catch-all
     add_route_with_slash(
         config,
         name='repo_summary',
         pattern='/{repo_name:.*?[^/]}', repo_route=True)
 
     # Scan module for configuration decorators.
     config.scan()

rhodecode/apps/repository/tests/test_repo_summary.py

@@ -1,523 +1,523 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 mock
 import pytest
 
 from rhodecode.apps.repository.views.repo_summary import RepoSummaryView
 from rhodecode.lib import helpers as h
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.utils2 import AttributeDict, safe_str
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
 
 
 fixture = Fixture()
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'repo_stats': '/{repo_name}/repo_stats/{commit_id}',
         'repo_refs_data': '/{repo_name}/refs-data',
-        'repo_refs_changelog_data': '/{repo_name}/refs-data-changelog'
-
+        'repo_refs_changelog_data': '/{repo_name}/refs-data-changelog',
+        'repo_creating_check': '/{repo_name}/repo_creating_check',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures('app')
 class TestSummaryView(object):
     def test_index(self, autologin_user, backend, http_host_only_stub):
         repo_id = backend.repo.repo_id
         repo_name = backend.repo_name
         with mock.patch('rhodecode.lib.helpers.is_svn_without_proxy',
                         return_value=False):
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name))
 
         # repo type
         response.mustcontain(
             '<i class="icon-%s">' % (backend.alias, )
         )
         # public/private
         response.mustcontain(
             """<i class="icon-unlock-alt">"""
         )
 
         # clone url...
         response.mustcontain(
             'id="clone_url" readonly="readonly"'
             ' value="http://test_admin@%s/%s"' % (http_host_only_stub, repo_name, ))
         response.mustcontain(
             'id="clone_url_id" readonly="readonly"'
             ' value="http://test_admin@%s/_%s"' % (http_host_only_stub, repo_id, ))
 
     def test_index_svn_without_proxy(
             self, autologin_user, backend_svn, http_host_only_stub):
         repo_id = backend_svn.repo.repo_id
         repo_name = backend_svn.repo_name
         response = self.app.get(route_path('repo_summary', repo_name=repo_name))
         # clone url...
         response.mustcontain(
             'id="clone_url" disabled'
             ' value="http://test_admin@%s/%s"' % (http_host_only_stub, repo_name, ))
         response.mustcontain(
             'id="clone_url_id" disabled'
             ' value="http://test_admin@%s/_%s"' % (http_host_only_stub, repo_id, ))
 
     def test_index_with_trailing_slash(
             self, autologin_user, backend, http_host_only_stub):
 
         repo_id = backend.repo.repo_id
         repo_name = backend.repo_name
         with mock.patch('rhodecode.lib.helpers.is_svn_without_proxy',
                         return_value=False):
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name) + '/',
                 status=200)
 
         # clone url...
         response.mustcontain(
             'id="clone_url" readonly="readonly"'
             ' value="http://test_admin@%s/%s"' % (http_host_only_stub, repo_name, ))
         response.mustcontain(
             'id="clone_url_id" readonly="readonly"'
             ' value="http://test_admin@%s/_%s"' % (http_host_only_stub, repo_id, ))
 
     def test_index_by_id(self, autologin_user, backend):
         repo_id = backend.repo.repo_id
         response = self.app.get(
             route_path('repo_summary', repo_name='_%s' % (repo_id,)))
 
         # repo type
         response.mustcontain(
             '<i class="icon-%s">' % (backend.alias, )
         )
         # public/private
         response.mustcontain(
             """<i class="icon-unlock-alt">"""
         )
 
     def test_index_by_repo_having_id_path_in_name_hg(self, autologin_user):
         fixture.create_repo(name='repo_1')
         response = self.app.get(route_path('repo_summary', repo_name='repo_1'))
 
         try:
             response.mustcontain("repo_1")
         finally:
             RepoModel().delete(Repository.get_by_repo_name('repo_1'))
             Session().commit()
 
     def test_index_with_anonymous_access_disabled(
             self, backend, disable_anonymous_user):
         response = self.app.get(
             route_path('repo_summary', repo_name=backend.repo_name), status=302)
         assert 'login' in response.location
 
     def _enable_stats(self, repo):
         r = Repository.get_by_repo_name(repo)
         r.enable_statistics = True
         Session().add(r)
         Session().commit()
 
     expected_trending = {
         'hg': {
             "py": {"count": 68, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "css": {"count": 2, "desc": ["Css"]},
             "sh": {"count": 2, "desc": ["Bash"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "html": {"count": 1, "desc": ["EvoqueHtml", "Html"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]}
         },
         'git': {
             "py": {"count": 68, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "css": {"count": 2, "desc": ["Css"]},
             "sh": {"count": 2, "desc": ["Bash"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "html": {"count": 1, "desc": ["EvoqueHtml", "Html"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]}
         },
         'svn': {
             "py": {"count": 75, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "html": {"count": 11, "desc": ["EvoqueHtml", "Html"]},
             "css": {"count": 2, "desc": ["Css"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]},
             "sh": {"count": 1, "desc": ["Bash"]}
         },
     }
 
     def test_repo_stats(self, autologin_user, backend, xhr_header):
         response = self.app.get(
             route_path(
                 'repo_stats', repo_name=backend.repo_name, commit_id='tip'),
             extra_environ=xhr_header,
             status=200)
         assert re.match(r'6[\d\.]+ KiB', response.json['size'])
 
     def test_repo_stats_code_stats_enabled(self, autologin_user, backend, xhr_header):
         repo_name = backend.repo_name
 
         # codes stats
         self._enable_stats(repo_name)
         ScmModel().mark_for_invalidation(repo_name)
 
         response = self.app.get(
             route_path(
                 'repo_stats', repo_name=backend.repo_name, commit_id='tip'),
             extra_environ=xhr_header,
             status=200)
 
         expected_data = self.expected_trending[backend.alias]
         returned_stats = response.json['code_stats']
         for k, v in expected_data.items():
             assert v == returned_stats[k]
 
     def test_repo_refs_data(self, backend):
         response = self.app.get(
             route_path('repo_refs_data', repo_name=backend.repo_name),
             status=200)
 
         # Ensure that there is the correct amount of items in the result
         repo = backend.repo.scm_instance()
         data = response.json['results']
         items = sum(len(section['children']) for section in data)
         repo_refs = len(repo.branches) + len(repo.tags) + len(repo.bookmarks)
         assert items == repo_refs
 
     def test_index_shows_missing_requirements_message(
             self, backend, autologin_user):
         repo_name = backend.repo_name
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
 
         with scm_patcher:
             response = self.app.get(route_path('repo_summary', repo_name=repo_name))
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.main .alert-warning strong', 'Missing requirements')
         assert_response.element_contains(
             '.main .alert-warning',
             'Commits cannot be displayed, because this repository '
             'uses one or more extensions, which was not enabled.')
 
     def test_missing_requirements_page_does_not_contains_switch_to(
             self, autologin_user, backend):
         repo_name = backend.repo_name
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
 
         with scm_patcher:
             response = self.app.get(route_path('repo_summary', repo_name=repo_name))
         response.mustcontain(no='Switch To')
 
 
 @pytest.mark.usefixtures('app')
 class TestRepoLocation(object):
 
     @pytest.mark.parametrize("suffix", [u'', u'ąęł'], ids=['', 'non-ascii'])
     def test_missing_filesystem_repo(
             self, autologin_user, backend, suffix, csrf_token):
         repo = backend.create_repo(name_suffix=suffix)
         repo_name = repo.repo_name
 
         # delete from file system
         RepoModel()._delete_filesystem_repo(repo)
 
         # test if the repo is still in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
         assert new_repo.repo_name == repo_name
 
         # check if repo is not in the filesystem
         assert not repo_on_filesystem(repo_name)
 
         response = self.app.get(
             route_path('repo_summary', repo_name=safe_str(repo_name)), status=302)
 
         msg = 'The repository `%s` cannot be loaded in filesystem. ' \
               'Please check if it exist, or is not damaged.' % repo_name
         assert_session_flash(response, msg)
 
     @pytest.mark.parametrize("suffix", [u'', u'ąęł'], ids=['', 'non-ascii'])
     def test_missing_filesystem_repo_on_repo_check(
             self, autologin_user, backend, suffix, csrf_token):
         repo = backend.create_repo(name_suffix=suffix)
         repo_name = repo.repo_name
 
         # delete from file system
         RepoModel()._delete_filesystem_repo(repo)
 
         # test if the repo is still in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
         assert new_repo.repo_name == repo_name
 
         # check if repo is not in the filesystem
         assert not repo_on_filesystem(repo_name)
 
         # flush the session
         self.app.get(
             route_path('repo_summary', repo_name=safe_str(repo_name)),
             status=302)
 
         response = self.app.get(
             route_path('repo_creating_check', repo_name=safe_str(repo_name)),
             status=200)
         msg = 'The repository `%s` cannot be loaded in filesystem. ' \
               'Please check if it exist, or is not damaged.' % repo_name
         assert_session_flash(response, msg )
 
 
 @pytest.fixture()
 def summary_view(context_stub, request_stub, user_util):
     """
     Bootstrap view to test the view functions
     """
     request_stub.matched_route = AttributeDict(name='test_view')
 
     request_stub.user = user_util.create_user().AuthUser
     request_stub.db_repo = user_util.create_repo()
 
     view = RepoSummaryView(context=context_stub, request=request_stub)
     return view
 
 
 @pytest.mark.usefixtures('app')
 class TestCreateReferenceData(object):
 
     @pytest.fixture
     def example_refs(self):
         section_1_refs = OrderedDict((('a', 'a_id'), ('b', 'b_id')))
         example_refs = [
             ('section_1', section_1_refs, 't1'),
             ('section_2', {'c': 'c_id'}, 't2'),
         ]
         return example_refs
 
     def test_generates_refs_based_on_commit_ids(self, example_refs, summary_view):
         repo = mock.Mock()
         repo.name = 'test-repo'
         repo.alias = 'git'
         full_repo_name = 'pytest-repo-group/' + repo.name
 
         result = summary_view._create_reference_data(
             repo, full_repo_name, example_refs)
 
         expected_files_url = '/{}/files/'.format(full_repo_name)
         expected_result = [
             {
                 'children': [
                     {
                         'id': 'a', 'raw_id': 'a_id', 'text': 'a', 'type': 't1',
                         'files_url': expected_files_url + 'a/?at=a',
                     },
                     {
                         'id': 'b', 'raw_id': 'b_id', 'text': 'b', 'type': 't1',
                         'files_url': expected_files_url + 'b/?at=b',
                     }
                 ],
                 'text': 'section_1'
             },
             {
                 'children': [
                     {
                         'id': 'c', 'raw_id': 'c_id', 'text': 'c', 'type': 't2',
                         'files_url': expected_files_url + 'c/?at=c',
                     }
                 ],
                 'text': 'section_2'
             }]
         assert result == expected_result
 
     def test_generates_refs_with_path_for_svn(self, example_refs, summary_view):
         repo = mock.Mock()
         repo.name = 'test-repo'
         repo.alias = 'svn'
         full_repo_name = 'pytest-repo-group/' + repo.name
 
         result = summary_view._create_reference_data(
             repo, full_repo_name, example_refs)
 
         expected_files_url = '/{}/files/'.format(full_repo_name)
         expected_result = [
             {
                 'children': [
                     {
                         'id': 'a@a_id', 'raw_id': 'a_id',
                         'text': 'a', 'type': 't1',
                         'files_url': expected_files_url + 'a_id/a?at=a',
                     },
                     {
                         'id': 'b@b_id', 'raw_id': 'b_id',
                         'text': 'b', 'type': 't1',
                         'files_url': expected_files_url + 'b_id/b?at=b',
                     }
                 ],
                 'text': 'section_1'
             },
             {
                 'children': [
                     {
                         'id': 'c@c_id', 'raw_id': 'c_id',
                         'text': 'c', 'type': 't2',
                         'files_url': expected_files_url + 'c_id/c?at=c',
                     }
                 ],
                 'text': 'section_2'
             }
         ]
         assert result == expected_result
 
 
 class TestCreateFilesUrl(object):
 
     def test_creates_non_svn_url(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1'
         raw_id = 'deadbeef0123456789'
         is_svn = False
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, commit_id=ref_name,
             f_path='', _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
     def test_creates_svn_url(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1'
         raw_id = 'deadbeef0123456789'
         is_svn = True
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, f_path=ref_name,
             commit_id=raw_id, _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
     def test_name_has_slashes(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1/branch2'
         raw_id = 'deadbeef0123456789'
         is_svn = False
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, commit_id=raw_id,
             f_path='', _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
 
 class TestReferenceItems(object):
     repo = mock.Mock()
     repo.name = 'pytest-repo'
     repo_full_name = 'pytest-repo-group/' + repo.name
     ref_type = 'branch'
     fake_url = '/abcde/'
 
     @staticmethod
     def _format_function(name, id_):
         return 'format_function_{}_{}'.format(name, id_)
 
     def test_creates_required_amount_of_items(self, summary_view):
         amount = 100
         refs = {
             'ref{}'.format(i): '{0:040d}'.format(i)
             for i in range(amount)
         }
 
         url_patcher = mock.patch.object(summary_view, '_create_files_url')
         svn_patcher = mock.patch('rhodecode.lib.helpers.is_svn',
                                  return_value=False)
 
         with url_patcher as url_mock, svn_patcher:
             result = summary_view._create_reference_items(
                 self.repo, self.repo_full_name, refs, self.ref_type,
                 self._format_function)
         assert len(result) == amount
         assert url_mock.call_count == amount
 
     def test_single_item_details(self, summary_view):
         ref_name = 'ref1'
         ref_id = 'deadbeef'
         refs = {
             ref_name: ref_id
         }
 
         svn_patcher = mock.patch('rhodecode.lib.helpers.is_svn',
                                  return_value=False)
 
         url_patcher = mock.patch.object(
             summary_view, '_create_files_url', return_value=self.fake_url)
 
         with url_patcher as url_mock, svn_patcher:
             result = summary_view._create_reference_items(
                 self.repo, self.repo_full_name, refs, self.ref_type,
                 self._format_function)
 
         url_mock.assert_called_once_with(
             self.repo, self.repo_full_name, ref_name, ref_id, False)
         expected_result = [
             {
                 'text': ref_name,
                 'id': self._format_function(ref_name, ref_id),
                 'raw_id': ref_id,
                 'type': self.ref_type,
                 'files_url': self.fake_url
             }
         ]
         assert result == expected_result

rhodecode/config/routing.py

@@ -1,515 +1,508 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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/
 
 """
 Routes configuration
 
 The more specific and detailed routes should be defined first so they
 may take precedent over the more generic routes. For more information
 refer to the routes manual at http://routes.groovie.org/docs/
 
 IMPORTANT: if you change any routing here, make sure to take a look at lib/base.py
 and _route_name variable which uses some of stored naming here to do redirects.
 """
 import os
 import re
 from routes import Mapper
 
 # prefix for non repository related links needs to be prefixed with `/`
 ADMIN_PREFIX = '/_admin'
 STATIC_FILE_PREFIX = '/_static'
 
 # Default requirements for URL parts
 URL_NAME_REQUIREMENTS = {
     # group name can have a slash in them, but they must not end with a slash
     'group_name': r'.*?[^/]',
     'repo_group_name': r'.*?[^/]',
     # repo names can have a slash in them, but they must not end with a slash
     'repo_name': r'.*?[^/]',
     # file path eats up everything at the end
     'f_path': r'.*',
     # reference types
     'source_ref_type': '(branch|book|tag|rev|\%\(source_ref_type\)s)',
     'target_ref_type': '(branch|book|tag|rev|\%\(target_ref_type\)s)',
 }
 
 
 class JSRoutesMapper(Mapper):
     """
     Wrapper for routes.Mapper to make pyroutes compatible url definitions
     """
     _named_route_regex = re.compile(r'^[a-z-_0-9A-Z]+$')
     _argument_prog = re.compile('\{(.*?)\}|:\((.*)\)')
     def __init__(self, *args, **kw):
         super(JSRoutesMapper, self).__init__(*args, **kw)
         self._jsroutes = []
 
     def connect(self, *args, **kw):
         """
         Wrapper for connect to take an extra argument jsroute=True
 
         :param jsroute: boolean, if True will add the route to the pyroutes list
         """
         if kw.pop('jsroute', False):
             if not self._named_route_regex.match(args[0]):
                 raise Exception('only named routes can be added to pyroutes')
             self._jsroutes.append(args[0])
 
         super(JSRoutesMapper, self).connect(*args, **kw)
 
     def _extract_route_information(self, route):
         """
         Convert a route into tuple(name, path, args), eg:
             ('show_user', '/profile/%(username)s', ['username'])
         """
         routepath = route.routepath
         def replace(matchobj):
             if matchobj.group(1):
                 return "%%(%s)s" % matchobj.group(1).split(':')[0]
             else:
                 return "%%(%s)s" % matchobj.group(2)
 
         routepath = self._argument_prog.sub(replace, routepath)
         return (
             route.name,
             routepath,
             [(arg[0].split(':')[0] if arg[0] != '' else arg[1])
               for arg in self._argument_prog.findall(route.routepath)]
         )
 
     def jsroutes(self):
         """
         Return a list of pyroutes.js compatible routes
         """
         for route_name in self._jsroutes:
             yield self._extract_route_information(self._routenames[route_name])
 
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
     rmap = JSRoutesMapper(
         directory=config['pylons.paths']['controllers'],
         always_scan=config['debug'])
     rmap.minimization = False
     rmap.explicit = False
 
     from rhodecode.lib.utils2 import str2bool
     from rhodecode.model import repo, repo_group
 
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         repo_name = match_dict.get('repo_name')
 
         if match_dict.get('f_path'):
             # fix for multiple initial slashes that causes errors
             match_dict['f_path'] = match_dict['f_path'].lstrip('/')
         repo_model = repo.RepoModel()
         by_name_match = repo_model.get_by_repo_name(repo_name)
         # if we match quickly from database, short circuit the operation,
         # and validate repo based on the type.
         if by_name_match:
             return True
 
         by_id_match = repo_model.get_repo_by_id(repo_name)
         if by_id_match:
             repo_name = by_id_match.repo_name
             match_dict['repo_name'] = repo_name
             return True
 
         return False
 
     def check_group(environ, match_dict):
         """
         check for valid repository group path for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         repo_group_name = match_dict.get('group_name')
         repo_group_model = repo_group.RepoGroupModel()
         by_name_match = repo_group_model.get_by_group_name(repo_group_name)
         if by_name_match:
             return True
 
         return False
 
     def check_user_group(environ, match_dict):
         """
         check for valid user group for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         return True
 
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
 
 
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
 
     # ping and pylons error test
     rmap.connect('ping', '%s/ping' % (ADMIN_PREFIX,), controller='home', action='ping')
     rmap.connect('error_test', '%s/error_test' % (ADMIN_PREFIX,), controller='home', action='error_test')
 
     # ADMIN REPOSITORY ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repos') as m:
         m.connect('repos', '/repos',
                   action='create', conditions={'method': ['POST']})
         m.connect('repos', '/repos',
                   action='index', conditions={'method': ['GET']})
         m.connect('new_repo', '/create_repository', jsroute=True,
                   action='create_repository', conditions={'method': ['GET']})
         m.connect('delete_repo', '/repos/{repo_name}',
                   action='delete', conditions={'method': ['DELETE']},
                   requirements=URL_NAME_REQUIREMENTS)
         m.connect('repo', '/repos/{repo_name}',
                   action='show', conditions={'method': ['GET'],
                                              'function': check_repo},
                   requirements=URL_NAME_REQUIREMENTS)
 
     # ADMIN REPOSITORY GROUPS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repo_groups') as m:
         m.connect('repo_groups', '/repo_groups',
                   action='create', conditions={'method': ['POST']})
         m.connect('repo_groups', '/repo_groups',
                   action='index', conditions={'method': ['GET']})
         m.connect('new_repo_group', '/repo_groups/new',
                   action='new', conditions={'method': ['GET']})
         m.connect('update_repo_group', '/repo_groups/{group_name}',
                   action='update', conditions={'method': ['PUT'],
                                                'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
 
         # EXTRAS REPO GROUP ROUTES
         m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
                   action='edit',
                   conditions={'method': ['GET'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
         m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
                   action='edit',
                   conditions={'method': ['PUT'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
 
         m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
                   action='edit_repo_group_advanced',
                   conditions={'method': ['GET'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
         m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
                   action='edit_repo_group_advanced',
                   conditions={'method': ['PUT'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
 
         m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
                   action='edit_repo_group_perms',
                   conditions={'method': ['GET'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
         m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
                   action='update_perms',
                   conditions={'method': ['PUT'], 'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
 
         m.connect('delete_repo_group', '/repo_groups/{group_name}',
                   action='delete', conditions={'method': ['DELETE'],
                                                'function': check_group},
                   requirements=URL_NAME_REQUIREMENTS)
 
     # ADMIN USER ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/users') as m:
         m.connect('users', '/users',
                   action='create', conditions={'method': ['POST']})
         m.connect('new_user', '/users/new',
                   action='new', conditions={'method': ['GET']})
         m.connect('update_user', '/users/{user_id}',
                   action='update', conditions={'method': ['PUT']})
         m.connect('delete_user', '/users/{user_id}',
                   action='delete', conditions={'method': ['DELETE']})
         m.connect('edit_user', '/users/{user_id}/edit',
                   action='edit', conditions={'method': ['GET']}, jsroute=True)
         m.connect('user', '/users/{user_id}',
                   action='show', conditions={'method': ['GET']})
         m.connect('force_password_reset_user', '/users/{user_id}/password_reset',
                   action='reset_password', conditions={'method': ['POST']})
         m.connect('create_personal_repo_group', '/users/{user_id}/create_repo_group',
                   action='create_personal_repo_group', conditions={'method': ['POST']})
 
         # EXTRAS USER ROUTES
         m.connect('edit_user_advanced', '/users/{user_id}/edit/advanced',
                   action='edit_advanced', conditions={'method': ['GET']})
         m.connect('edit_user_advanced', '/users/{user_id}/edit/advanced',
                   action='update_advanced', conditions={'method': ['PUT']})
 
         m.connect('edit_user_global_perms', '/users/{user_id}/edit/global_permissions',
                   action='edit_global_perms', conditions={'method': ['GET']})
         m.connect('edit_user_global_perms', '/users/{user_id}/edit/global_permissions',
                   action='update_global_perms', conditions={'method': ['PUT']})
 
         m.connect('edit_user_perms_summary', '/users/{user_id}/edit/permissions_summary',
                   action='edit_perms_summary', conditions={'method': ['GET']})
 
     # ADMIN USER GROUPS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/user_groups') as m:
         m.connect('users_groups', '/user_groups',
                   action='create', conditions={'method': ['POST']})
         m.connect('new_users_group', '/user_groups/new',
                   action='new', conditions={'method': ['GET']})
         m.connect('update_users_group', '/user_groups/{user_group_id}',
                   action='update', conditions={'method': ['PUT']})
         m.connect('delete_users_group', '/user_groups/{user_group_id}',
                   action='delete', conditions={'method': ['DELETE']})
         m.connect('edit_users_group', '/user_groups/{user_group_id}/edit',
                   action='edit', conditions={'method': ['GET']},
                   function=check_user_group)
 
         # EXTRAS USER GROUP ROUTES
         m.connect('edit_user_group_global_perms',
                   '/user_groups/{user_group_id}/edit/global_permissions',
                   action='edit_global_perms', conditions={'method': ['GET']})
         m.connect('edit_user_group_global_perms',
                   '/user_groups/{user_group_id}/edit/global_permissions',
                   action='update_global_perms', conditions={'method': ['PUT']})
         m.connect('edit_user_group_perms_summary',
                   '/user_groups/{user_group_id}/edit/permissions_summary',
                   action='edit_perms_summary', conditions={'method': ['GET']})
 
         m.connect('edit_user_group_perms',
                   '/user_groups/{user_group_id}/edit/permissions',
                   action='edit_perms', conditions={'method': ['GET']})
         m.connect('edit_user_group_perms',
                   '/user_groups/{user_group_id}/edit/permissions',
                   action='update_perms', conditions={'method': ['PUT']})
 
         m.connect('edit_user_group_advanced',
                   '/user_groups/{user_group_id}/edit/advanced',
                   action='edit_advanced', conditions={'method': ['GET']})
 
         m.connect('edit_user_group_advanced_sync',
                   '/user_groups/{user_group_id}/edit/advanced/sync',
                   action='edit_advanced_set_synchronization', conditions={'method': ['POST']})
 
     # ADMIN DEFAULTS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/defaults') as m:
         m.connect('admin_defaults_repositories', '/defaults/repositories',
                   action='update_repository_defaults', conditions={'method': ['POST']})
         m.connect('admin_defaults_repositories', '/defaults/repositories',
                   action='index', conditions={'method': ['GET']})
 
     # ADMIN SETTINGS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/settings') as m:
 
         # default
         m.connect('admin_settings', '/settings',
                   action='settings_global_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings', '/settings',
                   action='settings_global', conditions={'method': ['GET']})
 
         m.connect('admin_settings_vcs', '/settings/vcs',
                   action='settings_vcs_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_vcs', '/settings/vcs',
                   action='settings_vcs',
                   conditions={'method': ['GET']})
         m.connect('admin_settings_vcs', '/settings/vcs',
                   action='delete_svn_pattern',
                   conditions={'method': ['DELETE']})
 
         m.connect('admin_settings_mapping', '/settings/mapping',
                   action='settings_mapping_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_mapping', '/settings/mapping',
                   action='settings_mapping', conditions={'method': ['GET']})
 
         m.connect('admin_settings_global', '/settings/global',
                   action='settings_global_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_global', '/settings/global',
                   action='settings_global', conditions={'method': ['GET']})
 
         m.connect('admin_settings_visual', '/settings/visual',
                   action='settings_visual_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_visual', '/settings/visual',
                   action='settings_visual', conditions={'method': ['GET']})
 
         m.connect('admin_settings_issuetracker',
                   '/settings/issue-tracker', action='settings_issuetracker',
                   conditions={'method': ['GET']})
         m.connect('admin_settings_issuetracker_save',
                   '/settings/issue-tracker/save',
                   action='settings_issuetracker_save',
                   conditions={'method': ['POST']})
         m.connect('admin_issuetracker_test', '/settings/issue-tracker/test',
                   action='settings_issuetracker_test',
                   conditions={'method': ['POST']})
         m.connect('admin_issuetracker_delete',
                   '/settings/issue-tracker/delete',
                   action='settings_issuetracker_delete',
                   conditions={'method': ['DELETE']})
 
         m.connect('admin_settings_email', '/settings/email',
                   action='settings_email_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_email', '/settings/email',
                   action='settings_email', conditions={'method': ['GET']})
 
         m.connect('admin_settings_hooks', '/settings/hooks',
                   action='settings_hooks_update',
                   conditions={'method': ['POST', 'DELETE']})
         m.connect('admin_settings_hooks', '/settings/hooks',
                   action='settings_hooks', conditions={'method': ['GET']})
 
         m.connect('admin_settings_search', '/settings/search',
                   action='settings_search', conditions={'method': ['GET']})
 
         m.connect('admin_settings_supervisor', '/settings/supervisor',
                   action='settings_supervisor', conditions={'method': ['GET']})
         m.connect('admin_settings_supervisor_log', '/settings/supervisor/{procid}/log',
                   action='settings_supervisor_log', conditions={'method': ['GET']})
 
         m.connect('admin_settings_labs', '/settings/labs',
                   action='settings_labs_update',
                   conditions={'method': ['POST']})
         m.connect('admin_settings_labs', '/settings/labs',
                   action='settings_labs', conditions={'method': ['GET']})
 
     # ADMIN MY ACCOUNT
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/my_account') as m:
 
         # NOTE(marcink): this needs to be kept for password force flag to be
         # handled in pylons controllers, remove after full migration to pyramid
         m.connect('my_account_password', '/my_account/password',
                   action='my_account_password', conditions={'method': ['GET']})
 
     #==========================================================================
     # REPOSITORY ROUTES
     #==========================================================================
 
-    rmap.connect('repo_creating_home', '/{repo_name}/repo_creating',
-                 controller='admin/repos', action='repo_creating',
-                 requirements=URL_NAME_REQUIREMENTS)
-    rmap.connect('repo_check_home', '/{repo_name}/crepo_check',
-                 controller='admin/repos', action='repo_check',
-                 requirements=URL_NAME_REQUIREMENTS)
-
     # repo edit options
     rmap.connect('edit_repo_fields', '/{repo_name}/settings/fields',
                  controller='admin/repos', action='edit_fields',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('create_repo_fields', '/{repo_name}/settings/fields/new',
                  controller='admin/repos', action='create_repo_field',
                  conditions={'method': ['PUT'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('delete_repo_fields', '/{repo_name}/settings/fields/{field_id}',
                  controller='admin/repos', action='delete_repo_field',
                  conditions={'method': ['DELETE'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('toggle_locking', '/{repo_name}/settings/advanced/locking_toggle',
                  controller='admin/repos', action='toggle_locking',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('edit_repo_remote', '/{repo_name}/settings/remote',
                  controller='admin/repos', action='edit_remote_form',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('edit_repo_remote', '/{repo_name}/settings/remote',
                  controller='admin/repos', action='edit_remote',
                  conditions={'method': ['PUT'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('edit_repo_statistics', '/{repo_name}/settings/statistics',
                  controller='admin/repos', action='edit_statistics_form',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('edit_repo_statistics', '/{repo_name}/settings/statistics',
                  controller='admin/repos', action='edit_statistics',
                  conditions={'method': ['PUT'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_settings_issuetracker',
                  '/{repo_name}/settings/issue-tracker',
                  controller='admin/repos', action='repo_issuetracker',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_issuetracker_test',
                  '/{repo_name}/settings/issue-tracker/test',
                  controller='admin/repos', action='repo_issuetracker_test',
                  conditions={'method': ['POST'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_issuetracker_delete',
                  '/{repo_name}/settings/issue-tracker/delete',
                  controller='admin/repos', action='repo_issuetracker_delete',
                  conditions={'method': ['DELETE'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_issuetracker_save',
                  '/{repo_name}/settings/issue-tracker/save',
                  controller='admin/repos', action='repo_issuetracker_save',
                  conditions={'method': ['POST'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
                  controller='admin/repos', action='repo_settings_vcs_update',
                  conditions={'method': ['POST'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
                  controller='admin/repos', action='repo_settings_vcs',
                  conditions={'method': ['GET'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
                  controller='admin/repos', action='repo_delete_svn_pattern',
                  conditions={'method': ['DELETE'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
     rmap.connect('repo_pullrequest_settings', '/{repo_name}/settings/pullrequest',
                  controller='admin/repos', action='repo_settings_pullrequest',
                  conditions={'method': ['GET', 'POST'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
 
     rmap.connect('repo_fork_create_home', '/{repo_name}/fork',
                  controller='forks', action='fork_create',
                  conditions={'function': check_repo, 'method': ['POST']},
                  requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('repo_fork_home', '/{repo_name}/fork',
                  controller='forks', action='fork',
                  conditions={'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('repo_forks_home', '/{repo_name}/forks',
                  controller='forks', action='forks',
                  conditions={'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
 
     return rmap

rhodecode/controllers/admin/repos.py

@@ -1,606 +1,563 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2013-2017 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/
 
 
 """
 Repositories controller for RhodeCode
 """
 
 import logging
 import traceback
 
 import formencode
 from formencode import htmlfill
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
-from webob.exc import HTTPForbidden, HTTPNotFound, HTTPBadRequest
+from webob.exc import HTTPForbidden, HTTPBadRequest
 
+from pyramid.httpexceptions import HTTPFound
 import rhodecode
 from rhodecode.lib import auth, helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator,
     HasRepoPermissionAllDecorator, NotAnonymous, HasPermissionAny,
     HasRepoGroupPermissionAny, HasRepoPermissionAnyDecorator)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils import repo_name_slug, jsonify
 from rhodecode.lib.utils2 import safe_int, str2bool
 from rhodecode.model.db import (Repository, RepoGroup, RepositoryField)
 from rhodecode.model.forms import (
     RepoForm, RepoFieldForm, RepoVcsSettingsForm, IssueTrackerPatternsForm)
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel, RepoGroupList, RepoList
 from rhodecode.model.settings import (
     SettingsModel, IssueTrackerSettingsModel, VcsSettingsModel,
     SettingNotFound)
 
 log = logging.getLogger(__name__)
 
 
 class ReposController(BaseRepoController):
     """
     REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
 
     @LoginRequired()
     def __before__(self):
         super(ReposController, self).__before__()
 
     def _load_repo(self, repo_name):
         repo_obj = Repository.get_by_repo_name(repo_name)
 
         if repo_obj is None:
             h.not_mapped_error(repo_name)
             return redirect(url('repos'))
 
         return repo_obj
 
     def __load_defaults(self, repo=None):
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
         # in case someone no longer have a group.write access to a repository
         # pre fill the list with this entry, we don't care if this is the same
         # but it will allow saving repo data properly.
 
         repo_group = None
         if repo:
             repo_group = repo.group
         if repo_group and unicode(repo_group.group_id) not in c.repo_groups_choices:
             c.repo_groups_choices.append(unicode(repo_group.group_id))
             c.repo_groups.append(RepoGroup._generate_choice(repo_group))
 
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.landing_revs_choices = choices
 
     def __load_data(self, repo_name=None):
         """
         Load defaults settings for edit, and update
 
         :param repo_name:
         """
         c.repo_info = self._load_repo(repo_name)
         self.__load_defaults(c.repo_info)
 
         # override defaults for exact repo info here git/hg etc
         if not c.repository_requirements_missing:
             choices, c.landing_revs = ScmModel().get_repo_landing_revs(
                 c.repo_info)
             c.landing_revs_choices = choices
         defaults = RepoModel()._get_defaults(repo_name)
 
         return defaults
 
     def _log_creation_exception(self, e, repo_name):
             reason = None
             if len(e.args) == 2:
                 reason = e.args[1]
 
             if reason == 'INVALID_CERTIFICATE':
                 log.exception(
                     'Exception creating a repository: invalid certificate')
                 msg = (_('Error creating repository %s: invalid certificate')
                        % repo_name)
             else:
                 log.exception("Exception creating a repository")
                 msg = (_('Error creating repository %s')
                        % repo_name)
 
             return msg
 
     @NotAnonymous()
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
 
         repo_list = Repository.get_all_repos()
         c.repo_list = RepoList(repo_list, perm_set=['repository.admin'])
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=c.repo_list, admin=True, super_user_actions=True)
         # json used to render the grid
         c.data = json.dumps(repos_data)
 
         return render('admin/repos/repos.mako')
 
     # perms check inside
     @NotAnonymous()
     @auth.CSRFRequired()
     def create(self):
         """
         POST /repos: Create a new item"""
         # url('repos')
 
         self.__load_defaults()
         form_result = {}
         task_id = None
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form_result = RepoForm(repo_groups=c.repo_groups_choices,
                                    landing_revs=c.landing_revs_choices)()\
                             .to_python(dict(request.POST))
 
             # create is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create(form_result, c.rhodecode_user.user_id)
             from celery.result import BaseAsyncResult
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
             return htmlfill.render(
                 render('admin/repos/repo_add.mako'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
 
         except Exception as e:
             msg = self._log_creation_exception(e, form_result.get('repo_name'))
             h.flash(msg, category='error')
             return redirect(h.route_path('home'))
 
-        return redirect(h.url('repo_creating_home',
+        raise HTTPFound(
+            h.route_path('repo_creating',
                               repo_name=form_result['repo_name_full'],
-                              task_id=task_id))
+                         _query=dict(task_id=task_id)))
 
     # perms check inside
     @NotAnonymous()
     def create_repository(self):
         """GET /_admin/create_repository: Form to create a new item"""
         new_repo = request.GET.get('repo', '')
         parent_group = safe_int(request.GET.get('parent_group'))
         _gr = RepoGroup.get(parent_group)
 
         if not HasPermissionAny('hg.admin', 'hg.create.repository')():
             # you're not super admin nor have global create permissions,
             # but maybe you have at least write permission to a parent group ?
 
             gr_name = _gr.group_name if _gr else None
             # create repositories with write permission on group is set to true
             create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
             group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
             group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
             if not (group_admin or (group_write and create_on_write)):
                 raise HTTPForbidden
 
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
         c.new_repo = repo_name_slug(new_repo)
 
         # apply the defaults from defaults page
         defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
         # set checkbox to autochecked
         defaults['repo_copy_permissions'] = True
 
         parent_group_choice = '-1'
         if not c.rhodecode_user.is_admin and c.rhodecode_user.personal_repo_group:
             parent_group_choice = c.rhodecode_user.personal_repo_group
 
         if parent_group and _gr:
             if parent_group in [x[0] for x in c.repo_groups]:
                 parent_group_choice = unicode(parent_group)
 
         defaults.update({'repo_group': parent_group_choice})
 
         return htmlfill.render(
             render('admin/repos/repo_add.mako'),
             defaults=defaults,
             errors={},
             prefix_error=False,
             encoding="UTF-8",
             force_defaults=False
         )
 
-    @NotAnonymous()
-    def repo_creating(self, repo_name):
-        c.repo = repo_name
-        c.task_id = request.GET.get('task_id')
-        if not c.repo:
-            raise HTTPNotFound()
-        return render('admin/repos/repo_creating.mako')
-
-    @NotAnonymous()
-    @jsonify
-    def repo_check(self, repo_name):
-        c.repo = repo_name
-        task_id = request.GET.get('task_id')
-
-        if task_id and task_id not in ['None']:
-            import rhodecode
-            from celery.result import AsyncResult
-            if rhodecode.CELERY_ENABLED:
-                task = AsyncResult(task_id)
-                if task.failed():
-                    msg = self._log_creation_exception(task.result, c.repo)
-                    h.flash(msg, category='error')
-                    return redirect(h.route_path('home'), code=501)
-
-        repo = Repository.get_by_repo_name(repo_name)
-        if repo and repo.repo_state == Repository.STATE_CREATED:
-            if repo.clone_uri:
-                clone_uri = repo.clone_uri_hidden
-                h.flash(_('Created repository %s from %s')
-                        % (repo.repo_name, clone_uri), category='success')
-            else:
-                repo_url = h.link_to(
-                    repo.repo_name,
-                    h.route_path('repo_summary',repo_name=repo.repo_name))
-                fork = repo.fork
-                if fork:
-                    fork_name = fork.repo_name
-                    h.flash(h.literal(_('Forked repository %s as %s')
-                            % (fork_name, repo_url)), category='success')
-                else:
-                    h.flash(h.literal(_('Created repository %s') % repo_url),
-                            category='success')
-            return {'result': True}
-        return {'result': False}
-
     @HasPermissionAllDecorator('hg.admin')
     def show(self, repo_name, format='html'):
         """GET /repos/repo_name: Show a specific item"""
         # url('repo', repo_name=ID)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_fields(self, repo_name):
         """GET /repo_name/settings: Form to edit an existing item"""
         c.repo_info = self._load_repo(repo_name)
         c.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == c.repo_info).all()
         c.active = 'fields'
         if request.POST:
 
             return redirect(url('repo_edit_fields'))
         return render('admin/repos/repo_edit.mako')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def create_repo_field(self, repo_name):
         try:
             form_result = RepoFieldForm()().to_python(dict(request.POST))
             RepoModel().add_repo_field(
                 repo_name, form_result['new_field_key'],
                 field_type=form_result['new_field_type'],
                 field_value=form_result['new_field_value'],
                 field_label=form_result['new_field_label'],
                 field_desc=form_result['new_field_desc'])
 
             Session().commit()
         except Exception as e:
             log.exception("Exception creating field")
             msg = _('An error occurred during creation of field')
             if isinstance(e, formencode.Invalid):
                 msg += ". " + e.msg
             h.flash(msg, category='error')
         return redirect(url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def delete_repo_field(self, repo_name, field_id):
         field = RepositoryField.get_or_404(field_id)
         try:
             RepoModel().delete_repo_field(repo_name, field.field_key)
             Session().commit()
         except Exception as e:
             log.exception("Exception during removal of field")
             msg = _('An error occurred during removal of field')
             h.flash(msg, category='error')
         return redirect(url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @auth.CSRFRequired()
     def toggle_locking(self, repo_name):
         """
         Toggle locking of repository by simple GET call to url
 
         :param repo_name:
         """
 
         try:
             repo = Repository.get_by_repo_name(repo_name)
 
             if repo.enable_locking:
                 if repo.locked[0]:
                     Repository.unlock(repo)
                     action = _('Unlocked')
                 else:
                     Repository.lock(repo, c.rhodecode_user.user_id,
                                     lock_reason=Repository.LOCK_WEB)
                     action = _('Locked')
 
                 h.flash(_('Repository has been %s') % action,
                         category='success')
         except Exception:
             log.exception("Exception during unlocking")
             h.flash(_('An error occurred during unlocking'),
                     category='error')
         return redirect(h.route_path('repo_summary', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_remote(self, repo_name):
         """PUT /{repo_name}/settings/remote: edit the repo remote."""
         try:
             ScmModel().pull_changes(repo_name, c.rhodecode_user.username)
             h.flash(_('Pulled from remote location'), category='success')
         except Exception:
             log.exception("Exception during pull from remote")
             h.flash(_('An error occurred during pull from remote location'),
                     category='error')
         return redirect(url('edit_repo_remote', repo_name=c.repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_remote_form(self, repo_name):
         """GET /repo_name/settings: Form to edit an existing item"""
         c.repo_info = self._load_repo(repo_name)
         c.active = 'remote'
 
         return render('admin/repos/repo_edit.mako')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_statistics(self, repo_name):
         """PUT /{repo_name}/settings/statistics: reset the repo statistics."""
         try:
             RepoModel().delete_stats(repo_name)
             Session().commit()
         except Exception as e:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
         return redirect(url('edit_repo_statistics', repo_name=c.repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_statistics_form(self, repo_name):
         """GET /repo_name/settings: Form to edit an existing item"""
         c.repo_info = self._load_repo(repo_name)
         repo = c.repo_info.scm_instance()
 
         if c.repo_info.stats:
             # this is on what revision we ended up so we add +1 for count
             last_rev = c.repo_info.stats.stat_on_revision + 1
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
         c.repo_last_rev = repo.count()
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
         else:
             c.stats_percentage = '%.2f' % ((float((last_rev)) / c.repo_last_rev) * 100)
 
         c.active = 'statistics'
 
         return render('admin/repos/repo_edit.mako')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_test(self, repo_name):
         if request.is_xhr:
             return h.urlify_commit_message(
                 request.POST.get('test_text', ''),
                 repo_name)
         else:
             raise HTTPBadRequest()
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_delete(self, repo_name):
         uid = request.POST.get('uid')
         repo_settings = IssueTrackerSettingsModel(repo=repo_name)
         try:
             repo_settings.delete_entries(uid)
         except Exception:
             h.flash(_('Error occurred during deleting issue tracker entry'),
                     category='error')
         else:
             h.flash(_('Removed issue tracker entry'), category='success')
         return redirect(url('repo_settings_issuetracker',
                         repo_name=repo_name))
 
     def _update_patterns(self, form, repo_settings):
         for uid in form['delete_patterns']:
             repo_settings.delete_entries(uid)
 
         for pattern in form['patterns']:
             for setting, value, type_ in pattern:
                 sett = repo_settings.create_or_update_setting(
                     setting, value, type_)
                 Session().add(sett)
 
             Session().commit()
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_save(self, repo_name):
         # Save inheritance
         repo_settings = IssueTrackerSettingsModel(repo=repo_name)
         inherited = (request.POST.get('inherit_global_issuetracker')
                      == "inherited")
         repo_settings.inherit_global_settings = inherited
         Session().commit()
 
         form = IssueTrackerPatternsForm()().to_python(request.POST)
         if form:
             self._update_patterns(form, repo_settings)
 
         h.flash(_('Updated issue tracker entries'), category='success')
         return redirect(url('repo_settings_issuetracker',
                         repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def repo_issuetracker(self, repo_name):
         """GET /admin/settings/issue-tracker: All items in the collection"""
         c.active = 'issuetracker'
         c.data = 'data'
         c.repo_info = self._load_repo(repo_name)
 
         repo = Repository.get_by_repo_name(repo_name)
         c.settings_model = IssueTrackerSettingsModel(repo=repo)
         c.global_patterns = c.settings_model.get_global_settings()
         c.repo_patterns = c.settings_model.get_repo_settings()
 
         return render('admin/repos/repo_edit.mako')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def repo_settings_vcs(self, repo_name):
         """GET /{repo_name}/settings/vcs/: All items in the collection"""
 
         model = VcsSettingsModel(repo=repo_name)
 
         c.active = 'vcs'
         c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
         c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
         c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
         c.repo_info = self._load_repo(repo_name)
         defaults = self._vcs_form_defaults(repo_name)
         c.inherit_global_settings = defaults['inherit_global_settings']
         c.labs_active = str2bool(
             rhodecode.CONFIG.get('labs_settings_active', 'true'))
 
         return htmlfill.render(
             render('admin/repos/repo_edit.mako'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_settings_vcs_update(self, repo_name):
         """POST /{repo_name}/settings/vcs/: All items in the collection"""
         c.active = 'vcs'
 
         model = VcsSettingsModel(repo=repo_name)
         c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
         c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
         c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
         c.repo_info = self._load_repo(repo_name)
         defaults = self._vcs_form_defaults(repo_name)
         c.inherit_global_settings = defaults['inherit_global_settings']
 
         application_form = RepoVcsSettingsForm(repo_name)()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             return htmlfill.render(
                 render('admin/repos/repo_edit.mako'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
 
         try:
             inherit_global_settings = form_result['inherit_global_settings']
             model.create_or_update_repo_settings(
                 form_result, inherit_global_settings=inherit_global_settings)
         except Exception:
             log.exception("Exception while updating settings")
             h.flash(
                 _('Error occurred during updating repository VCS settings'),
                 category='error')
         else:
             Session().commit()
             h.flash(_('Updated VCS settings'), category='success')
             return redirect(url('repo_vcs_settings', repo_name=repo_name))
 
         return htmlfill.render(
             render('admin/repos/repo_edit.mako'),
             defaults=self._vcs_form_defaults(repo_name),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def repo_delete_svn_pattern(self, repo_name):
         if not request.is_xhr:
             return False
 
         delete_pattern_id = request.POST.get('delete_svn_pattern')
         model = VcsSettingsModel(repo=repo_name)
         try:
             model.delete_repo_svn_pattern(delete_pattern_id)
         except SettingNotFound:
             raise HTTPBadRequest()
 
         Session().commit()
         return True
 
     def _vcs_form_defaults(self, repo_name):
         model = VcsSettingsModel(repo=repo_name)
         global_defaults = model.get_global_settings()
 
         repo_defaults = {}
         repo_defaults.update(global_defaults)
         repo_defaults.update(model.get_repo_settings())
 
         global_defaults = {
             '{}_inherited'.format(k): global_defaults[k]
             for k in global_defaults}
 
         defaults = {
             'inherit_global_settings': model.inherit_global_settings
         }
         defaults.update(global_defaults)
         defaults.update(repo_defaults)
         defaults.update({
             'new_svn_branch': '',
             'new_svn_tag': '',
         })
         return defaults

rhodecode/controllers/forks.py

@@ -1,196 +1,198 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2017 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/
 
 """
 forks controller for rhodecode
 """
 
 import formencode
 import logging
 from formencode import htmlfill
 
 from pylons import tmpl_context as c, request, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
+from pyramid.httpexceptions import HTTPFound
 import rhodecode.lib.helpers as h
 
 from rhodecode.lib import auth
 from rhodecode.lib.helpers import Page
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasRepoPermissionAny, HasPermissionAnyDecorator, HasAcceptedRepoType)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.model.db import Repository, RepoGroup, UserFollowing, User
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.forms import RepoForkForm
 from rhodecode.model.scm import ScmModel, RepoGroupList
 from rhodecode.lib.utils2 import safe_int
 
 log = logging.getLogger(__name__)
 
 
 class ForksController(BaseRepoController):
 
     def __before__(self):
         super(ForksController, self).__before__()
 
     def __load_defaults(self):
         acl_groups = RepoGroupList(
             RepoGroup.query().all(),
             perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.landing_revs_choices = choices
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
 
     def __load_data(self, repo_name=None):
         """
         Load defaults settings for edit, and update
 
         :param repo_name:
         """
         self.__load_defaults()
 
         c.repo_info = Repository.get_by_repo_name(repo_name)
         repo = c.repo_info.scm_instance()
 
         if c.repo_info is None:
             h.not_mapped_error(repo_name)
             return redirect(url('repos'))
 
         c.default_user_id = User.get_default_user().user_id
         c.in_public_journal = UserFollowing.query()\
             .filter(UserFollowing.user_id == c.default_user_id)\
             .filter(UserFollowing.follows_repository == c.repo_info).scalar()
 
         if c.repo_info.stats:
             last_rev = c.repo_info.stats.stat_on_revision+1
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
         c.repo_last_rev = repo.count()
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
         else:
             c.stats_percentage = '%.2f' % ((float((last_rev)) /
                                             c.repo_last_rev) * 100)
 
         defaults = RepoModel()._get_defaults(repo_name)
         # alter the description to indicate a fork
         defaults['description'] = ('fork of repository: %s \n%s'
                                    % (defaults['repo_name'],
                                       defaults['description']))
         # add suffix to fork
         defaults['repo_name'] = '%s-fork' % defaults['repo_name']
 
         return defaults
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     def forks(self, repo_name):
         p = safe_int(request.GET.get('page', 1), 1)
         repo_id = c.rhodecode_db_repo.repo_id
         d = []
         for r in Repository.get_repo_forks(repo_id):
             if not HasRepoPermissionAny(
                 'repository.read', 'repository.write', 'repository.admin'
             )(r.repo_name, 'get forks check'):
                 continue
             d.append(r)
         c.forks_pager = Page(d, page=p, items_per_page=20)
 
         c.forks_data = render('/forks/forks_data.mako')
 
         if request.environ.get('HTTP_X_PJAX'):
             return c.forks_data
 
         return render('/forks/forks.mako')
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     def fork(self, repo_name):
         c.repo_info = Repository.get_by_repo_name(repo_name)
         if not c.repo_info:
             h.not_mapped_error(repo_name)
             return redirect(h.route_path('home'))
 
         defaults = self.__load_data(repo_name)
 
         return htmlfill.render(
             render('forks/fork.mako'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     @auth.CSRFRequired()
     def fork_create(self, repo_name):
         self.__load_defaults()
         c.repo_info = Repository.get_by_repo_name(repo_name)
         _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},
                              repo_groups=c.repo_groups_choices,
                              landing_revs=c.landing_revs_choices)()
         form_result = {}
         task_id = None
         try:
             form_result = _form.to_python(dict(request.POST))
             # create fork is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create_fork(
                 form_result, c.rhodecode_user.user_id)
             from celery.result import BaseAsyncResult
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
             c.new_repo = errors.value['repo_name']
             return htmlfill.render(
                 render('forks/fork.mako'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
         except Exception:
             log.exception(
                 u'Exception while trying to fork the repository %s', repo_name)
             msg = (
                 _('An error occurred during repository forking %s') %
                 (repo_name, ))
             h.flash(msg, category='error')
 
-        return redirect(h.url('repo_creating_home',
+        raise HTTPFound(
+            h.route_path('repo_creating',
                               repo_name=form_result['repo_name_full'],
-                              task_id=task_id))
+                         _query=dict(task_id=task_id)))

rhodecode/public/css/main.less

@@ -1,2392 +1,2397 b''
 //Primary CSS
 
 //--- IMPORTS ------------------//
 
 @import 'helpers';
 @import 'mixins';
 @import 'rcicons';
 @import 'fonts';
 @import 'variables';
 @import 'bootstrap-variables';
 @import 'form-bootstrap';
 @import 'codemirror';
 @import 'legacy_code_styles';
 @import 'readme-box';
 @import 'progress-bar';
 
 @import 'type';
 @import 'alerts';
 @import 'buttons';
 @import 'tags';
 @import 'code-block';
 @import 'examples';
 @import 'login';
 @import 'main-content';
 @import 'select2';
 @import 'comments';
 @import 'panels-bootstrap';
 @import 'panels';
 @import 'deform';
 
 //--- BASE ------------------//
 .noscript-error {
     top: 0;
     left: 0;
     width: 100%;
     z-index: 101;
     text-align: center;
     font-family: @text-semibold;
     font-size: 120%;
     color: white;
     background-color: @alert2;
     padding: 5px 0 5px 0;
 }
 
 html {
     display: table;
     height: 100%;
     width: 100%;
 }
 
 body {
     display: table-cell;
     width: 100%;
 }
 
 //--- LAYOUT ------------------//
 
 .hidden{
 	display: none !important;
 }
 
 .box{
 	float: left;
 	width: 100%;
 }
 
 .browser-header {
     clear: both;
 }
 .main {
   clear: both;
   padding:0 0 @pagepadding;
   height: auto;
 
 	&:after { //clearfix
 		content:"";
 		clear:both;
 		width:100%;
 		display:block;
 	}
 }
 
 .action-link{
 	margin-left: @padding;
 	padding-left: @padding;
 	border-left: @border-thickness solid @border-default-color;
 }
 
 input + .action-link, .action-link.first{
 	border-left: none;
 }
 
 .action-link.last{
 	margin-right: @padding;
 	padding-right: @padding;
 }
 
 .action-link.active,
 .action-link.active a{
 	color: @grey4;
 }
 
 .clipboard-action {
   cursor: pointer;
 }
 
 ul.simple-list{
 	list-style: none;
 	margin: 0;
 	padding: 0;
 }
 
 .main-content {
 	padding-bottom: @pagepadding;
 }
 
 .wide-mode-wrapper {
     max-width:4000px !important;
 }
 
 .wrapper {
 	position: relative;
 	max-width: @wrapper-maxwidth;
 	margin: 0 auto;
 }
 
 #content {
     clear: both;
     padding: 0 @contentpadding;
 }
 
 .advanced-settings-fields{
 	input{
 		margin-left: @textmargin;
 		margin-right: @padding/2;
 	}
 }
 
 .cs_files_title {
     margin: @pagepadding 0 0;
 }
 
 input.inline[type="file"] {
 	display: inline;
 }
 
 .error_page {
     margin: 10% auto;
 
     h1 {
         color: @grey2;
     }
 
     .alert {
         margin: @padding 0;
     }
 
     .error-branding {
         font-family: @text-semibold;
         color: @grey4;
     }
 
     .error_message {
         font-family: @text-regular;
     }
 
     .sidebar {
         min-height: 275px;
         margin: 0;
         padding: 0 0 @sidebarpadding @sidebarpadding;
         border: none;
     }
 
     .main-content {
         position: relative;
         margin: 0 @sidebarpadding @sidebarpadding;
         padding: 0 0 0 @sidebarpadding;
         border-left: @border-thickness solid @grey5;
 
         @media (max-width:767px) {
             clear: both;
             width: 100%;
             margin: 0;
             border: none;
         }
     }
 
     .inner-column {
         float: left;
         width: 29.75%;
         min-height: 150px;
         margin: @sidebarpadding 2% 0 0;
         padding: 0 2% 0 0;
         border-right: @border-thickness solid @grey5;
 
         @media (max-width:767px) {
             clear: both;
             width: 100%;
             border: none;
         }
 
         ul {
             padding-left: 1.25em;
         }
 
         &:last-child {
             margin: @sidebarpadding 0 0;
             border: none;
         }
 
         h4 {
             margin: 0 0 @padding;
             font-family: @text-semibold;
         }
     }
 }
 .error-page-logo {
     width: 130px;
     height: 160px;
 }
 
 // HEADER
 .header {
 
     // TODO: johbo: Fix login pages, so that they work without a min-height
     // for the header and then remove the min-height. I chose a smaller value
     // intentionally here to avoid rendering issues in the main navigation.
     min-height: 49px;
 
 	position: relative;
 	vertical-align: bottom;
 	padding: 0 @header-padding;
 	background-color: @grey2;
 	color: @grey5;
 
 	.title {
 		overflow: visible;
 	}
 
 	&:before,
 	&:after {
 		content: "";
 		clear: both;
 		width: 100%;
 	}
 
 	// TODO: johbo: Avoids breaking "Repositories" chooser
 	.select2-container .select2-choice .select2-arrow {
 	    display: none;
 	}
 }
 
 #header-inner {
 	&.title {
 		margin: 0;
 	}
 	&:before,
 	&:after {
 		content: "";
 		clear: both;
 	}
 }
 
 // Gists
 #files_data {
     clear: both; //for firefox
 }
 #gistid {
     margin-right: @padding;
 }
 
 // Global Settings Editor
 .textarea.editor {
 	float: left;
 	position: relative;
 	max-width: @texteditor-width;
 
 	select {
 		position: absolute;
 		top:10px;
 		right:0;
 	}
 
 	.CodeMirror {
 		margin: 0;
 	}
 
 	.help-block {
 		margin: 0 0 @padding;
 		padding:.5em;
 		background-color: @grey6;
         &.pre-formatting {
             white-space: pre;
         }
 	}
 }
 
 ul.auth_plugins {
 	margin: @padding 0 @padding @legend-width;
 	padding: 0;
 
 	li {
 		margin-bottom: @padding;
         line-height: 1em;
 		list-style-type: none;
 
 		.auth_buttons .btn {
 			margin-right: @padding;
 		}
 
         &:before { content: none; }
 	}
 }
 
 
 // My Account PR list
 
 #show_closed {
     margin: 0 1em 0 0;
 }
 
 .pullrequestlist {
     .closed {
         background-color: @grey6;
     }
     .td-status {
         padding-left: .5em;
     }
     .log-container .truncate {
         height: 2.75em;
         white-space: pre-line;
     }
     table.rctable .user {
         padding-left: 0;
     }
     table.rctable {
         td.td-description,
         .rc-user {
             min-width: auto;
         }
     }
 }
 
 // Pull Requests
 
 .pullrequests_section_head {
 	display: block;
 	clear: both;
 	margin: @padding 0;
 	font-family: @text-bold;
 }
 
 .pr-origininfo, .pr-targetinfo {
     position: relative;
 
     .tag {
         display: inline-block;
         margin: 0 1em .5em 0;
     }
 
     .clone-url {
         display: inline-block;
         margin: 0 0 .5em 0;
         padding: 0;
         line-height: 1.2em;
     }
 }
 
 .pr-mergeinfo {
       min-width: 95% !important;
       padding: 0 !important;
       border: 0;
 }
 .pr-mergeinfo-copy {
     padding: 0 0;
 }
 
 .pr-pullinfo {
       min-width: 95% !important;
       padding: 0 !important;
       border: 0;
 }
 .pr-pullinfo-copy {
     padding: 0 0;
 }
 
 
 #pr-title-input {
     width: 72%;
     font-size: 1em;
     font-family: @text-bold;
     margin: 0;
     padding: 0 0 0 @padding/4;
     line-height: 1.7em;
     color: @text-color;
     letter-spacing: .02em;
 }
 
 #pullrequest_title {
     width: 100%;
     box-sizing: border-box;
 }
 
 #pr_open_message {
     border: @border-thickness solid #fff;
     border-radius: @border-radius;
     padding: @padding-large-vertical @padding-large-vertical @padding-large-vertical 0;
     text-align: left;
     overflow: hidden;
 }
 
 .pr-submit-button {
     float: right;
     margin: 0 0 0 5px;
 }
 
 .pr-spacing-container {
     padding: 20px;
     clear: both
 }
 
 #pr-description-input {
     margin-bottom: 0;
 }
 
 .pr-description-label {
     vertical-align: top;
 }
 
 .perms_section_head {
     min-width: 625px;
 
     h2 {
         margin-bottom: 0;
     }
 
     .label-checkbox {
         float: left;
     }
 
     &.field {
         margin: @space 0 @padding;
     }
 
     &:first-child.field {
         margin-top: 0;
 
         .label {
             margin-top: 0;
             padding-top: 0;
         }
 
         .radios {
             padding-top: 0;
         }
     }
 
     .radios {
 	   float: right;
         position: relative;
         width: 405px;
     }
 }
 
 //--- MODULES ------------------//
 
 
 // Server Announcement
 #server-announcement {
     width: 95%;
     margin: @padding auto;
     padding: @padding;
     border-width: 2px;
     border-style: solid;
     .border-radius(2px);
     font-family: @text-bold;
 
     &.info    { border-color: @alert4; background-color: @alert4-inner; }
     &.warning { border-color: @alert3; background-color: @alert3-inner; }
     &.error   { border-color: @alert2; background-color: @alert2-inner; }
     &.success { border-color: @alert1; background-color: @alert1-inner; }
     &.neutral { border-color: @grey3; background-color: @grey6; }
 }
 
 // Fixed Sidebar Column
 .sidebar-col-wrapper {
     padding-left: @sidebar-all-width;
 
     .sidebar {
         width: @sidebar-width;
         margin-left: -@sidebar-all-width;
     }
 }
 
 .sidebar-col-wrapper.scw-small {
     padding-left: @sidebar-small-all-width;
 
     .sidebar {
         width: @sidebar-small-width;
         margin-left: -@sidebar-small-all-width;
     }
 }
 
 
 // FOOTER
 #footer {
 	padding: 0;
 	text-align: center;
 	vertical-align: middle;
 	color: @grey2;
 	background-color: @grey6;
 
 	p {
 		margin: 0;
 		padding: 1em;
 		line-height: 1em;
 	}
 
 	.server-instance { //server instance
 		display: none;
 	}
 
 	.title {
 		float: none;
 		margin: 0 auto;
 	}
 }
 
 button.close {
 	padding: 0;
 	cursor: pointer;
 	background: transparent;
 	border: 0;
 	.box-shadow(none);
 	-webkit-appearance: none;
 }
 
 .close {
 	float: right;
 	font-size: 21px;
 	font-family: @text-bootstrap;
 	line-height: 1em;
 	font-weight: bold;
 	color: @grey2;
 
 	&:hover,
 	&:focus {
 		color: @grey1;
 		text-decoration: none;
 		cursor: pointer;
 	}
 }
 
 // GRID
 .sorting,
 .sorting_desc,
 .sorting_asc {
 	cursor: pointer;
 }
 .sorting_desc:after {
 	content: "\00A0\25B2";
 	font-size: .75em;
 }
 .sorting_asc:after {
 	content: "\00A0\25BC";
 	font-size: .68em;
 }
 
 
 .user_auth_tokens {
 
     &.truncate {
         white-space: nowrap;
         overflow: hidden;
         text-overflow: ellipsis;
     }
 
 	.fields .field .input {
 		margin: 0;
 	}
 
 	input#description {
 		width: 100px;
 		margin: 0;
 	}
 
 	.drop-menu {
 	    // TODO: johbo: Remove this, should work out of the box when
 	    // having multiple inputs inline
 		margin: 0 0 0 5px;
 	}
 }
 #user_list_table {
   .closed {
     background-color: @grey6;
   }
 }
 
 
 input {
 	&.disabled {
 		opacity: .5;
 	}
 }
 
 // remove extra padding in firefox
 input::-moz-focus-inner { border:0; padding:0 }
 
 .adjacent input {
 	margin-bottom: @padding;
 }
 
 .permissions_boxes {
 	display: block;
 }
 
 //TODO: lisa: this should be in tables
 .show_more_col {
     width: 20px;
 }
 
 //FORMS
 
 .medium-inline,
 input#description.medium-inline {
 	display: inline;
 	width: @medium-inline-input-width;
 	min-width: 100px;
 }
 
 select {
 	//reset
 	-webkit-appearance: none;
 	-moz-appearance: none;
 
 	display: inline-block;
 	height: 28px;
 	width: auto;
 	margin: 0 @padding @padding 0;
 	padding: 0 18px 0 8px;
 	line-height:1em;
 	font-size: @basefontsize;
 	border: @border-thickness solid @rcblue;
 	background:white url("../images/dt-arrow-dn.png") no-repeat 100% 50%;
 	color: @rcblue;
 
 	&:after {
 		content: "\00A0\25BE";
 	}
 
 	&:focus {
 		outline: none;
 	}
 }
 
 option {
 	&:focus {
 		outline: none;
 	}
 }
 
 input,
 textarea {
 	padding: @input-padding;
 	border: @input-border-thickness solid @border-highlight-color;
 	.border-radius (@border-radius);
 	font-family: @text-light;
 	font-size: @basefontsize;
 
 	&.input-sm {
 		padding: 5px;
 	}
 
 	&#description {
 		min-width: @input-description-minwidth;
 		min-height: 1em;
 		padding: 10px;
 	}
 }
 
 .field-sm {
     input,
     textarea {
         padding: 5px;
     }
 }
 
 textarea {
 	display: block;
 	clear: both;
 	width: 100%;
 	min-height: 100px;
 	margin-bottom: @padding;
     .box-sizing(border-box);
     overflow: auto;
 }
 
 label {
 	font-family: @text-light;
 }
 
 // GRAVATARS
 // centers gravatar on username to the right
 
 .gravatar {
     display: inline;
     min-width: 16px;
     min-height: 16px;
     margin: -5px 0;
     padding: 0;
     line-height: 1em;
     border: 1px solid @grey4;
     box-sizing: content-box;
 
     &.gravatar-large {
         margin: -0.5em .25em -0.5em 0;
     }
 
     & + .user {
         display: inline;
         margin: 0;
         padding: 0 0 0 .17em;
         line-height: 1em;
     }
 }
 
 .user-inline-data {
     display: inline-block;
     float: left;
     padding-left: .5em;
     line-height: 1.3em;
 }
 
 .rc-user { // gravatar + user wrapper
     float: left;
     position: relative;
     min-width: 100px;
     max-width: 200px;
     min-height: (@gravatar-size + @border-thickness * 2); // account for border
     display: block;
     padding: 0 0 0 (@gravatar-size  + @basefontsize/2 + @border-thickness * 2);
 
 
     .gravatar {
         display: block;
         position: absolute;
         top: 0;
         left: 0;
         min-width:  @gravatar-size;
         min-height: @gravatar-size;
         margin: 0;
     }
 
     .user {
         display: block;
         max-width: 175px;
         padding-top: 2px;
         overflow: hidden;
         text-overflow: ellipsis;
     }
 }
 
 .gist-gravatar,
 .journal_container {
     .gravatar-large {
         margin: 0 .5em -10px 0;
     }
 }
 
 
 // ADMIN SETTINGS
 
 // Tag Patterns
 .tag_patterns {
 	.tag_input {
 		margin-bottom: @padding;
 	}
 }
 
 .locked_input {
     position: relative;
 
     input {
         display: inline;
         margin: 3px 5px 0px 0px;
     }
 
     br {
         display: none;
     }
 
     .error-message {
         float: left;
         width: 100%;
     }
 
     .lock_input_button {
         display: inline;
     }
 
     .help-block {
         clear: both;
     }
 }
 
 // Notifications
 
 .notifications_buttons {
 	margin: 0 0 @space 0;
 	padding: 0;
 
 	.btn {
 		display: inline-block;
 	}
 }
 
 .notification-list {
 
 	div {
 		display: inline-block;
 		vertical-align: middle;
 	}
 
 	.container {
 		display: block;
 		margin: 0 0 @padding 0;
 	}
 
 	.delete-notifications {
 		margin-left: @padding;
 		text-align: right;
         cursor: pointer;
 	}
 
 	.read-notifications {
 		margin-left: @padding/2;
 		text-align: right;
 		width: 35px;
         cursor: pointer;
 	}
 
 	.icon-minus-sign {
 		color: @alert2;
 	}
 
 	.icon-ok-sign {
 		color: @alert1;
 	}
 }
 
 .user_settings {
 	float: left;
 	clear: both;
 	display: block;
 	width: 100%;
 
 	.gravatar_box {
 		margin-bottom: @padding;
 
 		&:after {
 			content: " ";
 			clear: both;
 			width: 100%;
 		}
 	}
 
 	.fields .field {
 		clear: both;
 	}
 }
 
 .advanced_settings {
 	margin-bottom: @space;
 
 	.help-block {
 		margin-left: 0;
 	}
 
 	button + .help-block {
 		margin-top: @padding;
 	}
 }
 
 // admin settings radio buttons and labels
 .label-2 {
 	float: left;
 	width: @label2-width;
 
 	label {
 		color: @grey1;
 	}
 }
 .checkboxes {
 	float: left;
 	width: @checkboxes-width;
 	margin-bottom: @padding;
 
 	.checkbox {
 		width: 100%;
 
 		label {
 			margin: 0;
 			padding: 0;
 		}
 	}
 
 	.checkbox + .checkbox {
 		display: inline-block;
 	}
 
 	label {
 		margin-right: 1em;
 	}
 }
 
 // CHANGELOG
 .container_header {
     float: left;
 	display: block;
 	width: 100%;
 	margin: @padding 0 @padding;
 
     #filter_changelog {
         float: left;
         margin-right: @padding;
     }
 
     .breadcrumbs_light {
         display: inline-block;
     }
 }
 
 .info_box {
 	float: right;
 }
 
 
 #graph_nodes {
     padding-top: 43px;
 }
 
 #graph_content{
 
     // adjust for table headers so that graph renders properly
     //           #graph_nodes padding - table cell padding
     padding-top: (@space - (@basefontsize * 2.4));
 
     &.graph_full_width {
         width: 100%;
         max-width: 100%;
     }
 }
 
 #graph {
     .flag_status {
         margin: 0;
     }
 
     .pagination-left {
         float: left;
         clear: both;
     }
 
     .log-container {
         max-width: 345px;
 
         .message{
             max-width: 340px;
         }
     }
 
     .graph-col-wrapper {
         padding-left: 110px;
 
         #graph_nodes {
             width: 100px;
             margin-left: -110px;
             float: left;
             clear: left;
         }
     }
 
     .load-more-commits {
         text-align: center;
     }
     .load-more-commits:hover {
         background-color: @grey7;
     }
     .load-more-commits {
       a {
         display: block;
       }
     }
 }
 
 #filter_changelog {
     float: left;
 }
 
 
 //--- THEME ------------------//
 
 #logo {
 	float: left;
 	margin: 9px 0 0 0;
 
     .header {
     	background-color: transparent;
     }
 
     a {
     	display: inline-block;
     }
 
     img {
     	height:30px;
     }
 }
 
 .logo-wrapper {
 	float:left;
 }
 
 .branding{
 	float: left;
 	padding: 9px 2px;
 	line-height: 1em;
 	font-size: @navigation-fontsize;
 }
 
 img {
 	border: none;
 	outline: none;
 }
  user-profile-header
 label {
 
     input[type="checkbox"] {
         margin-right: 1em;
     }
     input[type="radio"] {
         margin-right: 1em;
     }
 }
 
 .flag_status {
     margin: 2px 8px 6px 2px;
     &.under_review {
         .circle(5px, @alert3);
     }
     &.approved {
         .circle(5px, @alert1);
     }
     &.rejected,
     &.forced_closed{
         .circle(5px, @alert2);
     }
     &.not_reviewed {
         .circle(5px, @grey5);
     }
 }
 
 .flag_status_comment_box {
 	margin: 5px 6px 0px 2px;
 }
 .test_pattern_preview {
 	margin: @space 0;
 
 	p {
         margin-bottom: 0;
 		border-bottom: @border-thickness solid @border-default-color;
 		color: @grey3;
 	}
 
 	.btn {
 		margin-bottom: @padding;
 	}
 }
 #test_pattern_result {
     display: none;
     &:extend(pre);
     padding: .9em;
     color: @grey3;
     background-color: @grey7;
     border-right: @border-thickness solid @border-default-color;
     border-bottom: @border-thickness solid @border-default-color;
     border-left: @border-thickness solid @border-default-color;
 }
 
 #repo_vcs_settings {
     #inherit_overlay_vcs_default {
         display: none;
     }
     #inherit_overlay_vcs_custom {
         display: custom;
     }
     &.inherited {
         #inherit_overlay_vcs_default {
             display: block;
         }
         #inherit_overlay_vcs_custom {
             display: none;
         }
     }
 }
 
 .issue-tracker-link {
 	color: @rcblue;
 }
 
 // Issue Tracker Table Show/Hide
 #repo_issue_tracker {
     #inherit_overlay {
         display: none;
     }
     #custom_overlay {
         display: custom;
     }
     &.inherited {
         #inherit_overlay {
             display: block;
         }
         #custom_overlay {
             display: none;
         }
     }
 }
 table.issuetracker {
     &.readonly {
         tr, td {
             color: @grey3;
         }
     }
     .edit {
         display: none;
     }
     .editopen {
         .edit {
             display: inline;
         }
         .entry {
             display: none;
         }
     }
     tr td.td-action {
         min-width: 117px;
     }
     td input {
         max-width: none;
         min-width: 30px;
         width: 80%;
     }
     .issuetracker_pref input {
         width: 40%;
     }
     input.edit_issuetracker_update {
         margin-right: 0;
         width: auto;
     }
 }
 
 table.integrations {
     .td-icon {
         width: 20px;
         .integration-icon {
             height: 20px;
             width: 20px;
         }
     }
 }
 
 .integrations {
     a.integration-box {
         color: @text-color;
         &:hover {
             .panel {
                 background: #fbfbfb;
             }
         }
         .integration-icon {
           width: 30px;
           height: 30px;
           margin-right: 20px;
           float: left;
         }
 
         .panel-body {
             padding: 10px;
         }
         .panel {
             margin-bottom: 10px;
         }
         h2 {
             display: inline-block;
             margin: 0;
             min-width: 140px;
         }
     }
 }
 
 //Permissions Settings
 #add_perm {
     margin: 0 0 @padding;
 	cursor: pointer;
 }
 
 .perm_ac {
     input {
         width: 95%;
     }
 }
 
 .autocomplete-suggestions {
     width: auto !important; // overrides autocomplete.js
     margin: 0;
     border: @border-thickness solid @rcblue;
     border-radius: @border-radius;
     color: @rcblue;
     background-color: white;
 }
 .autocomplete-selected {
     background: #F0F0F0;
 }
 .ac-container-wrap {
 	margin: 0;
 	padding: 8px;
 	border-bottom: @border-thickness solid @rclightblue;
 	list-style-type: none;
 	cursor: pointer;
 
 		&:hover {
 			background-color: @rclightblue;
 	}
 
 	img {
         height: @gravatar-size;
         width: @gravatar-size;
 		margin-right: 1em;
 	}
 
 	strong {
 		font-weight: normal;
 	}
 }
 
 // Settings Dropdown
 .user-menu .container {
     padding: 0 4px;
     margin: 0;
 }
 
 .user-menu .gravatar {
     cursor: pointer;
 }
 
 .codeblock {
 	margin-bottom: @padding;
     clear: both;
 
     .stats{
         overflow: hidden;
     }
 
     .message{
         textarea{
             margin: 0;
         }
     }
 
     .code-header {
     	.stats {
             line-height: 2em;
 
     		.revision_id {
     			margin-left: 0;
     		}
 			.buttons {
                 padding-right: 0;
 			}
     	}
 
         .item{
             margin-right: 0.5em;
         }
     }
 
     #editor_container{
         position: relative;
         margin: @padding;
     }
 }
 
 #file_history_container {
     display: none;
 }
 
 .file-history-inner {
     margin-bottom: 10px;
 }
 
 // Pull Requests
 .summary-details {
     width: 72%;
 }
 .pr-summary {
     border-bottom: @border-thickness solid @grey5;
     margin-bottom: @space;
 }
 .reviewers-title {
     width: 25%;
     min-width: 200px;
 }
 .reviewers {
     width: 25%;
     min-width: 200px;
 }
 .reviewers ul li {
     position: relative;
     width: 100%;
     margin-bottom: 8px;
 }
 
 .reviewer_entry {
   min-height: 55px;
 }
 
 .reviewers_member {
     width: 100%;
     overflow: auto;
 }
 .reviewer_reason {
     padding-left: 20px;
 }
 .reviewer_status {
     display: inline-block;
     vertical-align: top;
     width: 7%;
     min-width: 20px;
     height: 1.2em;
     margin-top: 3px;
     line-height: 1em;
 }
 
 .reviewer_name {
     display: inline-block;
     max-width: 83%;
     padding-right: 20px;
     vertical-align: middle;
     line-height: 1;
 
     .rc-user {
         min-width: 0;
         margin: -2px 1em 0 0;
     }
 
     .reviewer {
         float: left;
     }
 }
 
 .reviewer_member_mandatory,
 .reviewer_member_mandatory_remove,
 .reviewer_member_remove {
     position: absolute;
     right: 0;
     top: 0;
     width: 16px;
     margin-bottom: 10px;
     padding: 0;
     color: black;
 }
 
 .reviewer_member_mandatory_remove {
   color: @grey4;
 }
 
 .reviewer_member_mandatory {
   padding-top:20px;
 }
 
 .reviewer_member_status {
     margin-top: 5px;
 }
 .pr-summary #summary{
     width: 100%;
 }
 .pr-summary .action_button:hover {
     border: 0;
     cursor: pointer;
 }
 .pr-details-title {
     padding-bottom: 8px;
     border-bottom: @border-thickness solid @grey5;
 
     .action_button.disabled {
         color: @grey4;
         cursor: inherit;
     }
     .action_button {
         color: @rcblue;
     }
 }
 .pr-details-content {
     margin-top: @textmargin;
     margin-bottom: @textmargin;
 }
 .pr-description {
     white-space:pre-wrap;
 }
 
 .pr-reviewer-rules {
    padding: 10px 0px 20px 0px;
 }
 
 .group_members {
     margin-top: 0;
     padding: 0;
     list-style: outside none none;
 
     img {
         height: @gravatar-size;
         width: @gravatar-size;
         margin-right: .5em;
         margin-left: 3px;
     }
 
     .to-delete {
         .user {
           text-decoration: line-through;
         }
     }
 }
 
 .compare_view_commits_title {
   .disabled {
     cursor: inherit;
     &:hover{
       background-color: inherit;
       color: inherit;
     }
   }
 }
 
 .subtitle-compare {
   margin: -15px 0px 0px 0px;
 }
 
 .comments-summary-td {
   border-top: 1px dashed @grey5;
 }
 
 // new entry in group_members
 .td-author-new-entry {
   background-color: rgba(red(@alert1), green(@alert1), blue(@alert1), 0.3);
 }
 
 .usergroup_member_remove {
     width: 16px;
     margin-bottom: 10px;
     padding: 0;
     color: black !important;
     cursor: pointer;
 }
 
 .reviewer_ac .ac-input {
     width: 92%;
     margin-bottom: 1em;
 }
 
 .compare_view_commits tr{
     height: 20px;
 }
 .compare_view_commits td {
     vertical-align: top;
     padding-top: 10px;
 }
 .compare_view_commits .author {
     margin-left: 5px;
 }
 
 .compare_view_commits {
   .color-a {
     color: @alert1;
   }
 
   .color-c {
     color: @color3;
   }
 
   .color-r {
     color: @color5;
   }
 
   .color-a-bg {
     background-color: @alert1;
   }
 
   .color-c-bg {
     background-color: @alert3;
   }
 
   .color-r-bg {
     background-color: @alert2;
   }
 
   .color-a-border {
     border: 1px solid @alert1;
   }
 
   .color-c-border {
     border: 1px solid @alert3;
   }
 
   .color-r-border {
     border: 1px solid @alert2;
   }
 
   .commit-change-indicator {
     width: 15px;
     height: 15px;
     position: relative;
     left: 15px;
   }
 
   .commit-change-content {
     text-align: center;
     vertical-align: middle;
     line-height: 15px;
   }
 }
 
 .compare_view_files {
     width: 100%;
 
     td {
         vertical-align: middle;
     }
 }
 
 .compare_view_filepath {
     color: @grey1;
 }
 
 .show_more {
     display: inline-block;
     position: relative;
     vertical-align: middle;
     width: 4px;
     height: @basefontsize;
 
     &:after {
         content: "\00A0\25BE";
         display: inline-block;
         width:10px;
         line-height: 5px;
         font-size: 12px;
         cursor: pointer;
     }
 }
 
 .journal_more .show_more {
     display: inline;
 
     &:after {
         content: none;
     }
 }
 
 .open .show_more:after,
 .select2-dropdown-open .show_more:after {
     .rotate(180deg);
     margin-left: 4px;
 }
 
 
 .compare_view_commits .collapse_commit:after {
     cursor: pointer;
     content: "\00A0\25B4";
     margin-left: -3px;
     font-size: 17px;
     color: @grey4;
 }
 
 .diff_links {
     margin-left: 8px;
 }
 
 div.ancestor {
     margin: -30px 0px;
 }
 
 .cs_icon_td input[type="checkbox"] {
     display: none;
 }
 
 .cs_icon_td .expand_file_icon:after {
     cursor: pointer;
     content: "\00A0\25B6";
     font-size: 12px;
     color: @grey4;
 }
 
 .cs_icon_td .collapse_file_icon:after {
     cursor: pointer;
     content: "\00A0\25BC";
     font-size: 12px;
     color: @grey4;
 }
 
 /*new binary
 NEW_FILENODE = 1
 DEL_FILENODE = 2
 MOD_FILENODE = 3
 RENAMED_FILENODE = 4
 COPIED_FILENODE = 5
 CHMOD_FILENODE = 6
 BIN_FILENODE = 7
 */
 .cs_files_expand {
     font-size: @basefontsize + 5px;
     line-height: 1.8em;
     float: right;
 }
 
 .cs_files_expand span{
     color: @rcblue;
     cursor: pointer;
 }
 .cs_files {
     clear: both;
 	padding-bottom: @padding;
 
     .cur_cs {
         margin: 10px 2px;
         font-weight: bold;
     }
 
     .node {
         float: left;
     }
 
     .changes {
         float: right;
         color: white;
         font-size: @basefontsize - 4px;
         margin-top: 4px;
         opacity: 0.6;
         filter: Alpha(opacity=60); /* IE8 and earlier */
 
         .added {
             background-color: @alert1;
             float: left;
             text-align: center;
         }
 
         .deleted {
             background-color: @alert2;
             float: left;
             text-align: center;
         }
 
         .bin {
             background-color: @alert1;
             text-align: center;
         }
 
         /*new binary*/
         .bin.bin1 {
             background-color: @alert1;
             text-align: center;
         }
 
         /*deleted binary*/
         .bin.bin2 {
             background-color: @alert2;
             text-align: center;
         }
 
         /*mod binary*/
         .bin.bin3 {
             background-color: @grey2;
             text-align: center;
         }
 
         /*rename file*/
         .bin.bin4 {
             background-color: @alert4;
             text-align: center;
         }
 
         /*copied file*/
         .bin.bin5 {
             background-color: @alert4;
             text-align: center;
         }
 
         /*chmod file*/
         .bin.bin6 {
             background-color: @grey2;
             text-align: center;
         }
     }
 }
 
 .cs_files .cs_added, .cs_files .cs_A,
 .cs_files .cs_added, .cs_files .cs_M,
 .cs_files .cs_added, .cs_files .cs_D {
     height: 16px;
     padding-right: 10px;
     margin-top: 7px;
     text-align: left;
 }
 
 .cs_icon_td {
   min-width: 16px;
   width: 16px;
 }
 
 .pull-request-merge {
     border: 1px solid @grey5;
     padding: 10px 0px 20px;
     margin-top: 10px;
     margin-bottom: 20px;
 }
 
 .pull-request-merge ul {
     padding: 0px 0px;
 }
 
 .pull-request-merge li:before{
     content:none;
 }
 
 .pull-request-merge .pull-request-wrap {
     height: auto;
     padding: 0px 0px;
     text-align: right;
 }
 
 .pull-request-merge span {
     margin-right: 5px;
 }
 
 .pull-request-merge-actions {
     height: 30px;
     padding: 0px 0px;
 }
 
 .merge-status {
   margin-right: 5px;
 }
 
 .merge-message {
     font-size: 1.2em
 }
 
 .merge-message.success i,
 .merge-icon.success i {
     color:@alert1;
 }
 
 .merge-message.warning i,
 .merge-icon.warning i {
   color: @alert3;
 }
 
 .merge-message.error i,
 .merge-icon.error i  {
     color:@alert2;
 }
 
 .pr-versions {
     font-size: 1.1em;
 
     table {
       padding: 0px 5px;
     }
 
     td {
       line-height: 15px;
     }
 
     .flag_status {
         margin: 0;
     }
 
     .compare-radio-button {
       position: relative;
       top: -3px;
     }
 }
 
 
 #close_pull_request {
     margin-right: 0px;
 }
 
 .empty_data {
     color: @grey4;
 }
 
 #changeset_compare_view_content {
     margin-bottom: @space;
     clear: both;
     width: 100%;
     box-sizing: border-box;
     .border-radius(@border-radius);
 
     .help-block {
         margin: @padding 0;
         color: @text-color;
         &.pre-formatting {
             white-space: pre;
         }
     }
 
     .empty_data {
         margin: @padding 0;
     }
 
     .alert {
         margin-bottom: @space;
     }
 }
 
 .table_disp {
 	.status {
 		width: auto;
 
 		.flag_status {
 			float: left;
 		}
 	}
 }
 
+
+.creation_in_progress {
+  color: @grey4
+}
+
 .status_box_menu {
     margin: 0;
 }
 
 .notification-table{
 	margin-bottom: @space;
 	display: table;
 	width: 100%;
 
 	.container{
 		display: table-row;
 
 		.notification-header{
 			border-bottom: @border-thickness solid @border-default-color;
 		}
 
 		.notification-subject{
 			display: table-cell;
 		}
 	}
 }
 
 // Notifications
 .notification-header{
 	display: table;
 	width: 100%;
 	padding: floor(@basefontsize/2) 0;
     line-height: 1em;
 
 	.desc, .delete-notifications, .read-notifications{
 		display: table-cell;
 		text-align: left;
 	}
 
 	.desc{
 		width: 1163px;
 	}
 
 	.delete-notifications, .read-notifications{
 		width: 35px;
 		min-width: 35px; //fixes when only one button is displayed
 	}
 }
 
 .notification-body {
     .markdown-block,
 	.rst-block {
 		padding: @padding 0;
 	}
 
 	.notification-subject {
 		padding: @textmargin 0;
 		border-bottom: @border-thickness solid @border-default-color;
 	}
 }
 
 
 .notifications_buttons{
 	float: right;
 }
 
 #notification-status{
   display: inline;
 }
 
 // Repositories
 
 #summary.fields{
 	display: table;
 
 	.field{
 		display: table-row;
 
 		.label-summary{
 			display: table-cell;
 			min-width: @label-summary-minwidth;
 			padding-top: @padding/2;
 			padding-bottom: @padding/2;
 			padding-right: @padding/2;
 		}
 
 		.input{
 			display: table-cell;
 			padding: @padding/2;
 
 			input{
 				min-width: 29em;
 				padding:  @padding/4;
 			}
 		}
 		.statistics, .downloads{
 			.disabled{
 				color: @grey4;
 			}
 		}
 	}
 }
 
 #summary{
 	width: 70%;
 }
 
 
 // Journal
 .journal.title {
 	h5 {
 		float: left;
 		margin: 0;
 		width: 70%;
 	}
 
 	ul {
 		float: right;
 		display: inline-block;
 		margin: 0;
 		width: 30%;
 		text-align: right;
 
 		li {
 			display: inline;
 			font-size: @journal-fontsize;
             line-height: 1em;
 
             &:before { content: none; }
 		}
 	}
 }
 
 .filterexample {
     position: absolute;
     top: 95px;
     left: @contentpadding;
     color: @rcblue;
     font-size: 11px;
     font-family: @text-regular;
     cursor: help;
 
     &:hover {
         color: @rcdarkblue;
     }
 
     @media (max-width:768px) {
         position: relative;
         top: auto;
         left: auto;
         display: block;
     }
 }
 
 
 #journal{
 	margin-bottom: @space;
 
 	.journal_day{
 		margin-bottom: @textmargin/2;
 		padding-bottom: @textmargin/2;
 		font-size: @journal-fontsize;
 		border-bottom: @border-thickness solid @border-default-color;
 	}
 
 	.journal_container{
 		margin-bottom: @space;
 
 		.journal_user{
 			display: inline-block;
 		}
 		.journal_action_container{
 			display: block;
 			margin-top: @textmargin;
 
 			div{
 				display: inline;
 			}
 
 			div.journal_action_params{
 				display: block;
 			}
 
 			div.journal_repo:after{
 				content: "\A";
 				white-space: pre;
 			}
 
 			div.date{
 				display: block;
 				margin-bottom: @textmargin;
 			}
 		}
 	}
 }
 
 // Files
 .edit-file-title {
     border-bottom: @border-thickness solid @border-default-color;
 
     .breadcrumbs {
         margin-bottom: 0;
     }
 }
 
 .edit-file-fieldset {
     margin-top: @sidebarpadding;
 
     .fieldset {
         .left-label {
             width: 13%;
         }
         .right-content {
             width: 87%;
             max-width: 100%;
         }
         .filename-label {
             margin-top: 13px;
         }
         .commit-message-label {
             margin-top: 4px;
         }
         .file-upload-input {
             input {
                 display: none;
             }
           margin-top: 10px;
         }
         .file-upload-label {
           margin-top: 10px;
         }
         p {
             margin-top: 5px;
         }
 
     }
     .custom-path-link {
         margin-left: 5px;
     }
     #commit {
         resize: vertical;
     }
 }
 
 .delete-file-preview {
     max-height: 250px;
 }
 
 .new-file,
 #filter_activate,
 #filter_deactivate {
     float: left;
     margin: 0 0 0 15px;
 }
 
 h3.files_location{
     line-height: 2.4em;
 }
 
 .browser-nav {
 	display: table;
 	margin-bottom: @space;
 
 
 	.info_box {
 		display: inline-table;
 		height: 2.5em;
 
         .browser-cur-rev, .info_box_elem {
 			display: table-cell;
 			vertical-align: middle;
 		}
 
 		.info_box_elem {
 			border-top: @border-thickness solid @rcblue;
 			border-bottom: @border-thickness solid @rcblue;
 
             #at_rev, a {
                 padding: 0.6em 0.9em;
                 margin: 0;
                 .box-shadow(none);
                 border: 0;
                 height: 12px;
             }
 
             input#at_rev {
                 max-width: 50px;
                 text-align: right;
             }
 
 			&.previous {
 				border: @border-thickness solid @rcblue;
                 .disabled {
                   color: @grey4;
                   cursor: not-allowed;
                 }
 			}
 
 			&.next {
 				border: @border-thickness solid @rcblue;
                 .disabled {
                   color: @grey4;
                   cursor: not-allowed;
                 }
 			}
 		}
 
 		.browser-cur-rev {
 
 			span{
                 margin: 0;
 				color: @rcblue;
                 height: 12px;
                 display: inline-block;
                 padding:  0.7em 1em ;
                 border: @border-thickness solid @rcblue;
                 margin-right: @padding;
 			}
 		}
 	}
 
 	.search_activate {
 		display: table-cell;
 		vertical-align: middle;
 
 		input, label{
 			margin: 0;
 			padding: 0;
 		}
 
 		input{
 			margin-left: @textmargin;
 		}
 
 	}
 }
 
 .browser-cur-rev{
 	margin-bottom: @textmargin;
 }
 
 #node_filter_box_loading{
 	.info_text;
 }
 
 .browser-search {
 	margin: -25px 0px 5px 0px;
 }
 
 .node-filter {
   font-size: @repo-title-fontsize;
   padding: 4px 0px 0px 0px;
 
   .node-filter-path {
       float: left;
       color: @grey4;
     }
     .node-filter-input {
         float: left;
         margin: -2px 0px 0px 2px;
         input {
             padding: 2px;
             border: none;
             font-size: @repo-title-fontsize;
         }
     }
 }
 
 
 .browser-result{
 	td a{
 		margin-left: 0.5em;
 		display: inline-block;
 
 		em{
 			font-family: @text-bold;
 		}
 	}
 }
 
 .browser-highlight{
 	background-color: @grey5-alpha;
 }
 
 
 // Search
 
 .search-form{
     #q {
         width: @search-form-width;
     }
 	.fields{
 		margin: 0 0 @space;
 	}
 
 	label{
 		display: inline-block;
 		margin-right: @textmargin;
 		padding-top: 0.25em;
 	}
 
 
 	.results{
 		clear: both;
 		margin: 0 0 @padding;
 	}
 }
 
 div.search-feedback-items {
 	display: inline-block;
 	padding:0px 0px 0px 96px;
 }
 
 div.search-code-body {
     background-color: #ffffff; padding: 5px 0 5px 10px;
     pre {
         .match { background-color: #faffa6;}
         .break { display: block; width: 100%; background-color: #DDE7EF; color: #747474; }
     }
 }
 
 .expand_commit.search {
     .show_more.open {
         height: auto;
         max-height: none;
     }
 }
 
 .search-results {
 
     h2 {
         margin-bottom: 0;
     }
     .codeblock {
         border: none;
         background: transparent;
     }
 
     .codeblock-header {
         border: none;
         background: transparent;
     }
 
     .code-body {
         border: @border-thickness solid @border-default-color;
         .border-radius(@border-radius);
     }
 
     .td-commit {
         &:extend(pre);
         border-bottom: @border-thickness solid @border-default-color;
     }
 
     .message {
         height: auto;
         max-width: 350px;
         white-space: normal;
         text-overflow: initial;
         overflow: visible;
 
         .match { background-color: #faffa6;}
         .break { background-color: #DDE7EF; width: 100%; color: #747474; display: block; }
     }
 
 }
 
 table.rctable td.td-search-results div {
     max-width: 100%;
 }
 
 #tip-box, .tip-box{
 	padding: @menupadding/2;
 	display: block;
 	border: @border-thickness solid @border-highlight-color;
 	.border-radius(@border-radius);
 	background-color: white;
     z-index: 99;
     white-space: pre-wrap;
 }
 
 #linktt {
     width: 79px;
 }
 
 #help_kb .modal-content{
 	max-width: 750px;
 	margin: 10% auto;
 
 	table{
 		td,th{
 			border-bottom: none;
 			line-height: 2.5em;
 		}
 		th{
 			padding-bottom: @textmargin/2;
 		}
 		td.keys{
 			text-align: center;
 		}
 	}
 
 	.block-left{
 		width: 45%;
 		margin-right: 5%;
 	}
 	.modal-footer{
 		clear: both;
 	}
 	.key.tag{
 		padding: 0.5em;
 		background-color: @rcblue;
 		color: white;
 		border-color: @rcblue;
 		.box-shadow(none);
 	}
 }
 
 
 
 //--- IMPORTS FOR REFACTORED STYLES ------------------//
 
 @import 'statistics-graph';
 @import 'tables';
 @import 'forms';
 @import 'diff';
 @import 'summary';
 @import 'navigation';
 
 //--- SHOW/HIDE SECTIONS --//
 
 .btn-collapse {
     float: right;
     text-align: right;
     font-family: @text-light;
     font-size: @basefontsize;
     cursor: pointer;
     border: none;
     color: @rcblue;
 }
 
 table.rctable,
 table.dataTable {
     .btn-collapse {
         float: right;
         text-align: right;
     }
 }
 
 
 // TODO: johbo: Fix for IE10, this avoids that we see a border
 // and padding around checkboxes and radio boxes. Move to the right place,
 // or better: Remove this once we did the form refactoring.
 input[type=checkbox],
 input[type=radio] {
     padding: 0;
     border: none;
 }
 
 .toggle-ajax-spinner{
   height: 16px;
   width: 16px;
 }

rhodecode/public/js/rhodecode/routes.js

@@ -1,220 +1,222 b''
 
 /******************************************************************************
  *                                                                            *
  *                      DO NOT CHANGE THIS FILE MANUALLY                      *
  *                                                                            *
  *                                                                            *
  *        This file is automatically generated when the app starts up with    *
  *                         generate_js_files = true                           *
  *                                                                            *
  *  To add a route here pass jsroute=True to the route definition in the app  *
  *                                                                            *
  ******************************************************************************/
 function registerRCRoutes() {
     // routes registration
     pyroutes.register('new_repo', '/_admin/create_repository', []);
     pyroutes.register('edit_user', '/_admin/users/%(user_id)s/edit', ['user_id']);
     pyroutes.register('favicon', '/favicon.ico', []);
     pyroutes.register('robots', '/robots.txt', []);
     pyroutes.register('auth_home', '/_admin/auth*traverse', []);
     pyroutes.register('global_integrations_new', '/_admin/integrations/new', []);
     pyroutes.register('global_integrations_home', '/_admin/integrations', []);
     pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']);
     pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']);
     pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']);
     pyroutes.register('repo_group_integrations_home', '/%(repo_group_name)s/settings/integrations', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_list', '/%(repo_group_name)s/settings/integrations/%(integration)s', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_new', '/%(repo_group_name)s/settings/integrations/new', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_create', '/%(repo_group_name)s/settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_edit', '/%(repo_group_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']);
     pyroutes.register('repo_integrations_home', '/%(repo_name)s/settings/integrations', ['repo_name']);
     pyroutes.register('repo_integrations_list', '/%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_new', '/%(repo_name)s/settings/integrations/new', ['repo_name']);
     pyroutes.register('repo_integrations_create', '/%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_edit', '/%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']);
     pyroutes.register('ops_ping', '/_admin/ops/ping', []);
     pyroutes.register('ops_error_test', '/_admin/ops/error', []);
     pyroutes.register('ops_redirect_test', '/_admin/ops/redirect', []);
     pyroutes.register('admin_home', '/_admin', []);
     pyroutes.register('admin_audit_logs', '/_admin/audit_logs', []);
     pyroutes.register('pull_requests_global_0', '/_admin/pull_requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global_1', '/_admin/pull-requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global', '/_admin/pull-request/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('admin_settings_open_source', '/_admin/settings/open_source', []);
     pyroutes.register('admin_settings_vcs_svn_generate_cfg', '/_admin/settings/vcs/svn_generate_cfg', []);
     pyroutes.register('admin_settings_system', '/_admin/settings/system', []);
     pyroutes.register('admin_settings_system_update', '/_admin/settings/system/updates', []);
     pyroutes.register('admin_settings_sessions', '/_admin/settings/sessions', []);
     pyroutes.register('admin_settings_sessions_cleanup', '/_admin/settings/sessions/cleanup', []);
     pyroutes.register('admin_settings_process_management', '/_admin/settings/process_management', []);
     pyroutes.register('admin_settings_process_management_signal', '/_admin/settings/process_management/signal', []);
     pyroutes.register('admin_permissions_application', '/_admin/permissions/application', []);
     pyroutes.register('admin_permissions_application_update', '/_admin/permissions/application/update', []);
     pyroutes.register('admin_permissions_global', '/_admin/permissions/global', []);
     pyroutes.register('admin_permissions_global_update', '/_admin/permissions/global/update', []);
     pyroutes.register('admin_permissions_object', '/_admin/permissions/object', []);
     pyroutes.register('admin_permissions_object_update', '/_admin/permissions/object/update', []);
     pyroutes.register('admin_permissions_ips', '/_admin/permissions/ips', []);
     pyroutes.register('admin_permissions_overview', '/_admin/permissions/overview', []);
     pyroutes.register('admin_permissions_auth_token_access', '/_admin/permissions/auth_token_access', []);
     pyroutes.register('users', '/_admin/users', []);
     pyroutes.register('users_data', '/_admin/users_data', []);
     pyroutes.register('edit_user_auth_tokens', '/_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_add', '/_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_delete', '/_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']);
     pyroutes.register('edit_user_emails', '/_admin/users/%(user_id)s/edit/emails', ['user_id']);
     pyroutes.register('edit_user_emails_add', '/_admin/users/%(user_id)s/edit/emails/new', ['user_id']);
     pyroutes.register('edit_user_emails_delete', '/_admin/users/%(user_id)s/edit/emails/delete', ['user_id']);
     pyroutes.register('edit_user_ips', '/_admin/users/%(user_id)s/edit/ips', ['user_id']);
     pyroutes.register('edit_user_ips_add', '/_admin/users/%(user_id)s/edit/ips/new', ['user_id']);
     pyroutes.register('edit_user_ips_delete', '/_admin/users/%(user_id)s/edit/ips/delete', ['user_id']);
     pyroutes.register('edit_user_groups_management', '/_admin/users/%(user_id)s/edit/groups_management', ['user_id']);
     pyroutes.register('edit_user_groups_management_updates', '/_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']);
     pyroutes.register('edit_user_audit_logs', '/_admin/users/%(user_id)s/edit/audit', ['user_id']);
     pyroutes.register('user_groups', '/_admin/user_groups', []);
     pyroutes.register('user_groups_data', '/_admin/user_groups_data', []);
     pyroutes.register('user_group_members_data', '/_admin/user_groups/%(user_group_id)s/members', ['user_group_id']);
     pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []);
     pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []);
     pyroutes.register('channelstream_proxy', '/_channelstream', []);
     pyroutes.register('login', '/_admin/login', []);
     pyroutes.register('logout', '/_admin/logout', []);
     pyroutes.register('register', '/_admin/register', []);
     pyroutes.register('reset_password', '/_admin/password_reset', []);
     pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []);
     pyroutes.register('home', '/', []);
     pyroutes.register('user_autocomplete_data', '/_users', []);
     pyroutes.register('user_group_autocomplete_data', '/_user_groups', []);
     pyroutes.register('repo_list_data', '/_repos', []);
     pyroutes.register('goto_switcher_data', '/_goto_data', []);
     pyroutes.register('journal', '/_admin/journal', []);
     pyroutes.register('journal_rss', '/_admin/journal/rss', []);
     pyroutes.register('journal_atom', '/_admin/journal/atom', []);
     pyroutes.register('journal_public', '/_admin/public_journal', []);
     pyroutes.register('journal_public_atom', '/_admin/public_journal/atom', []);
     pyroutes.register('journal_public_atom_old', '/_admin/public_journal_atom', []);
     pyroutes.register('journal_public_rss', '/_admin/public_journal/rss', []);
     pyroutes.register('journal_public_rss_old', '/_admin/public_journal_rss', []);
     pyroutes.register('toggle_following', '/_admin/toggle_following', []);
+    pyroutes.register('repo_creating', '/%(repo_name)s/repo_creating', ['repo_name']);
+    pyroutes.register('repo_creating_check', '/%(repo_name)s/repo_creating_check', ['repo_name']);
     pyroutes.register('repo_summary_explicit', '/%(repo_name)s/summary', ['repo_name']);
     pyroutes.register('repo_summary_commits', '/%(repo_name)s/summary-commits', ['repo_name']);
     pyroutes.register('repo_commit', '/%(repo_name)s/changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_children', '/%(repo_name)s/changeset_children/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_parents', '/%(repo_name)s/changeset_parents/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_raw', '/%(repo_name)s/changeset-diff/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_patch', '/%(repo_name)s/changeset-patch/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_download', '/%(repo_name)s/changeset-download/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_data', '/%(repo_name)s/changeset-data/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_create', '/%(repo_name)s/changeset/%(commit_id)s/comment/create', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_preview', '/%(repo_name)s/changeset/%(commit_id)s/comment/preview', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_delete', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/delete', ['repo_name', 'commit_id', 'comment_id']);
     pyroutes.register('repo_commit_raw_deprecated', '/%(repo_name)s/raw-changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_archivefile', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']);
     pyroutes.register('repo_files_diff', '/%(repo_name)s/diff/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files_diff_2way_redirect', '/%(repo_name)s/diff-2way/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files', '/%(repo_name)s/files/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:default_path', '/%(repo_name)s/files/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_files:default_commit', '/%(repo_name)s/files', ['repo_name']);
     pyroutes.register('repo_files:rendered', '/%(repo_name)s/render/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated', '/%(repo_name)s/annotate/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated_previous', '/%(repo_name)s/annotate-previous/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_nodetree_full:default_path', '/%(repo_name)s/nodetree_full/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_files_nodelist', '/%(repo_name)s/nodelist/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_raw', '/%(repo_name)s/raw/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download', '/%(repo_name)s/download/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download:legacy', '/%(repo_name)s/rawfile/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_history', '/%(repo_name)s/history/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_authors', '/%(repo_name)s/authors/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_remove_file', '/%(repo_name)s/remove_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_delete_file', '/%(repo_name)s/delete_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_edit_file', '/%(repo_name)s/edit_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_update_file', '/%(repo_name)s/update_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_add_file', '/%(repo_name)s/add_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_create_file', '/%(repo_name)s/create_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']);
     pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']);
     pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_changelog', '/%(repo_name)s/changelog', ['repo_name']);
     pyroutes.register('repo_changelog_file', '/%(repo_name)s/changelog/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_changelog_elements', '/%(repo_name)s/changelog_elements', ['repo_name']);
     pyroutes.register('repo_compare_select', '/%(repo_name)s/compare', ['repo_name']);
     pyroutes.register('repo_compare', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']);
     pyroutes.register('tags_home', '/%(repo_name)s/tags', ['repo_name']);
     pyroutes.register('branches_home', '/%(repo_name)s/branches', ['repo_name']);
     pyroutes.register('bookmarks_home', '/%(repo_name)s/bookmarks', ['repo_name']);
     pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']);
     pyroutes.register('pullrequest_show_all_data', '/%(repo_name)s/pull-request-data', ['repo_name']);
     pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']);
     pyroutes.register('pullrequest_repo_destinations', '/%(repo_name)s/pull-request/repo-destinations', ['repo_name']);
     pyroutes.register('pullrequest_new', '/%(repo_name)s/pull-request/new', ['repo_name']);
     pyroutes.register('pullrequest_create', '/%(repo_name)s/pull-request/create', ['repo_name']);
     pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s/update', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_merge', '/%(repo_name)s/pull-request/%(pull_request_id)s/merge', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/delete', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/delete', ['repo_name', 'pull_request_id', 'comment_id']);
     pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
     pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']);
     pyroutes.register('edit_repo_advanced_delete', '/%(repo_name)s/settings/advanced/delete', ['repo_name']);
     pyroutes.register('edit_repo_advanced_locking', '/%(repo_name)s/settings/advanced/locking', ['repo_name']);
     pyroutes.register('edit_repo_advanced_journal', '/%(repo_name)s/settings/advanced/journal', ['repo_name']);
     pyroutes.register('edit_repo_advanced_fork', '/%(repo_name)s/settings/advanced/fork', ['repo_name']);
     pyroutes.register('edit_repo_caches', '/%(repo_name)s/settings/caches', ['repo_name']);
     pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']);
     pyroutes.register('repo_reviewers', '/%(repo_name)s/settings/review/rules', ['repo_name']);
     pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/settings/review/default-reviewers', ['repo_name']);
     pyroutes.register('repo_maintenance', '/%(repo_name)s/settings/maintenance', ['repo_name']);
     pyroutes.register('repo_maintenance_execute', '/%(repo_name)s/settings/maintenance/execute', ['repo_name']);
     pyroutes.register('strip', '/%(repo_name)s/settings/strip', ['repo_name']);
     pyroutes.register('strip_check', '/%(repo_name)s/settings/strip_check', ['repo_name']);
     pyroutes.register('strip_execute', '/%(repo_name)s/settings/strip_execute', ['repo_name']);
     pyroutes.register('rss_feed_home', '/%(repo_name)s/feed/rss', ['repo_name']);
     pyroutes.register('atom_feed_home', '/%(repo_name)s/feed/atom', ['repo_name']);
     pyroutes.register('repo_summary', '/%(repo_name)s', ['repo_name']);
     pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_name']);
     pyroutes.register('repo_group_home', '/%(repo_group_name)s', ['repo_group_name']);
     pyroutes.register('repo_group_home_slash', '/%(repo_group_name)s/', ['repo_group_name']);
     pyroutes.register('search', '/_admin/search', []);
     pyroutes.register('search_repo', '/%(repo_name)s/search', ['repo_name']);
     pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']);
     pyroutes.register('my_account_profile', '/_admin/my_account/profile', []);
     pyroutes.register('my_account_edit', '/_admin/my_account/edit', []);
     pyroutes.register('my_account_update', '/_admin/my_account/update', []);
     pyroutes.register('my_account_password', '/_admin/my_account/password', []);
     pyroutes.register('my_account_password_update', '/_admin/my_account/password/update', []);
     pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []);
     pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []);
     pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []);
     pyroutes.register('my_account_emails', '/_admin/my_account/emails', []);
     pyroutes.register('my_account_emails_add', '/_admin/my_account/emails/new', []);
     pyroutes.register('my_account_emails_delete', '/_admin/my_account/emails/delete', []);
     pyroutes.register('my_account_repos', '/_admin/my_account/repos', []);
     pyroutes.register('my_account_watched', '/_admin/my_account/watched', []);
     pyroutes.register('my_account_perms', '/_admin/my_account/perms', []);
     pyroutes.register('my_account_notifications', '/_admin/my_account/notifications', []);
     pyroutes.register('my_account_notifications_toggle_visibility', '/_admin/my_account/toggle_visibility', []);
     pyroutes.register('my_account_pullrequests', '/_admin/my_account/pull_requests', []);
     pyroutes.register('my_account_pullrequests_data', '/_admin/my_account/pull_requests/data', []);
     pyroutes.register('notifications_show_all', '/_admin/notifications', []);
     pyroutes.register('notifications_mark_all_read', '/_admin/notifications/mark_all_read', []);
     pyroutes.register('notifications_show', '/_admin/notifications/%(notification_id)s', ['notification_id']);
     pyroutes.register('notifications_update', '/_admin/notifications/%(notification_id)s/update', ['notification_id']);
     pyroutes.register('notifications_delete', '/_admin/notifications/%(notification_id)s/delete', ['notification_id']);
     pyroutes.register('my_account_notifications_test_channelstream', '/_admin/my_account/test_channelstream', []);
     pyroutes.register('gists_show', '/_admin/gists', []);
     pyroutes.register('gists_new', '/_admin/gists/new', []);
     pyroutes.register('gists_create', '/_admin/gists/create', []);
     pyroutes.register('gist_show', '/_admin/gists/%(gist_id)s', ['gist_id']);
     pyroutes.register('gist_delete', '/_admin/gists/%(gist_id)s/delete', ['gist_id']);
     pyroutes.register('gist_edit', '/_admin/gists/%(gist_id)s/edit', ['gist_id']);
     pyroutes.register('gist_edit_check_revision', '/_admin/gists/%(gist_id)s/edit/check_revision', ['gist_id']);
     pyroutes.register('gist_update', '/_admin/gists/%(gist_id)s/update', ['gist_id']);
     pyroutes.register('gist_show_rev', '/_admin/gists/%(gist_id)s/%(revision)s', ['gist_id', 'revision']);
     pyroutes.register('gist_show_formatted', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s', ['gist_id', 'revision', 'format']);
     pyroutes.register('gist_show_formatted_path', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s/%(f_path)s', ['gist_id', 'revision', 'format', 'f_path']);
     pyroutes.register('debug_style_home', '/_admin/debug_style', []);
     pyroutes.register('debug_style_template', '/_admin/debug_style/t/%(t_path)s', ['t_path']);
     pyroutes.register('apiv2', '/_admin/api', []);
 }

rhodecode/templates/admin/repos/repo_creating.mako

@@ -1,70 +1,77 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
-    ${_('%s Creating repository') % c.repo_name}
+    ${_('{} Creating repository').format(c.repo_name)}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
-    ${_('Creating repository')} ${c.repo}
+    ${_('Creating repository')} ${c.repo_name}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     <div id="progress-message">
         ${_('Repository "%(repo_name)s" is being created, you will be redirected when this process is finished.' % {'repo_name':c.repo_name})}
     </div>
 
     <div id="progress">
         <div class="progress progress-striped active">
           <div class="progress-bar progress-bar" role="progressbar"
                aria-valuenow="100" aria-valuemin="0" aria-valuemax="100">
           </div>
         </div>
     </div>
 </div>
 
 <script>
 (function worker() {
   var skipCheck = false;
-  var url = "${h.url('repo_check_home', repo_name=c.repo_name, repo=c.repo, task_id=c.task_id)}";
+  var url = "${h.route_path('repo_creating_check', repo_name=c.repo_name, _query=dict(task_id=c.task_id))}";
   $.ajax({
     url: url,
     complete: function(resp) {
         if (resp.status == 200) {
             var jsonResponse = resp.responseJSON;
 
             if (jsonResponse === undefined) {
                 setTimeout(function () {
                     // we might have a backend problem, try dashboard again
-                    window.location = "${h.route_path('repo_summary', repo_name = c.repo)}";
+                    window.location = "${h.route_path('repo_summary', repo_name = c.repo_name)}";
                 }, 3000);
             } else {
                 if (skipCheck || jsonResponse.result === true) {
                     // success, means go to dashboard
-                    window.location = "${h.route_path('repo_summary', repo_name = c.repo)}";
+                    window.location = "${h.route_path('repo_summary', repo_name = c.repo_name)}";
                 } else {
                     // Schedule the next request when the current one's complete
                     setTimeout(worker, 1000);
                 }
             }
         }
         else {
-            window.location = "${h.route_path('home')}";
+            var payload = {
+                message: {
+                    message: _gettext('Fetching repository state failed. Error code: {0} {1}. Try refreshing this page.').format(resp.status, resp.statusText),
+                    level: 'error',
+                    force: true
+                }
+            };
+            $.Topic('/notifications').publish(payload);
         }
     }
   });
 })();
 </script>
-</%def>
  No newline at end of file
+</%def>

rhodecode/templates/data_table/_dt_elements.mako

@@ -1,317 +1,319 b''
 ## DATA TABLE RE USABLE ELEMENTS
 ## usage:
 ## <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 <%namespace name="base" file="/base/base.mako"/>
 
 ## REPOSITORY RENDERERS
 <%def name="quick_menu(repo_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a title="${_('Summary')}" href="${h.route_path('repo_summary',repo_name=repo_name)}">
          <span>${_('Summary')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Changelog')}" href="${h.route_path('repo_changelog',repo_name=repo_name)}">
          <span>${_('Changelog')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Files')}" href="${h.route_path('repo_files:default_commit',repo_name=repo_name)}">
          <span>${_('Files')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Fork')}" href="${h.url('repo_fork_home',repo_name=repo_name)}">
          <span>${_('Fork')}</span>
          </a>
       </li>
     </ul>
   </div>
 </%def>
 
 <%def name="repo_name(name,rtype,rstate,private,fork_of,short_name=False,admin=False)">
     <%
     def get_name(name,short_name=short_name):
       if short_name:
         return name.split('/')[-1]
       else:
         return name
     %>
   <div class="${'repo_state_pending' if rstate == 'repo_state_pending' else ''} truncate">
     ##NAME
     <a href="${h.route_path('edit_repo',repo_name=name) if admin else h.route_path('repo_summary',repo_name=name)}">
 
     ##TYPE OF REPO
     %if h.is_hg(rtype):
         <span title="${_('Mercurial repository')}"><i class="icon-hg"></i></span>
     %elif h.is_git(rtype):
         <span title="${_('Git repository')}"><i class="icon-git"></i></span>
     %elif h.is_svn(rtype):
         <span title="${_('Subversion repository')}"><i class="icon-svn"></i></span>
     %endif
 
     ##PRIVATE/PUBLIC
     %if private and c.visual.show_private_icon:
       <i class="icon-lock" title="${_('Private repository')}"></i>
     %elif not private and c.visual.show_public_icon:
       <i class="icon-unlock-alt" title="${_('Public repository')}"></i>
     %else:
       <span></span>
     %endif
     ${get_name(name)}
     </a>
     %if fork_of:
       <a href="${h.route_path('repo_summary',repo_name=fork_of.repo_name)}"><i class="icon-code-fork"></i></a>
     %endif
     %if rstate == 'repo_state_pending':
-      <i class="icon-cogs" title="${_('Repository creating in progress...')}"></i>
+      <span class="creation_in_progress tooltip" title="${_('This repository is being created in a background task')}">
+          (${_('creating...')})
+      </span>
     %endif
   </div>
 </%def>
 
 <%def name="repo_desc(description)">
     <div class="truncate-wrap">${description}</div>
 </%def>
 
 <%def name="last_change(last_change)">
     ${h.age_component(last_change)}
 </%def>
 
 <%def name="revision(name,rev,tip,author,last_msg)">
   <div>
   %if rev >= 0:
       <code><a title="${h.tooltip('%s:\n\n%s' % (author,last_msg))}" class="tooltip" href="${h.route_path('repo_commit',repo_name=name,commit_id=tip)}">${'r%s:%s' % (rev,h.short_id(tip))}</a></code>
   %else:
       ${_('No commits yet')}
   %endif
   </div>
 </%def>
 
 <%def name="rss(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="atom(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="user_gravatar(email, size=16)">
   <div class="rc-user tooltip" title="${h.tooltip(h.author_string(email))}">
     ${base.gravatar(email, 16)}
   </div>
 </%def>
 
 <%def name="repo_actions(repo_name, super_user=True)">
   <div>
     <div class="grid_edit">
       <a href="${h.route_path('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">
         <i class="icon-pencil"></i>Edit</a>
     </div>
     <div class="grid_delete">
       ${h.secure_form(h.route_path('edit_repo_advanced_delete', repo_name=repo_name), method='POST', request=request)}
         ${h.submit('remove_%s' % repo_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo_name+"');")}
       ${h.end_form()}
     </div>
   </div>
 </%def>
 
 <%def name="repo_state(repo_state)">
   <div>
     %if repo_state == 'repo_state_pending':
         <div class="tag tag4">${_('Creating')}</div>
     %elif repo_state == 'repo_state_created':
         <div class="tag tag1">${_('Created')}</div>
     %else:
         <div class="tag alert2" title="${h.tooltip(repo_state)}">invalid</div>
     %endif
   </div>
 </%def>
 
 
 ## REPO GROUP RENDERERS
 <%def name="quick_repo_group_menu(repo_group_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">
          <span class="icon">
              <i class="icon-file-text"></i>
          </span>
          <span>${_('Summary')}</span>
          </a>
       </li>
 
     </ul>
   </div>
 </%def>
 
 <%def name="repo_group_name(repo_group_name, children_groups=None)">
   <div>
     <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">
     <i class="icon-folder-close" title="${_('Repository group')}"></i>
       %if children_groups:
           ${h.literal(' &raquo; '.join(children_groups))}
       %else:
           ${repo_group_name}
       %endif
   </a>
   </div>
 </%def>
 
 <%def name="repo_group_desc(description)">
     <div class="truncate-wrap">${description}</div>
 </%def>
 
 <%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">
  <div class="grid_edit">
     <a href="${h.url('edit_repo_group',group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
     ${h.secure_form(h.url('delete_repo_group', group_name=repo_group_name),method='delete')}
         ${h.submit('remove_%s' % repo_group_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_ungettext('Confirm to delete this group: %s with %s repository','Confirm to delete this group: %s with %s repositories',gr_count) % (repo_group_name, gr_count)+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_actions(user_id, username)">
  <div class="grid_edit">
    <a href="${h.url('edit_user',user_id=user_id)}" title="${_('Edit')}">
      <i class="icon-pencil"></i>Edit</a>
  </div>
  <div class="grid_delete">
   ${h.secure_form(h.url('delete_user', user_id=user_id),method='delete')}
     ${h.submit('remove_',_('Delete'),id="remove_user_%s" % user_id, class_="btn btn-link btn-danger",
     onclick="return confirm('"+_('Confirm to delete this user: %s') % username+"');")}
   ${h.end_form()}
  </div>
 </%def>
 
 <%def name="user_group_actions(user_group_id, user_group_name)">
  <div class="grid_edit">
     <a href="${h.url('edit_users_group', user_group_id=user_group_id)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
     ${h.secure_form(h.url('delete_users_group', user_group_id=user_group_id),method='delete')}
       ${h.submit('remove_',_('Delete'),id="remove_group_%s" % user_group_id, class_="btn btn-link btn-danger",
       onclick="return confirm('"+_('Confirm to delete this user group: %s') % user_group_name+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_name(user_id, username)">
     ${h.link_to(h.person(username, 'username_or_name_or_email'), h.url('edit_user', user_id=user_id))}
 </%def>
 
 <%def name="user_profile(username)">
     ${base.gravatar_with_user(username, 16)}
 </%def>
 
 <%def name="user_group_name(user_group_id, user_group_name)">
   <div>
   <a href="${h.url('edit_users_group', user_group_id=user_group_id)}">
     <i class="icon-group" title="${_('User group')}"></i> ${user_group_name}</a>
   </div>
 </%def>
 
 
 ## GISTS
 
 <%def name="gist_gravatar(full_contact)">
     <div class="gist_gravatar">
       ${base.gravatar(full_contact, 30)}
     </div>
 </%def>
 
 <%def name="gist_access_id(gist_access_id, full_contact)">
     <div>
       <b>
         <a href="${h.route_path('gist_show', gist_id=gist_access_id)}">gist: ${gist_access_id}</a>
       </b>
     </div>
 </%def>
 
 <%def name="gist_author(full_contact, created_on, expires)">
     ${base.gravatar_with_user(full_contact, 16)}
 </%def>
 
 
 <%def name="gist_created(created_on)">
     <div class="created">
       ${h.age_component(created_on, time_is_local=True)}
     </div>
 </%def>
 
 <%def name="gist_expires(expires)">
     <div class="created">
           %if expires == -1:
             ${_('never')}
           %else:
             ${h.age_component(h.time_to_utcdatetime(expires))}
           %endif
     </div>
 </%def>
 
 <%def name="gist_type(gist_type)">
     %if gist_type != 'public':
       <div class="tag">${_('Private')}</div>
     %endif
 </%def>
 
 <%def name="gist_description(gist_description)">
   ${gist_description}
 </%def>
 
 
 ## PULL REQUESTS GRID RENDERERS
 
 <%def name="pullrequest_target_repo(repo_name)">
     <div class="truncate">
       ${h.link_to(repo_name,h.route_path('repo_summary',repo_name=repo_name))}
     </div>
 </%def>
 <%def name="pullrequest_status(status)">
     <div class="${'flag_status %s' % status} pull-left"></div>
 </%def>
 
 <%def name="pullrequest_title(title, description)">
     ${title} <br/>
     ${h.shorter(description, 40)}
 </%def>
 
 <%def name="pullrequest_comments(comments_nr)">
     <i class="icon-comment"></i> ${comments_nr}
 </%def>
 
 <%def name="pullrequest_name(pull_request_id, target_repo_name, short=False)">
     <a href="${h.route_path('pullrequest_show',repo_name=target_repo_name,pull_request_id=pull_request_id)}">
       % if short:
         #${pull_request_id}
       % else:
         ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
       % endif
     </a>
 </%def>
 
 <%def name="pullrequest_updated_on(updated_on)">
     ${h.age_component(h.time_to_utcdatetime(updated_on))}
 </%def>
 
 <%def name="pullrequest_author(full_contact)">
     ${base.gravatar_with_user(full_contact, 16)}
 </%def>

rhodecode/tests/functional/test_admin_repo_groups.py

@@ -1,229 +1,227 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 os
 
 from rhodecode.lib import helpers as h
 from rhodecode.model.meta import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.tests import (
     url, TestController, assert_session_flash, GIT_REPO, HG_REPO,
     TESTS_TMP_PATH, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 
 
 def test_update(app, csrf_token, autologin_user, user_util):
     repo_group = user_util.create_repo_group()
     description = 'description for newly created repo group'
     Session().commit()
     response = app.post(
         url('update_repo_group', group_name=repo_group.group_name),
         fixture._get_group_create_params(
             group_name=repo_group.group_name,
             group_description=description,
             csrf_token=csrf_token,
             _method='PUT')
         )
     # TODO: anderson: johbo: we believe that this update should return
     # a redirect instead of rendering the template.
     assert response.status_code == 200
 
 
 def test_edit(app, user_util, autologin_user):
     repo_group = user_util.create_repo_group()
     Session().commit()
     response = app.get(
         url('edit_repo_group', group_name=repo_group.group_name))
     assert response.status_code == 200
 
 
 def test_edit_repo_group_perms(app, user_util, autologin_user):
     repo_group = user_util.create_repo_group()
     Session().commit()
     response = app.get(
         url('edit_repo_group_perms', group_name=repo_group.group_name))
     assert response.status_code == 200
 
 
 def test_update_fails_when_parent_pointing_to_self(
         app, csrf_token, user_util, autologin_user):
     group = user_util.create_repo_group()
     response = app.post(
         url('update_repo_group', group_name=group.group_name),
         fixture._get_group_create_params(
             group_parent_id=group.group_id,
             csrf_token=csrf_token,
             _method='PUT')
         )
     response.mustcontain(
         '<select class="medium error" id="group_parent_id"'
         ' name="group_parent_id">')
     response.mustcontain('<span class="error-message">Value must be one of:')
 
 
 class _BaseTest(TestController):
 
     REPO_GROUP = None
     NEW_REPO_GROUP = None
     REPO = None
     REPO_TYPE = None
 
     def test_index(self):
         self.log_user()
         response = self.app.get(url('repo_groups'))
         response.mustcontain('data: []')
 
     def test_index_after_creating_group(self):
         self.log_user()
         fixture.create_repo_group('test_repo_group')
         response = self.app.get(url('repo_groups'))
         response.mustcontain('"name_raw": "test_repo_group"')
         fixture.destroy_repo_group('test_repo_group')
 
     def test_new(self):
         self.log_user()
         self.app.get(url('new_repo_group'))
 
     def test_new_by_regular_user_no_permission(self):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         self.app.get(url('new_repo_group'), status=403)
 
     def test_create(self):
         self.log_user()
         repo_group_name = self.NEW_REPO_GROUP
         repo_group_name_unicode = repo_group_name.decode('utf8')
         description = 'description for newly created repo group'
 
         response = self.app.post(
             url('repo_groups'),
             fixture._get_group_create_params(
                 group_name=repo_group_name,
                 group_description=description,
                 csrf_token=self.csrf_token))
 
         # run the check page that triggers the flash message
-        # response = self.app.get(url('repo_check_home', repo_name=repo_name))
-        # assert response.json == {u'result': True}
         repo_gr_url = h.route_path(
             'repo_group_home', repo_group_name=repo_group_name)
 
         assert_session_flash(
             response,
             'Created repository group <a href="%s">%s</a>' % (
                 repo_gr_url, repo_group_name_unicode))
 
         # # test if the repo group was created in the database
         new_repo_group = RepoGroupModel()._get_repo_group(
             repo_group_name_unicode)
         assert new_repo_group is not None
 
         assert new_repo_group.group_name == repo_group_name_unicode
         assert new_repo_group.group_description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(repo_gr_url)
         response.mustcontain(repo_group_name)
 
         # test if the repository group was created on filesystem
         is_on_filesystem = os.path.isdir(
             os.path.join(TESTS_TMP_PATH, repo_group_name))
         if not is_on_filesystem:
             self.fail('no repo group %s in filesystem' % repo_group_name)
 
         RepoGroupModel().delete(repo_group_name_unicode)
         Session().commit()
 
     def test_create_subgroup(self, user_util):
         self.log_user()
         repo_group_name = self.NEW_REPO_GROUP
         parent_group = user_util.create_repo_group()
         parent_group_name = parent_group.group_name
 
         expected_group_name = '{}/{}'.format(
             parent_group_name, repo_group_name)
         expected_group_name_unicode = expected_group_name.decode('utf8')
 
         try:
             response = self.app.post(
                 url('repo_groups'),
                 fixture._get_group_create_params(
                     group_name=repo_group_name,
                     group_parent_id=parent_group.group_id,
                     group_description='Test desciption',
                     csrf_token=self.csrf_token))
 
             assert_session_flash(
                 response,
                 u'Created repository group <a href="%s">%s</a>' % (
                     h.route_path('repo_group_home', repo_group_name=expected_group_name),
                     expected_group_name_unicode))
         finally:
             RepoGroupModel().delete(expected_group_name_unicode)
             Session().commit()
 
     def test_user_with_creation_permissions_cannot_create_subgroups(
             self, user_util):
 
         user_util.grant_user_permission(
             TEST_USER_REGULAR_LOGIN, 'hg.repogroup.create.true')
         parent_group = user_util.create_repo_group()
         parent_group_id = parent_group.group_id
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         self.app.get(
             url('new_repo_group', parent_group=parent_group_id,),
             status=403)
 
 
 class TestRepoGroupsControllerGIT(_BaseTest):
     REPO_GROUP = None
     NEW_REPO_GROUP = 'git_repo'
     REPO = GIT_REPO
     REPO_TYPE = 'git'
 
 
 class TestRepoGroupsControllerNonAsciiGit(_BaseTest):
     REPO_GROUP = None
     NEW_REPO_GROUP = 'git_repo_ąć'
     REPO = GIT_REPO
     REPO_TYPE = 'git'
 
 
 class TestRepoGroupsControllerHG(_BaseTest):
     REPO_GROUP = None
     NEW_REPO_GROUP = 'hg_repo'
     REPO = HG_REPO
     REPO_TYPE = 'hg'
 
 
 class TestRepoGroupsControllerNumericalHG(_BaseTest):
     REPO_GROUP = None
     NEW_REPO_GROUP = '12345'
     REPO = HG_REPO
     REPO_TYPE = 'hg'
 
 
 class TestRepoGroupsControllerNonAsciiHG(_BaseTest):
     REPO_GROUP = None
     NEW_REPO_GROUP = 'hg_repo_ąć'
     REPO = HG_REPO
     REPO_TYPE = 'hg'

rhodecode/tests/functional/test_admin_repos.py

@@ -1,1117 +1,1131 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 urllib
 
 import mock
 import pytest
 
 from rhodecode.lib import auth
 from rhodecode.lib.utils2 import safe_str, str2bool
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import (
     Repository, RepoGroup, UserRepoToPerm, User, Permission)
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import (
     login_user_session, url, assert_session_flash, TEST_USER_ADMIN_LOGIN,
-    TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, HG_REPO, GIT_REPO,
-    logout_user_session)
+    TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, logout_user_session)
 from rhodecode.tests.fixture import Fixture, error_function
 from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
 
 fixture = Fixture()
 
 
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'repo_summary': '/{repo_name}',
+        'repo_creating_check': '/{repo_name}/repo_creating_check',
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
 @pytest.mark.usefixtures("app")
 class TestAdminRepos(object):
 
     def test_index(self):
         self.app.get(url('repos'))
 
     def test_create_page_restricted(self, autologin_user, backend):
         with mock.patch('rhodecode.BACKENDS', {'git': 'git'}):
             response = self.app.get(url('new_repo'), status=200)
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#repo_type')
         assert element.text_content() == '\ngit\n'
 
     def test_create_page_non_restricted(self, autologin_user, backend):
         response = self.app.get(url('new_repo'), status=200)
         assert_response = AssertResponse(response)
         assert_response.element_contains('#repo_type', 'git')
         assert_response.element_contains('#repo_type', 'svn')
         assert_response.element_contains('#repo_type', 'hg')
 
     @pytest.mark.parametrize("suffix",
                              [u'', u'xxa'], ids=['', 'non-ascii'])
     def test_create(self, autologin_user, backend, suffix, csrf_token):
         repo_name_unicode = backend.new_repo_name(suffix=suffix)
         repo_name = repo_name_unicode.encode('utf8')
         description_unicode = u'description for newly created repo' + suffix
         description = description_unicode.encode('utf8')
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token),
             status=302)
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     def test_create_numeric(self, autologin_user, backend, csrf_token):
         numeric_repo = '1234'
         repo_name = numeric_repo
         description = 'description for newly created repo' + numeric_repo
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     @pytest.mark.parametrize("suffix", [u'', u'ąćę'], ids=['', 'non-ascii'])
     def test_create_in_group(
             self, autologin_user, backend, suffix, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = u'ingroup' + suffix
         repo_name_full = RepoGroup.url_sep().join(
             [group_name, repo_name])
         description = u'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=safe_str(repo_name),
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_numeric(
             self, autologin_user, backend, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = '12345'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query()\
                 .filter(UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_without_needed_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         # create GROUP
         group_name = 'reg_sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         group_name_allowed = 'reg_sometest_allowed_%s' % backend.alias
         gr_allowed = RepoGroupModel().create(
             group_name=group_name_allowed,
             group_description='test',
             owner=TEST_USER_REGULAR_LOGIN)
         Session().commit()
 
         repo_name = 'ingroup'
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         response.mustcontain('Invalid value')
 
         # user is allowed to create in this group
         repo_name = 'ingroup'
         repo_name_full = RepoGroup.url_sep().join(
             [group_name_allowed, repo_name])
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr_allowed.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup in pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
 
             assert repo_on_filesystem(repo_name_full)
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             RepoGroupModel().delete(group_name_allowed)
             Session().commit()
 
     def test_create_in_group_inherit_permissions(self, autologin_user, backend,
                                                  csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         perm = Permission.get_by_key('repository.write')
         RepoGroupModel().grant_user_permission(
             gr, TEST_USER_REGULAR_LOGIN, perm)
 
         # add repo permissions
         Session().commit()
 
         repo_name = 'ingroup_inherited_%s' % backend.alias
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 repo_copy_permissions=True,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup to pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
         except Exception:
             RepoGroupModel().delete(group_name)
             Session().commit()
             raise
 
         # check if inherited permissions are applied
         new_repo = RepoModel().get_by_repo_name(repo_name_full)
         inherited_perms = UserRepoToPerm.query().filter(
             UserRepoToPerm.repository_id == new_repo.repo_id).all()
         assert len(inherited_perms) == 2
 
         assert TEST_USER_REGULAR_LOGIN in [
             x.user.username for x in inherited_perms]
         assert 'repository.write' in [
             x.permission.permission_name for x in inherited_perms]
 
         RepoModel().delete(repo_name_full)
         RepoGroupModel().delete(group_name)
         Session().commit()
 
     @pytest.mark.xfail_backends(
         "git", "hg", reason="Missing reposerver support")
     def test_create_with_clone_uri(self, autologin_user, backend, reposerver,
                                    csrf_token):
         source_repo = backend.create_repo(number_of_commits=2)
         source_repo_name = source_repo.repo_name
         reposerver.serve(source_repo.scm_instance())
 
         repo_name = backend.new_repo_name()
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description='',
                 clone_uri=reposerver.url,
                 csrf_token=csrf_token),
             status=302)
 
         # Should be redirected to the creating page
         response.mustcontain('repo_creating')
 
         # Expecting that both repositories have same history
         source_repo = RepoModel().get_by_repo_name(source_repo_name)
         source_vcs = source_repo.scm_instance()
         repo = RepoModel().get_by_repo_name(repo_name)
         repo_vcs = repo.scm_instance()
         assert source_vcs[0].message == repo_vcs[0].message
         assert source_vcs.count() == repo_vcs.count()
         assert source_vcs.commit_ids == repo_vcs.commit_ids
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri(self, autologin_user, backend,
                                                 csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='http://repo.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri_hg_svn(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='svn+http://svn.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     def test_create_with_git_suffix(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name() + ".git"
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
         response.mustcontain('Repository name cannot end with .git')
 
     def test_show(self, autologin_user, backend):
         self.app.get(url('repo', repo_name=backend.repo_name))
 
     def test_default_user_cannot_access_private_repo_in_a_group(
             self, autologin_user, user_util, backend, csrf_token):
 
         group = user_util.create_repo_group()
 
         repo = backend.create_repo(
             repo_private=True, repo_group=group, repo_copy_permissions=True)
 
         permissions = _get_permission_for_user(
             user='default', repo=repo.repo_name)
         assert len(permissions) == 1
         assert permissions[0].permission.permission_name == 'repository.none'
         assert permissions[0].repository.private is True
 
     def test_create_on_top_level_without_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
 
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         response.mustcontain(
             u"You do not have the permission to store repositories in "
             u"the root location.")
 
     @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)
     def test_create_repo_when_filesystem_op_fails(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
 
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         assert_session_flash(
             response, 'Error creating repository %s' % repo_name)
         # repo must not be in db
         assert backend.repo is None
         # repo must not be in filesystem !
         assert not repo_on_filesystem(repo_name)
 
     def assert_repository_is_created_correctly(
             self, repo_name, description, backend):
         repo_name_utf8 = safe_str(repo_name)
 
         # run the check page that triggers the flash message
-        response = self.app.get(url('repo_check_home', repo_name=repo_name))
+        response = self.app.get(
+            route_path('repo_creating_check', repo_name=safe_str(repo_name)))
         assert response.json == {u'result': True}
 
         flash_msg = u'Created repository <a href="/{}">{}</a>'.format(
             urllib.quote(repo_name_utf8), repo_name)
         assert_session_flash(response, flash_msg)
 
         # test if the repo was created in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
 
         assert new_repo.repo_name == repo_name
         assert new_repo.description == description
 
         # test if the repository is visible in the list ?
-        response = self.app.get(h.route_path('repo_summary', repo_name=repo_name))
+        response = self.app.get(
+            h.route_path('repo_summary', repo_name=safe_str(repo_name)))
         response.mustcontain(repo_name)
         response.mustcontain(backend.alias)
 
         assert repo_on_filesystem(repo_name)
 
 
 @pytest.mark.usefixtures("app")
 class TestVcsSettings(object):
     FORM_DATA = {
         'inherit_global_settings': False,
         'hooks_changegroup_repo_size': False,
         'hooks_changegroup_push_logger': False,
         'hooks_outgoing_pull_logger': False,
         'extensions_largefiles': False,
         'extensions_evolve': False,
         'phases_publish': 'False',
         'rhodecode_pr_merge_enabled': False,
         'rhodecode_use_outdated_comments': False,
         'new_svn_branch': '',
         'new_svn_tag': ''
     }
 
     @pytest.mark.skip_backends('svn')
     def test_global_settings_initial_values(self, autologin_user, backend):
         repo_name = backend.repo_name
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         expected_settings = (
             'rhodecode_use_outdated_comments', 'rhodecode_pr_merge_enabled',
             'hooks_changegroup_repo_size', 'hooks_changegroup_push_logger',
             'hooks_outgoing_pull_logger'
         )
         for setting in expected_settings:
             self.assert_repo_value_equals_global_value(response, setting)
 
     def test_show_settings_requires_repo_admin_permission(
             self, backend, user_util, settings_util):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         self.app.get(url('repo_vcs_settings', repo_name=repo_name), status=200)
 
     def test_inherit_global_settings_flag_is_true_by_default(
             self, autologin_user, backend):
         repo_name = backend.repo_name
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked
 
     @pytest.mark.parametrize('checked_value', [True, False])
     def test_inherit_global_settings_value(
             self, autologin_user, backend, checked_value, settings_util):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         settings_util.create_repo_rhodecode_setting(
             repo, 'inherit_vcs_settings', checked_value, 'bool')
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked == checked_value
 
     @pytest.mark.skip_backends('svn')
     def test_hooks_settings_are_created(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hooks_settings_are_not_created_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui is None
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_hooks_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings.create_ui_section_value(section, '', key=key, active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hooks_settings_are_not_updated_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         settings = SettingsModel(repo=repo_name)
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings.create_ui_section_value(section, '', key=key, active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is True
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_pr_settings_are_created(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_are_not_created_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting is None
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_creation_requires_repo_admin_permission(
             self, backend, user_util, settings_util, csrf_token):
         repo = backend.create_repo()
         repo_name = repo.repo_name
 
         logout_user_session(self.app, csrf_token)
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         new_csrf_token = auth.get_csrf_token(session)
 
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
         repo = Repository.get_by_repo_name(repo_name)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         data = self.FORM_DATA.copy()
         data['csrf_token'] = new_csrf_token
         settings = SettingsModel(repo=repo_name)
 
         try:
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 status=302)
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_pr_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             settings.create_or_update_setting(name, True, 'bool')
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_are_not_updated_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         settings = SettingsModel(repo=repo_name)
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             settings.create_or_update_setting(name, True, 'bool')
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is True
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_created(
             self, autologin_user, backend_svn, csrf_token, settings_util):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'svn-tag'
         data['new_svn_branch'] = 'svn-branch'
         data['csrf_token'] = csrf_token
 
         # Create few global settings to make sure that uniqueness validators
         # are not triggered
         settings_util.create_rhodecode_ui(
             VcsSettingsModel.SVN_BRANCH_SECTION, 'svn-branch')
         settings_util.create_rhodecode_ui(
             VcsSettingsModel.SVN_TAG_SECTION, 'svn-tag')
 
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_branch_names = [b.ui_value for b in svn_branches]
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             svn_tag_names = [b.ui_value for b in svn_tags]
             assert 'svn-branch' in svn_branch_names
             assert 'svn-tag' in svn_tag_names
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_unique(
             self, autologin_user, backend_svn, csrf_token, settings_util):
         repo = backend_svn.repo
         repo_name = repo.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'test_tag'
         data['new_svn_branch'] = 'test_branch'
         data['csrf_token'] = csrf_token
         settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch')
         settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_TAG_SECTION, 'test_tag')
 
         response = self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=200)
         response.mustcontain('Pattern already exists')
 
     def test_svn_settings_with_empty_values_are_not_created(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             assert len(svn_branches) == 0
             assert len(svn_tags) == 0
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_shown_for_svn_repository(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain('Subversion Settings')
 
     @pytest.mark.skip_backends('svn')
     def test_svn_settings_are_not_created_for_not_svn_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             assert len(svn_branches) == 0
             assert len(svn_tags) == 0
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_svn_settings_are_shown_only_for_svn_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='Subversion Settings')
 
     def test_hg_settings_are_created(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'svn-tag'
         data['new_svn_branch'] = 'svn-branch'
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is False
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert str2bool(phases_ui.ui_value) is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hg_settings_are_updated(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         settings = SettingsModel(repo=repo_name)
         settings.create_ui_section_value(
             'extensions', '', key='largefiles', active=True)
         settings.create_ui_section_value(
             'phases', '1', key='publish', active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is False
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert str2bool(phases_ui.ui_value) is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hg_settings_are_shown_for_hg_repository(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain('Mercurial Settings')
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_created_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui is None
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert phases_ui is None
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_shown_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='Mercurial Settings')
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_updated_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         settings.create_ui_section_value(
             'extensions', '', key='largefiles', active=True)
         settings.create_ui_section_value(
             'phases', '1', key='publish', active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is True
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert phases_ui.ui_value == '1'
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_per_repo_svn_settings_are_displayed(
             self, autologin_user, backend_svn, settings_util):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         branches = [
             settings_util.create_repo_rhodecode_ui(
                 repo, VcsSettingsModel.SVN_BRANCH_SECTION,
                 'branch_{}'.format(i))
             for i in range(10)]
         tags = [
             settings_util.create_repo_rhodecode_ui(
                 repo, VcsSettingsModel.SVN_TAG_SECTION, 'tag_{}'.format(i))
             for i in range(10)]
 
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         assert_response = AssertResponse(response)
         for branch in branches:
             css_selector = '[name=branch_value_{}]'.format(branch.ui_id)
             element = assert_response.get_element(css_selector)
             assert element.value == branch.ui_value
         for tag in tags:
             css_selector = '[name=tag_ui_value_new_{}]'.format(tag.ui_id)
             element = assert_response.get_element(css_selector)
             assert element.value == tag.ui_value
 
     def test_per_repo_hg_and_pr_settings_are_not_displayed_for_svn(
             self, autologin_user, backend_svn, settings_util):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='<label>Hooks:</label>')
         response.mustcontain(no='<label>Pull Request Settings:</label>')
 
     def test_inherit_global_settings_value_is_saved(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
 
         settings = SettingsModel(repo=repo_name)
         vcs_settings = VcsSettingsModel(repo=repo_name)
         try:
             assert vcs_settings.inherit_global_settings is True
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_repo_cache_is_invalidated_when_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         settings = SettingsModel(repo=repo_name)
 
         invalidation_patcher = mock.patch(
             'rhodecode.controllers.admin.repos.ScmModel.mark_for_invalidation')
         with invalidation_patcher as invalidation_mock:
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 status=302)
         try:
             invalidation_mock.assert_called_once_with(repo_name, delete=True)
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_other_settings_not_saved_inherit_global_settings_is_true(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
 
         settings = SettingsModel(repo=repo_name)
         ui_settings = (
             VcsSettingsModel.HOOKS_SETTINGS + VcsSettingsModel.HG_SETTINGS)
 
         vcs_settings = []
         try:
             for section, key in ui_settings:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 if ui:
                     vcs_settings.append(ui)
             vcs_settings.extend(settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION))
             vcs_settings.extend(settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION))
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 if setting:
                     vcs_settings.append(setting)
             assert vcs_settings == []
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_delete_svn_branch_and_tag_patterns(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         branch = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch',
             cleanup=False)
         tag = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_TAG_SECTION, 'test_tag', cleanup=False)
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token
         }
         for id_ in (branch.ui_id, tag.ui_id):
             data['delete_svn_pattern'] = id_,
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
         settings = VcsSettingsModel(repo=repo_name)
         assert settings.get_repo_svn_branch_patterns() == []
 
     def test_delete_svn_branch_requires_repo_admin_permission(
             self, backend_svn, user_util, settings_util, csrf_token):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
 
         logout_user_session(self.app, csrf_token)
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
 
         repo = Repository.get_by_repo_name(repo_name)
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         branch = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch',
             cleanup=False)
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token,
             'delete_svn_pattern': branch.ui_id
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
 
     def test_delete_svn_branch_raises_400_when_not_found(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo_name = backend_svn.repo_name
         data = {
             '_method': 'delete',
             'delete_svn_pattern': 123,
             'csrf_token': csrf_token
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=400)
 
     def test_delete_svn_branch_raises_400_when_no_id_specified(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo_name = backend_svn.repo_name
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=400)
 
     def _cleanup_repo_settings(self, settings_model):
         cleanup = []
         ui_settings = (
             VcsSettingsModel.HOOKS_SETTINGS + VcsSettingsModel.HG_SETTINGS)
 
         for section, key in ui_settings:
             ui = settings_model.get_ui_by_section_and_key(section, key)
             if ui:
                 cleanup.append(ui)
 
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.INHERIT_SETTINGS))
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.SVN_BRANCH_SECTION))
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.SVN_TAG_SECTION))
 
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             setting = settings_model.get_setting_by_name(name)
             if setting:
                 cleanup.append(setting)
 
         for object_ in cleanup:
             Session().delete(object_)
         Session().commit()
 
     def assert_repo_value_equals_global_value(self, response, setting):
         assert_response = AssertResponse(response)
         global_css_selector = '[name={}_inherited]'.format(setting)
         repo_css_selector = '[name={}]'.format(setting)
         repo_element = assert_response.get_element(repo_css_selector)
         global_element = assert_response.get_element(global_css_selector)
         assert repo_element.value == global_element.value
 
 
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm

rhodecode/tests/functional/test_forks.py

@@ -1,273 +1,288 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 pytest
 
 from rhodecode.tests import *
 from rhodecode.tests.fixture import Fixture
 from rhodecode.lib import helpers as h
 
 from rhodecode.model.db import Repository
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.meta import Session
 
 fixture = Fixture()
 
 
+def route_path(name, params=None, **kwargs):
+    import urllib
+
+    base_url = {
+        'repo_summary': '/{repo_name}',
+        'repo_creating_check': '/{repo_name}/repo_creating_check',
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
 class _BaseTest(TestController):
 
     REPO = None
     REPO_TYPE = None
     NEW_REPO = None
     REPO_FORK = None
 
     @pytest.fixture(autouse=True)
     def prepare(self, request, pylonsapp):
         self.username = u'forkuser'
         self.password = u'qweqwe'
         self.u1 = fixture.create_user(self.username, password=self.password,
                                       email=u'[e-mail]')
         Session().commit()
         self.u1id = self.u1.user_id
         request.addfinalizer(self.cleanup)
 
     def cleanup(self):
         u1 = UserModel().get(self.u1id)
         Session().delete(u1)
         Session().commit()
 
     def test_index(self):
         self.log_user()
         repo_name = self.REPO
         response = self.app.get(url(controller='forks', action='forks',
                                     repo_name=repo_name))
 
         response.mustcontain("""There are no forks yet""")
 
     def test_no_permissions_to_fork(self):
         usr = self.log_user(TEST_USER_REGULAR_LOGIN,
                             TEST_USER_REGULAR_PASS)['user_id']
         user_model = UserModel()
         user_model.revoke_perm(usr, 'hg.fork.repository')
         user_model.grant_perm(usr, 'hg.fork.none')
         u = UserModel().get(usr)
         u.inherit_default_permissions = False
         Session().commit()
         # try create a fork
         repo_name = self.REPO
         self.app.post(
             url(controller='forks', action='fork_create', repo_name=repo_name),
             {'csrf_token': self.csrf_token}, status=404)
 
     def test_index_with_fork(self):
         self.log_user()
 
         # create a fork
         fork_name = self.REPO_FORK
         description = 'fork of vcs test'
         repo_name = self.REPO
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': '',
             'fork_parent_id': source_repo.repo_id,
             'repo_type': self.REPO_TYPE,
             'description': description,
             'private': 'False',
             'landing_rev': 'rev:tip',
             'csrf_token': self.csrf_token,
         }
 
         self.app.post(url(controller='forks', action='fork_create',
                           repo_name=repo_name), creation_args)
 
         response = self.app.get(url(controller='forks', action='forks',
                                     repo_name=repo_name))
 
         response.mustcontain(
             """<a href="/%s">%s</a>""" % (fork_name, fork_name)
         )
 
         # remove this fork
         fixture.destroy_repo(fork_name)
 
     def test_fork_create_into_group(self):
         self.log_user()
         group = fixture.create_repo_group('vc')
         group_id = group.group_id
         fork_name = self.REPO_FORK
         fork_name_full = 'vc/%s' % fork_name
         description = 'fork of vcs test'
         repo_name = self.REPO
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': group_id,
             'fork_parent_id': source_repo.repo_id,
             'repo_type': self.REPO_TYPE,
             'description': description,
             'private': 'False',
             'landing_rev': 'rev:tip',
             'csrf_token': self.csrf_token,
         }
         self.app.post(url(controller='forks', action='fork_create',
                           repo_name=repo_name), creation_args)
         repo = Repository.get_by_repo_name(fork_name_full)
         assert repo.fork.repo_name == self.REPO
 
         # run the check page that triggers the flash message
-        response = self.app.get(url('repo_check_home', repo_name=fork_name_full))
+        response = self.app.get(
+            route_path('repo_creating_check', repo_name=fork_name_full))
         # test if we have a message that fork is ok
         assert_session_flash(response,
                 'Forked repository %s as <a href="/%s">%s</a>'
                 % (repo_name, fork_name_full, fork_name_full))
 
         # test if the fork was created in the database
         fork_repo = Session().query(Repository)\
             .filter(Repository.repo_name == fork_name_full).one()
 
         assert fork_repo.repo_name == fork_name_full
         assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(h.route_path('repo_summary', repo_name=fork_name_full))
         response.mustcontain(fork_name_full)
         response.mustcontain(self.REPO_TYPE)
 
         response.mustcontain('Fork of')
         response.mustcontain('<a href="/%s">%s</a>' % (repo_name, repo_name))
 
         fixture.destroy_repo(fork_name_full)
         fixture.destroy_repo_group(group_id)
 
     def test_z_fork_create(self):
         self.log_user()
         fork_name = self.REPO_FORK
         description = 'fork of vcs test'
         repo_name = self.REPO
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': '',
             'fork_parent_id': source_repo.repo_id,
             'repo_type': self.REPO_TYPE,
             'description': description,
             'private': 'False',
             'landing_rev': 'rev:tip',
             'csrf_token': self.csrf_token,
         }
         self.app.post(url(controller='forks', action='fork_create',
                           repo_name=repo_name), creation_args)
         repo = Repository.get_by_repo_name(self.REPO_FORK)
         assert repo.fork.repo_name == self.REPO
 
         # run the check page that triggers the flash message
-        response = self.app.get(url('repo_check_home', repo_name=fork_name))
+        response = self.app.get(
+            route_path('repo_creating_check', repo_name=fork_name))
         # test if we have a message that fork is ok
         assert_session_flash(response,
                 'Forked repository %s as <a href="/%s">%s</a>'
                 % (repo_name, fork_name, fork_name))
 
         # test if the fork was created in the database
         fork_repo = Session().query(Repository)\
             .filter(Repository.repo_name == fork_name).one()
 
         assert fork_repo.repo_name == fork_name
         assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(h.route_path('repo_summary', repo_name=fork_name))
         response.mustcontain(fork_name)
         response.mustcontain(self.REPO_TYPE)
         response.mustcontain('Fork of')
         response.mustcontain('<a href="/%s">%s</a>' % (repo_name, repo_name))
 
     def test_zz_fork_permission_page(self):
         usr = self.log_user(self.username, self.password)['user_id']
         repo_name = self.REPO
 
         forks = Repository.query()\
             .filter(Repository.repo_type == self.REPO_TYPE)\
             .filter(Repository.fork_id != None).all()
         assert 1 == len(forks)
 
         # set read permissions for this
         RepoModel().grant_user_permission(repo=forks[0],
                                           user=usr,
                                           perm='repository.read')
         Session().commit()
 
         response = self.app.get(url(controller='forks', action='forks',
                                     repo_name=repo_name))
 
         response.mustcontain('fork of vcs test')
 
     def test_zzz_fork_permission_page(self):
         usr = self.log_user(self.username, self.password)['user_id']
         repo_name = self.REPO
 
         forks = Repository.query()\
             .filter(Repository.repo_type == self.REPO_TYPE)\
             .filter(Repository.fork_id != None).all()
         assert 1 == len(forks)
 
         # set none
         RepoModel().grant_user_permission(repo=forks[0],
                                           user=usr, perm='repository.none')
         Session().commit()
         # fork shouldn't be there
         response = self.app.get(url(controller='forks', action='forks',
                                     repo_name=repo_name))
         response.mustcontain('There are no forks yet')
 
 
 class TestGIT(_BaseTest):
     REPO = GIT_REPO
     NEW_REPO = NEW_GIT_REPO
     REPO_TYPE = 'git'
     REPO_FORK = GIT_FORK
 
 
 class TestHG(_BaseTest):
     REPO = HG_REPO
     NEW_REPO = NEW_HG_REPO
     REPO_TYPE = 'hg'
     REPO_FORK = HG_FORK
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 @pytest.mark.skip_backends('git','hg')
 class TestSVNFork(object):
 
     def test_fork_redirects(self, backend):
         denied_actions = ['fork','fork_create']
         for action in denied_actions:
             response = self.app.get(url(
                 controller='forks', action=action,
                 repo_name=backend.repo_name))
             assert response.status_int == 302
 
             # Not allowed, redirect to the summary
             redirected = response.follow()
             summary_url = h.route_path('repo_summary', repo_name=backend.repo_name)
 
             # URL adds leading slash and path doesn't have it
             assert redirected.request.path == summary_url