forks: moved pylons code into pyramid.

rhodecode/apps/repository/tests/test_repo_forks.py

@@ -0,0 +1,315 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 TestController, assert_session_flash, HG_FORK, GIT_FORK
+
+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',
+        'repo_fork_new': '/{repo_name}/fork',
+        'repo_fork_create': '/{repo_name}/fork/create',
+        'repo_forks_show_all': '/{repo_name}/forks',
+        'repo_forks_data': '/{repo_name}/forks/data',
+    }[name].format(**kwargs)
+
+    if params:
+        base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
+    return base_url
+
+
+FORK_NAME = {
+    'hg': HG_FORK,
+    'git': GIT_FORK
+}
+
+
[e-mail]_backends('svn')
+class TestRepoForkViewTests(TestController):
+
+    def test_show_forks(self, backend, xhr_header):
+        self.log_user()
+        response = self.app.get(
+            route_path('repo_forks_data', repo_name=backend.repo_name),
+            extra_environ=xhr_header)
+
+        assert response.json == {u'data': [], u'draw': None,
+                                 u'recordsFiltered': 0, u'recordsTotal': 0}
+
+    def test_no_permissions_to_fork_page(self, backend, user_util):
+        user = user_util.create_user(password='qweqwe')
+        user_id = user.user_id
+        self.log_user(user.username, 'qweqwe')
+
+        user_model = UserModel()
+        user_model.revoke_perm(user_id, 'hg.fork.repository')
+        user_model.grant_perm(user_id, 'hg.fork.none')
+        u = UserModel().get(user_id)
+        u.inherit_default_permissions = False
+        Session().commit()
+        # try create a fork
+        self.app.get(
+            route_path('repo_fork_new', repo_name=backend.repo_name),
+            status=404)
+
+    def test_no_permissions_to_fork_submit(self, backend, csrf_token, user_util):
+        user = user_util.create_user(password='qweqwe')
+        user_id = user.user_id
+        self.log_user(user.username, 'qweqwe')
+
+        user_model = UserModel()
+        user_model.revoke_perm(user_id, 'hg.fork.repository')
+        user_model.grant_perm(user_id, 'hg.fork.none')
+        u = UserModel().get(user_id)
+        u.inherit_default_permissions = False
+        Session().commit()
+        # try create a fork
+        self.app.post(
+            route_path('repo_fork_create', repo_name=backend.repo_name),
+            {'csrf_token': csrf_token},
+            status=404)
+
+    def test_fork_missing_data(self, autologin_user, backend, csrf_token):
+        # try create a fork
+        response = self.app.post(
+            route_path('repo_fork_create', repo_name=backend.repo_name),
+            {'csrf_token': csrf_token},
+            status=200)
+        # test if html fill works fine
+        response.mustcontain('Missing value')
+
+    def test_create_fork_page(self, autologin_user, backend):
+        self.app.get(
+            route_path('repo_fork_new', repo_name=backend.repo_name),
+            status=200)
+
+    def test_create_and_show_fork(
+            self, autologin_user, backend, csrf_token, xhr_header):
+
+        # create a fork
+        fork_name = FORK_NAME[backend.alias]
+        description = 'fork of vcs test'
+        repo_name = backend.repo_name
+        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': backend.alias,
+            'description': description,
+            'private': 'False',
+            'landing_rev': 'rev:tip',
+            'csrf_token': csrf_token,
+        }
+
+        self.app.post(
+            route_path('repo_fork_create', repo_name=repo_name), creation_args)
+
+        response = self.app.get(
+            route_path('repo_forks_data', repo_name=repo_name),
+            extra_environ=xhr_header)
+
+        assert response.json['data'][0]['fork_name'] == \
+            """<a href="/%s">%s</a>""" % (fork_name, fork_name)
+
+        # remove this fork
+        fixture.destroy_repo(fork_name)
+
+    def test_fork_create(self, autologin_user, backend, csrf_token):
+        fork_name = FORK_NAME[backend.alias]
+        description = 'fork of vcs test'
+        repo_name = backend.repo_name
+        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': backend.alias,
+            'description': description,
+            'private': 'False',
+            'landing_rev': 'rev:tip',
+            'csrf_token': csrf_token,
+        }
+        self.app.post(
+            route_path('repo_fork_create', repo_name=repo_name), creation_args)
+        repo = Repository.get_by_repo_name(FORK_NAME[backend.alias])
+        assert repo.fork.repo_name == backend.repo_name
+
+        # run the check page that triggers the flash message
+        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(backend.alias)
+        response.mustcontain('Fork of')
+        response.mustcontain('<a href="/%s">%s</a>' % (repo_name, repo_name))
+
+    def test_fork_create_into_group(self, autologin_user, backend, csrf_token):
+        group = fixture.create_repo_group('vc')
+        group_id = group.group_id
+        fork_name = FORK_NAME[backend.alias]
+        fork_name_full = 'vc/%s' % fork_name
+        description = 'fork of vcs test'
+        repo_name = backend.repo_name
+        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': backend.alias,
+            'description': description,
+            'private': 'False',
+            'landing_rev': 'rev:tip',
+            'csrf_token': csrf_token,
+        }
+        self.app.post(
+            route_path('repo_fork_create', repo_name=repo_name), creation_args)
+        repo = Repository.get_by_repo_name(fork_name_full)
+        assert repo.fork.repo_name == backend.repo_name
+
+        # run the check page that triggers the flash message
+        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(backend.alias)
+
+        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_fork_read_permission(self, backend, xhr_header, user_util):
+        user = user_util.create_user(password='qweqwe')
+        user_id = user.user_id
+        self.log_user(user.username, 'qweqwe')
+
+        # create a fake fork
+        fork = user_util.create_repo(repo_type=backend.alias)
+        source = user_util.create_repo(repo_type=backend.alias)
+        repo_name = source.repo_name
+
+        fork.fork_id = source.repo_id
+        fork_name = fork.repo_name
+        Session().commit()
+
+        forks = Repository.query()\
+            .filter(Repository.repo_type == backend.alias)\
+            .filter(Repository.fork_id == source.repo_id).all()
+        assert 1 == len(forks)
+
+        # set read permissions for this
+        RepoModel().grant_user_permission(
+            repo=forks[0], user=user_id, perm='repository.read')
+        Session().commit()
+
+        response = self.app.get(
+            route_path('repo_forks_data', repo_name=repo_name),
+            extra_environ=xhr_header)
+
+        assert response.json['data'][0]['fork_name'] == \
+            """<a href="/%s">%s</a>""" % (fork_name, fork_name)
+
+    def test_fork_none_permission(self, backend, xhr_header, user_util):
+        user = user_util.create_user(password='qweqwe')
+        user_id = user.user_id
+        self.log_user(user.username, 'qweqwe')
+
+        # create a fake fork
+        fork = user_util.create_repo(repo_type=backend.alias)
+        source = user_util.create_repo(repo_type=backend.alias)
+        repo_name = source.repo_name
+
+        fork.fork_id = source.repo_id
+
+        Session().commit()
+
+        forks = Repository.query()\
+            .filter(Repository.repo_type == backend.alias)\
+            .filter(Repository.fork_id == source.repo_id).all()
+        assert 1 == len(forks)
+
+        # set none
+        RepoModel().grant_user_permission(
+            repo=forks[0], user=user_id, perm='repository.none')
+        Session().commit()
+
+        # fork shouldn't be there
+        response = self.app.get(
+            route_path('repo_forks_data', repo_name=repo_name),
+            extra_environ=xhr_header)
+
+        assert response.json == {u'data': [], u'draw': None,
+                                 u'recordsFiltered': 0, u'recordsTotal': 0}
+
+
+class TestSVNFork(TestController):
+    @pytest.mark.parametrize('route_name', [
+        'repo_fork_create', 'repo_fork_new'
+    ])
+    def test_fork_redirects(self, autologin_user, backend_svn, route_name):
+
+        self.app.get(route_path(
+            route_name, repo_name=backend_svn.repo_name),
+            status=404)

