integrations: fixed view for integrations on repo.

rhodecode/integrations/views.py

@@ -1,463 +1,464 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2019 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 deform
 import logging
 import peppercorn
 import webhelpers.paginate
 
 from pyramid.httpexceptions import HTTPFound, HTTPForbidden, HTTPNotFound
 
 from rhodecode.integrations import integration_type_registry
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps._base.navigation import navigation_list
 from rhodecode.lib.auth import (
     LoginRequired, CSRFRequired, HasPermissionAnyDecorator,
     HasRepoPermissionAnyDecorator, HasRepoGroupPermissionAnyDecorator)
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import Repository, RepoGroup, Session, Integration
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.model.validation_schema.schemas.integration_schema import (
     make_integration_schema, IntegrationScopeType)
 
 log = logging.getLogger(__name__)
 
 
 class IntegrationSettingsViewBase(BaseAppView):
     """
     Base Integration settings view used by both repo / global settings
     """
 
     def __init__(self, context, request):
         super(IntegrationSettingsViewBase, self).__init__(context, request)
         self._load_view_context()
 
     def _load_view_context(self):
         """
         This avoids boilerplate for repo/global+list/edit+views/templates
         by doing all possible contexts at the same time however it should
         be split up into separate functions once more "contexts" exist
         """
 
         self.IntegrationType = None
         self.repo = None
         self.repo_group = None
         self.integration = None
         self.integrations = {}
 
         request = self.request
 
         if 'repo_name' in request.matchdict:  # in repo settings context
             repo_name = request.matchdict['repo_name']
             self.repo = Repository.get_by_repo_name(repo_name)
 
         if 'repo_group_name' in request.matchdict:  # in group settings context
             repo_group_name = request.matchdict['repo_group_name']
             self.repo_group = RepoGroup.get_by_group_name(repo_group_name)
 
         if 'integration' in request.matchdict:  # integration type context
             integration_type = request.matchdict['integration']
             if integration_type not in integration_type_registry:
                 raise HTTPNotFound()
 
             self.IntegrationType = integration_type_registry[integration_type]
             if self.IntegrationType.is_dummy:
                 raise HTTPNotFound()
 
         if 'integration_id' in request.matchdict:  # single integration context
             integration_id = request.matchdict['integration_id']
             self.integration = Integration.get(integration_id)
 
             # extra perms check just in case
             if not self._has_perms_for_integration(self.integration):
                 raise HTTPForbidden()
 
         self.settings = self.integration and self.integration.settings or {}
         self.admin_view = not (self.repo or self.repo_group)
 
     def _has_perms_for_integration(self, integration):
         perms = self.request.user.permissions
 
         if 'hg.admin' in perms['global']:
             return True
 
         if integration.repo:
             return perms['repositories'].get(
                 integration.repo.repo_name) == 'repository.admin'
 
         if integration.repo_group:
             return perms['repositories_groups'].get(
                 integration.repo_group.group_name) == 'group.admin'
 
         return False
 
     def _get_local_tmpl_context(self, include_app_defaults=True):
         _ = self.request.translate
         c = super(IntegrationSettingsViewBase, self)._get_local_tmpl_context(
             include_app_defaults=include_app_defaults)
         c.active = 'integrations'
 
         return c
 
     def _form_schema(self):
         schema = make_integration_schema(IntegrationType=self.IntegrationType,
                                          settings=self.settings)
 
         # returns a clone, important if mutating the schema later
         return schema.bind(
             permissions=self.request.user.permissions,
             no_scope=not self.admin_view)
 
     def _form_defaults(self):
         _ = self.request.translate
         defaults = {}
 
         if self.integration:
             defaults['settings'] = self.integration.settings or {}
             defaults['options'] = {
                 'name': self.integration.name,
                 'enabled': self.integration.enabled,
                 'scope': {
                     'repo': self.integration.repo,
                     'repo_group': self.integration.repo_group,
                     'child_repos_only': self.integration.child_repos_only,
                 },
             }
         else:
             if self.repo:
                 scope = _('{repo_name} repository').format(
                     repo_name=self.repo.repo_name)
             elif self.repo_group:
                 scope = _('{repo_group_name} repo group').format(
                     repo_group_name=self.repo_group.group_name)
             else:
                 scope = _('Global')
 
             defaults['options'] = {
                 'enabled': True,
                 'name': _('{name} integration').format(
                     name=self.IntegrationType.display_name),
             }
             defaults['options']['scope'] = {
                 'repo': self.repo,
                 'repo_group': self.repo_group,
             }
 
         return defaults
 
     def _delete_integration(self, integration):
         _ = self.request.translate
         Session().delete(integration)
         Session().commit()
         h.flash(
             _('Integration {integration_name} deleted successfully.').format(
                 integration_name=integration.name),
             category='success')
 
         if self.repo:
             redirect_to = self.request.route_path(
                 'repo_integrations_home', repo_name=self.repo.repo_name)
         elif self.repo_group:
             redirect_to = self.request.route_path(
                 'repo_group_integrations_home',
                 repo_group_name=self.repo_group.group_name)
         else:
             redirect_to = self.request.route_path('global_integrations_home')
         raise HTTPFound(redirect_to)
 
     def _integration_list(self):
         """ List integrations """
 
         c = self.load_default_context()
         if self.repo:
             scope = self.repo
         elif self.repo_group:
             scope = self.repo_group
         else:
             scope = 'all'
 
         integrations = []
 
         for IntType, integration in IntegrationModel().get_integrations(
                         scope=scope, IntegrationType=self.IntegrationType):
 
             # extra permissions check *just in case*
             if not self._has_perms_for_integration(integration):
                 continue
 
             integrations.append((IntType, integration))
 
         sort_arg = self.request.GET.get('sort', 'name:asc')
         sort_dir = 'asc'
         if ':' in sort_arg:
             sort_field, sort_dir = sort_arg.split(':')
         else:
             sort_field = sort_arg, 'asc'
 
         assert sort_field in ('name', 'integration_type', 'enabled', 'scope')
 
         integrations.sort(
             key=lambda x: getattr(x[1], sort_field),
             reverse=(sort_dir == 'desc'))
 
         page_url = webhelpers.paginate.PageURL(
             self.request.path, self.request.GET)
         page = safe_int(self.request.GET.get('page', 1), 1)
 
         integrations = h.Page(
             integrations, page=page, items_per_page=10, url=page_url)
 
         c.rev_sort_dir = sort_dir != 'desc' and 'desc' or 'asc'
 
         c.current_IntegrationType = self.IntegrationType
         c.integrations_list = integrations
         c.available_integrations = integration_type_registry
 
         return self._get_template_context(c)
 
     def _settings_get(self, defaults=None, form=None):
         """
         View that displays the integration settings as a form.
         """
         c = self.load_default_context()
 
         defaults = defaults or self._form_defaults()
         schema = self._form_schema()
 
         if self.integration:
             buttons = ('submit', 'delete')
         else:
             buttons = ('submit',)
 
         form = form or deform.Form(schema, appstruct=defaults, buttons=buttons)
 
         c.form = form
         c.current_IntegrationType = self.IntegrationType
         c.integration = self.integration
 
         return self._get_template_context(c)
 
     def _settings_post(self):
         """
         View that validates and stores the integration settings.
         """
         _ = self.request.translate
 
         controls = self.request.POST.items()
         pstruct = peppercorn.parse(controls)
 
         if self.integration and pstruct.get('delete'):
             return self._delete_integration(self.integration)
 
         schema = self._form_schema()
 
         skip_settings_validation = False
         if self.integration and 'enabled' not in pstruct.get('options', {}):
             skip_settings_validation = True
             schema['settings'].validator = None
             for field in schema['settings'].children:
                 field.validator = None
                 field.missing = ''
 
         if self.integration:
             buttons = ('submit', 'delete')
         else:
             buttons = ('submit',)
 
         form = deform.Form(schema, buttons=buttons)
 
         if not self.admin_view:
             # scope is read only field in these cases, and has to be added
             options = pstruct.setdefault('options', {})
             if 'scope' not in options:
                 options['scope'] = IntegrationScopeType().serialize(None, {
                     'repo': self.repo,
                     'repo_group': self.repo_group,
                 })
 
         try:
             valid_data = form.validate_pstruct(pstruct)
         except deform.ValidationFailure as e:
             h.flash(
                 _('Errors exist when saving integration settings. '
                   'Please check the form inputs.'),
                 category='error')
             return self._settings_get(form=e)
 
         if not self.integration:
             self.integration = Integration()
             self.integration.integration_type = self.IntegrationType.key
             Session().add(self.integration)
 
         scope = valid_data['options']['scope']
 
         IntegrationModel().update_integration(self.integration,
             name=valid_data['options']['name'],
             enabled=valid_data['options']['enabled'],
             settings=valid_data['settings'],
             repo=scope['repo'],
             repo_group=scope['repo_group'],
             child_repos_only=scope['child_repos_only'],
         )
 
         self.integration.settings = valid_data['settings']
         Session().commit()
         # Display success message and redirect.
         h.flash(
             _('Integration {integration_name} updated successfully.').format(
                 integration_name=self.IntegrationType.display_name),
             category='success')
 
         # if integration scope changes, we must redirect to the right place
         # keeping in mind if the original view was for /repo/ or /_admin/
         admin_view = not (self.repo or self.repo_group)
 
         if self.integration.repo and not admin_view:
             redirect_to = self.request.route_path(
                 'repo_integrations_edit',
                 repo_name=self.integration.repo.repo_name,
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
         elif self.integration.repo_group and not admin_view:
             redirect_to = self.request.route_path(
                 'repo_group_integrations_edit',
                 repo_group_name=self.integration.repo_group.group_name,
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
         else:
             redirect_to = self.request.route_path(
                 'global_integrations_edit',
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
 
         return HTTPFound(redirect_to)
 
     def _new_integration(self):
         c = self.load_default_context()
         c.available_integrations = integration_type_registry
         return self._get_template_context(c)
 
     def load_default_context(self):
         raise NotImplementedError()
 
 
 class GlobalIntegrationsView(IntegrationSettingsViewBase):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.repo = self.repo
         c.repo_group = self.repo_group
         c.navlist = navigation_list(self.request)
 
         return c
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def integration_list(self):
         return self._integration_list()
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def settings_get(self):
         return self._settings_get()
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     @CSRFRequired()
     def settings_post(self):
         return self._settings_post()
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def new_integration(self):
         return self._new_integration()
 
 
 class RepoIntegrationsView(IntegrationSettingsViewBase):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         c.repo = self.repo
         c.repo_group = self.repo_group
 
         self.db_repo = self.repo
         c.rhodecode_db_repo = self.repo
         c.repo_name = self.db_repo.repo_name
         c.repository_pull_requests = ScmModel().get_pull_requests(self.repo)
-
+        c.repository_is_user_following = ScmModel().is_following_repo(
+            c.repo_name, self._rhodecode_user.user_id)
         c.has_origin_repo_read_perm = False
         if self.db_repo.fork:
             c.has_origin_repo_read_perm = h.HasRepoPermissionAny(
                 'repository.write', 'repository.read', 'repository.admin')(
                 self.db_repo.fork.repo_name, 'summary fork link')
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     def integration_list(self):
         return self._integration_list()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     def settings_get(self):
         return self._settings_get()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     def settings_post(self):
         return self._settings_post()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     def new_integration(self):
         return self._new_integration()
 
 
 class RepoGroupIntegrationsView(IntegrationSettingsViewBase):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.repo = self.repo
         c.repo_group = self.repo_group
         c.navlist = navigation_list(self.request)
 
         return c
 
     @LoginRequired()
     @HasRepoGroupPermissionAnyDecorator('group.admin')
     def integration_list(self):
         return self._integration_list()
 
     @LoginRequired()
     @HasRepoGroupPermissionAnyDecorator('group.admin')
     def settings_get(self):
         return self._settings_get()
 
     @LoginRequired()
     @HasRepoGroupPermissionAnyDecorator('group.admin')
     @CSRFRequired()
     def settings_post(self):
         return self._settings_post()
 
     @LoginRequired()
     @HasRepoGroupPermissionAnyDecorator('group.admin')
     def new_integration(self):
         return self._new_integration()