rhodecode/apps/repository/views/repo_forks.py

@@ -0,0 +1,256 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
+import datetime
+import formencode
+from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest, HTTPFound
+from pyramid.view import view_config
+from pyramid.renderers import render
+from pyramid.response import Response
+
+from rhodecode.apps._base import RepoAppView, DataGridAppView
+
+from rhodecode.lib.auth import (
+    LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
+    HasRepoPermissionAny, HasPermissionAnyDecorator, CSRFRequired)
+import rhodecode.lib.helpers as h
+from rhodecode.model.db import (
+    coalesce, or_, 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, safe_unicode
+
+log = logging.getLogger(__name__)
+
+
+class RepoForksView(RepoAppView, DataGridAppView):
+
+    def load_default_context(self):
+        c = self._get_local_tmpl_context(include_app_defaults=True)
+
+        # TODO(marcink): remove repo_info and use c.rhodecode_db_repo instead
+        c.repo_info = self.db_repo
+        c.rhodecode_repo = self.rhodecode_vcs_repo
+
+        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: safe_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
+
+        self._register_global_c(c)
+        return c
+
+    @LoginRequired()
+    @HasRepoPermissionAnyDecorator(
+        'repository.read', 'repository.write', 'repository.admin')
+    @view_config(
+        route_name='repo_forks_show_all', request_method='GET',
+        renderer='rhodecode:templates/forks/forks.mako')
+    def repo_forks_show_all(self):
+        c = self.load_default_context()
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasRepoPermissionAnyDecorator(
+        'repository.read', 'repository.write', 'repository.admin')
+    @view_config(
+        route_name='repo_forks_data', request_method='GET',
+        renderer='json_ext', xhr=True)
+    def repo_forks_data(self):
+        _ = self.request.translate
+        column_map = {
+            'fork_name': 'repo_name',
+            'fork_date': 'created_on',
+            'last_activity': 'updated_on'
+        }
+        draw, start, limit = self._extract_chunk(self.request)
+        search_q, order_by, order_dir = self._extract_ordering(
+            self.request, column_map=column_map)
+
+        acl_check = HasRepoPermissionAny(
+            'repository.read', 'repository.write', 'repository.admin')
+        repo_id = self.db_repo.repo_id
+        allowed_ids = []
+        for f in Repository.query().filter(Repository.fork_id == repo_id):
+            if acl_check(f.repo_name, 'get forks check'):
+                allowed_ids.append(f.repo_id)
+
+        forks_data_total_count = Repository.query()\
+            .filter(Repository.fork_id == repo_id)\
+            .filter(Repository.repo_id.in_(allowed_ids))\
+            .count()
+
+        # json generate
+        base_q = Repository.query()\
+            .filter(Repository.fork_id == repo_id)\
+            .filter(Repository.repo_id.in_(allowed_ids))\
+
+        if search_q:
+            like_expression = u'%{}%'.format(safe_unicode(search_q))
+            base_q = base_q.filter(or_(
+                Repository.repo_name.ilike(like_expression),
+                Repository.description.ilike(like_expression),
+            ))
+
+        forks_data_total_filtered_count = base_q.count()
+
+        sort_col = getattr(Repository, order_by, None)
+        if sort_col:
+            if order_dir == 'asc':
+                # handle null values properly to order by NULL last
+                if order_by in ['last_activity']:
+                    sort_col = coalesce(sort_col, datetime.date.max)
+                sort_col = sort_col.asc()
+            else:
+                # handle null values properly to order by NULL last
+                if order_by in ['last_activity']:
+                    sort_col = coalesce(sort_col, datetime.date.min)
+                sort_col = sort_col.desc()
+
+        base_q = base_q.order_by(sort_col)
+        base_q = base_q.offset(start).limit(limit)
+
+        fork_list = base_q.all()
+
+        def fork_actions(fork):
+            url_link = h.route_path(
+                'repo_compare',
+                repo_name=fork.repo_name,
+                source_ref_type=self.db_repo.landing_rev[0],
+                source_ref=self.db_repo.landing_rev[1],
+                target_ref_type=self.db_repo.landing_rev[0],
+                target_ref=self.db_repo.landing_rev[1],
+                _query=dict(merge=1, target_repo=f.repo_name))
+            return h.link_to(_('Compare fork'), url_link, class_='btn-link')
+
+        def fork_name(fork):
+            return h.link_to(fork.repo_name,
+                      h.route_path('repo_summary', repo_name=fork.repo_name))
+
+        forks_data = []
+        for fork in fork_list:
+            forks_data.append({
+                "username": h.gravatar_with_user(self.request, fork.user.username),
+                "fork_name": fork_name(fork),
+                "description": fork.description,
+                "fork_date": h.age_component(fork.created_on, time_is_local=True),
+                "last_activity": h.format_date(fork.updated_on),
+                "action": fork_actions(fork),
+            })
+
+        data = ({
+            'draw': draw,
+            'data': forks_data,
+            'recordsTotal': forks_data_total_count,
+            'recordsFiltered': forks_data_total_filtered_count,
+        })
+
+        return data
+
+    @LoginRequired()
+    @NotAnonymous()
+    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
+    @HasRepoPermissionAnyDecorator(
+        'repository.read', 'repository.write', 'repository.admin')
+    @view_config(
+        route_name='repo_fork_new', request_method='GET',
+        renderer='rhodecode:templates/forks/forks.mako')
+    def repo_fork_new(self):
+        c = self.load_default_context()
+
+        defaults = RepoModel()._get_defaults(self.db_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']
+
+        data = render('rhodecode:templates/forks/fork.mako',
+                      self._get_template_context(c), self.request)
+        html = formencode.htmlfill.render(
+            data,
+            defaults=defaults,
+            encoding="UTF-8",
+            force_defaults=False
+        )
+        return Response(html)
+
+    @LoginRequired()
+    @NotAnonymous()
+    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
+    @HasRepoPermissionAnyDecorator(
+        'repository.read', 'repository.write', 'repository.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='repo_fork_create', request_method='POST',
+        renderer='rhodecode:templates/forks/fork.mako')
+    def repo_fork_create(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+
+        _form = RepoForkForm(old_data={'repo_type': self.db_repo.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(self.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.repo_info = self.db_repo
+
+            data = render('rhodecode:templates/forks/fork.mako',
+                          self._get_template_context(c), self.request)
+            html = formencode.htmlfill.render(
+                data,
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8",
+                force_defaults=False
+            )
+            return Response(html)
+        except Exception:
+            log.exception(
+                u'Exception while trying to fork the repository %s',
+                self.db_repo_name)
+            msg = (
+                _('An error occurred during repository forking %s') % (
+                    self.db_repo_name, ))
+            h.flash(msg, category='error')
+
+        repo_name = form_result.get('repo_name_full', self.db_repo_name)
+        raise HTTPFound(
+            h.route_path('repo_creating',
+                         repo_name=repo_name,
+                         _query=dict(task_id=task_id)))

rhodecode/apps/repository/__init__.py

@@ -219,10 +219,31 b' def includeme(config):'
         name='branches_home',
         pattern='/{repo_name:.*?[^/]}/branches', repo_route=True)
 
+    # Bookmarks
     config.add_route(
         name='bookmarks_home',
         pattern='/{repo_name:.*?[^/]}/bookmarks', repo_route=True)
 
+    # Forks
+    config.add_route(
+        name='repo_fork_new',
+        pattern='/{repo_name:.*?[^/]}/fork', repo_route=True,
+        repo_accepted_types=['hg', 'git'])
+
+    config.add_route(
+        name='repo_fork_create',
+        pattern='/{repo_name:.*?[^/]}/fork/create', repo_route=True,
+        repo_accepted_types=['hg', 'git'])
+
+    config.add_route(
+        name='repo_forks_show_all',
+        pattern='/{repo_name:.*?[^/]}/forks', repo_route=True,
+        repo_accepted_types=['hg', 'git'])
+    config.add_route(
+        name='repo_forks_data',
+        pattern='/{repo_name:.*?[^/]}/forks/data', repo_route=True,
+        repo_accepted_types=['hg', 'git'])
+
     # Pull Requests
     config.add_route(
         name='pullrequest_show',

rhodecode/config/routing.py

@@ -489,20 +489,4 b' def make_map(config):'
                  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/lib/auth.py

@@ -1340,39 +1340,6 b' class XHRRequired(object):'
         return func(*fargs, **fkwargs)
 
 
-class HasAcceptedRepoType(object):
-    """
-    Check if requested repo is within given repo type aliases
-    """
-
-    # TODO(marcink): remove this in favor of the predicates in pyramid routes
-
-    def __init__(self, *repo_type_list):
-        self.repo_type_list = set(repo_type_list)
-
-    def __call__(self, func):
-        return get_cython_compat_decorator(self.__wrapper, func)
-
-    def __wrapper(self, func, *fargs, **fkwargs):
-        import rhodecode.lib.helpers as h
-        cls = fargs[0]
-        rhodecode_repo = cls.rhodecode_repo
-
-        log.debug('%s checking repo type for %s in %s',
-                  self.__class__.__name__,
-                  rhodecode_repo.alias, self.repo_type_list)
-
-        if rhodecode_repo.alias in self.repo_type_list:
-            return func(*fargs, **fkwargs)
-        else:
-            h.flash(h.literal(
-                _('Action not supported for %s.' % rhodecode_repo.alias)),
-                category='warning')
-            raise HTTPFound(
-                h.route_path('repo_summary',
-                             repo_name=cls.rhodecode_db_repo.repo_name))
-
-
 class PermsDecorator(object):
     """
     Base class for controller decorators, we extract the current user from

rhodecode/public/js/rhodecode/routes.js

@@ -145,6 +145,10 b' function registerRCRoutes() {'
     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('repo_fork_new', '/%(repo_name)s/fork', ['repo_name']);
+    pyroutes.register('repo_fork_create', '/%(repo_name)s/fork/create', ['repo_name']);
+    pyroutes.register('repo_forks_show_all', '/%(repo_name)s/forks', ['repo_name']);
+    pyroutes.register('repo_forks_data', '/%(repo_name)s/forks/data', ['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']);

rhodecode/templates/base/base.mako

@@ -275,7 +275,7 b''
               %endif
               %if c.rhodecode_user.username != h.DEFAULT_USER:
                 %if c.rhodecode_db_repo.repo_type in ['git','hg']:
-                  <li><a href="${h.url('repo_fork_home',repo_name=c.repo_name)}">${_('Fork')}</a></li>
+                  <li><a href="${h.route_path('repo_fork_new',repo_name=c.repo_name)}">${_('Fork')}</a></li>
                   <li><a href="${h.route_path('pullrequest_new',repo_name=c.repo_name)}">${_('Create Pull Request')}</a></li>
                 %endif
               %endif

rhodecode/templates/data_table/_dt_elements.mako

@@ -24,7 +24,7 b''
          </a>
       </li>
       <li>
-         <a title="${_('Fork')}" href="${h.url('repo_fork_home',repo_name=repo_name)}">
+         <a title="${_('Fork')}" href="${h.route_path('repo_fork_new',repo_name=repo_name)}">
          <span>${_('Fork')}</span>
          </a>
       </li>

rhodecode/templates/forks/fork.mako

@@ -27,7 +27,7 b''
           ${self.breadcrumbs()}
       </div>
 
-    ${h.secure_form(h.url('repo_fork_create_home',repo_name=c.repo_info.repo_name))}
+    ${h.secure_form(h.route_path('repo_fork_create',repo_name=c.repo_info.repo_name), method='POST', request=request)}
     <div class="form">
         <!-- fields -->
         <div class="fields">

rhodecode/templates/forks/forks.mako

@@ -26,20 +26,94 b''
         ${self.repo_page_title(c.rhodecode_db_repo)}
         <ul class="links">
             <li>
-            ## fork open link
-            <span>
-                <a class="btn btn-small btn-success" href="${h.url('repo_fork_home',repo_name=c.repo_name)}">
+                <a class="btn btn-small btn-success" href="${h.route_path('repo_fork_new',repo_name=c.repo_name)}">
                     ${_('Create new fork')}
                 </a>
-            </span>
-
             </li>
         </ul>
     </div>
-    <div class="table">
-        <div id="forks">
-            ${c.forks_data}
-        </div>
+
+    <div id="fork_list_wrap">
+        <table id="fork_list_table" class="display"></table>
     </div>
 </div>
+
+
+
+<script type="text/javascript">
+
+$(document).ready(function() {
+    var $userListTable = $('#fork_list_table');
+
+    var getDatatableCount = function(){
+      var table = $userListTable.dataTable();
+      var page = table.api().page.info();
+      var  active = page.recordsDisplay;
+      var  total = page.recordsTotal;
+
+      var _text = _gettext("{0} out of {1} users").format(active, total);
+      $('#user_count').text(_text);
+    };
+
+    // user list
+    $userListTable.DataTable({
+      processing: true,
+      serverSide: true,
+      ajax: "${h.route_path('repo_forks_data', repo_name=c.repo_name)}",
+      dom: 'rtp',
+      pageLength: ${c.visual.dashboard_items},
+      order: [[ 0, "asc" ]],
+      columns: [
+         { data: {"_": "username",
+                  "sort": "username"}, title: "${_('Owner')}", className: "td-user" },
+         { data: {"_": "fork_name",
+                  "sort": "fork_name"}, title: "${_('Fork name')}", className: "td-email"  },
+         { data: {"_": "description",
+                  "sort": "description"}, title: "${_('Description')}", className: "td-user" },
+         { data: {"_": "fork_date",
+                  "sort": "fork_date"}, title: "${_('Forked')}", className: "td-user" },
+         { data: {"_": "last_activity",
+                  "sort": "last_activity",
+                  "type": Number}, title: "${_('Last activity')}", className: "td-time" },
+         { data: {"_": "action",
+                  "sort": "action"}, title: "${_('Action')}", className: "td-action", orderable: false }
+      ],
+
+      language: {
+          paginate: DEFAULT_GRID_PAGINATION,
+          sProcessing: _gettext('loading...'),
+          emptyTable: _gettext("No forks available yet.")
+      },
+
+      "createdRow": function ( row, data, index ) {
+          if (!data['active_raw']){
+            $(row).addClass('closed')
+          }
+      }
+    });
+
+    $userListTable.on('xhr.dt', function(e, settings, json, xhr){
+        $userListTable.css('opacity', 1);
+    });
+
+    $userListTable.on('preXhr.dt', function(e, settings, data){
+        $userListTable.css('opacity', 0.3);
+    });
+
+    // refresh counters on draw
+    $userListTable.on('draw.dt', function(){
+        getDatatableCount();
+    });
+
+    // filter
+    $('#q_filter').on('keyup',
+        $.debounce(250, function() {
+            $userListTable.DataTable().search(
+                $('#q_filter').val()
+            ).draw();
+        })
+    );
+
+  });
+</script>
 </%def>

rhodecode/templates/summary/components.mako

@@ -108,7 +108,7 b''
                   % endif
 
                   ## forks
-                  <a title="${_('Number of Repository Forks')}" href="${h.url('repo_forks_home', repo_name=c.repo_name)}">
+                  <a title="${_('Number of Repository Forks')}" href="${h.route_path('repo_forks_show_all', repo_name=c.repo_name)}">
                      ${c.repository_forks} ${_ungettext('Fork', 'Forks', c.repository_forks)}</a>,
 
                   ## repo size

rhodecode/tests/functional/test_integrations.py

@@ -18,15 +18,10 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-import mock
 import pytest
-from webob.exc import HTTPNotFound
 
-import rhodecode
 from rhodecode.model.db import Integration
 from rhodecode.model.meta import Session
-from rhodecode.tests import assert_session_flash, url, TEST_USER_ADMIN_LOGIN
-from rhodecode.tests.utils import AssertResponse
 from rhodecode.integrations import integration_type_registry
 from rhodecode.config.routing import ADMIN_PREFIX