events: added support for pull-request-comment and commit-comment events.

- allows chopts like actions on commits
- re organized events and code cleanups

rhodecode/templates/forms/checkbox_choice_desc.pt

@@ -0,0 +1,26 b''
+<div tal:define="css_class css_class|field.widget.css_class;
+                 style style|field.widget.style;
+                 oid oid|field.oid;
+                 inline getattr(field.widget, 'inline', False)"
+     tal:omit-tag="not inline">
+  ${field.start_sequence()}
+  <div tal:repeat="choice values | field.widget.values"
+       tal:omit-tag="inline"
+       class="checkbox">
+    <div tal:define="(value, title, help_block) choice">
+      <input tal:attributes="checked value in cstruct;
+                             class css_class;
+                             style style"
+             type="checkbox"
+             name="checkbox"
+             value="${value}"
+             id="${oid}-${repeat.choice.index}"/>
+      <label for="${oid}-${repeat.choice.index}"
+             tal:attributes="class inline and 'checkbox-inline'">
+        ${title}
+      </label>
+      <p tal:condition="help_block" class="help-block">${help_block}</p>
+    </div>
+  </div>
+  ${field.end_sequence()}
+</div>

rhodecode/events/__init__.py

@@ -1,78 +1,79 b''
 # Copyright (C) 2016-2020 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.threadlocal import get_current_registry
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 
 
 log = logging.getLogger(__name__)
 
 
 def trigger(event, registry=None):
     """
     Helper method to send an event. This wraps the pyramid logic to send an
     event.
     """
     # For the first step we are using pyramids thread locals here. If the
     # event mechanism works out as a good solution we should think about
     # passing the registry as an argument to get rid of it.
     event_name = event.__class__
     log.debug('event %s sent for execution', event_name)
     registry = registry or get_current_registry()
     registry.notify(event)
     log.debug('event %s triggered using registry %s', event_name, registry)
 
     # Send the events to integrations directly
     from rhodecode.integrations import integrations_event_handler
     if isinstance(event, RhodeCodeIntegrationEvent):
         integrations_event_handler(event)
 
 
 from rhodecode.events.user import (  # pragma: no cover
     UserPreCreate,
     UserPostCreate,
     UserPreUpdate,
     UserRegistered,
     UserPermissionsChange,
 )
 
 from rhodecode.events.repo import (  # pragma: no cover
     RepoEvent, RepoCommitCommentEvent,
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
     RepoPrePushEvent,   RepoPushEvent,
     RepoPrePullEvent,   RepoPullEvent,
 )
 
 from rhodecode.events.repo_group import (  # pragma: no cover
     RepoGroupEvent,
     RepoGroupCreateEvent,
     RepoGroupUpdateEvent,
     RepoGroupDeleteEvent,
 )
 
 from rhodecode.events.pullrequest import (  # pragma: no cover
     PullRequestEvent,
     PullRequestCreateEvent,
     PullRequestUpdateEvent,
     PullRequestCommentEvent,
     PullRequestReviewEvent,
     PullRequestMergeEvent,
     PullRequestCloseEvent,
+    PullRequestCommentEvent,
 )

rhodecode/events/base.py

@@ -1,118 +1,122 b''
 # Copyright (C) 2016-2020 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
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 from pyramid.threadlocal import get_current_request
 
 from rhodecode.lib.utils2 import AttributeDict
 
 
 # this is a user object to be used for events caused by the system (eg. shell)
 SYSTEM_USER = AttributeDict(dict(
     username='__SYSTEM__',
     user_id='__SYSTEM_ID__'
 ))
 
 log = logging.getLogger(__name__)
 
 
 class RhodecodeEvent(object):
     """
     Base event class for all RhodeCode events
     """
     name = "RhodeCodeEvent"
     no_url_set = '<no server_url available>'
 
     def __init__(self, request=None):
         self._request = request
         self.utc_timestamp = datetime.datetime.utcnow()
 
+    def __repr__(self):
+        return '<%s:(%s)>' % (self.__class__.__name__, self.name)
+
     def get_request(self):
         if self._request:
             return self._request
         return get_current_request()
 
     @LazyProperty
     def request(self):
         return self.get_request()
 
     @property
     def auth_user(self):
         if not self.request:
             return
 
         user = getattr(self.request, 'user', None)
         if user:
             return user
 
         api_user = getattr(self.request, 'rpc_user', None)
         if api_user:
             return api_user
 
     @property
     def actor(self):
         auth_user = self.auth_user
         if auth_user:
             instance = auth_user.get_instance()
             if not instance:
                 return AttributeDict(dict(
                     username=auth_user.username,
                     user_id=auth_user.user_id,
                 ))
             return instance
 
         return SYSTEM_USER
 
     @property
     def actor_ip(self):
         auth_user = self.auth_user
         if auth_user:
             return auth_user.ip_addr
         return '<no ip available>'
 
     @property
     def server_url(self):
         if self.request:
             try:
                 return self.request.route_url('home')
             except Exception:
                 log.exception('Failed to fetch URL for server')
                 return self.no_url_set
 
         return self.no_url_set
 
     def as_dict(self):
         data = {
             'name': self.name,
             'utc_timestamp': self.utc_timestamp,
             'actor_ip': self.actor_ip,
             'actor': {
                 'username': self.actor.username,
                 'user_id': self.actor.user_id
             },
             'server_url': self.server_url
         }
         return data
 
 
 class RhodeCodeIntegrationEvent(RhodecodeEvent):
     """
     Special subclass for Integration events
     """
+    description = ''

rhodecode/events/pullrequest.py

@@ -1,155 +1,164 b''
 # Copyright (C) 2016-2020 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 rhodecode.translation import lazy_ugettext
 from rhodecode.events.repo import (
     RepoEvent, _commits_as_dict, _issues_as_dict)
 
 log = logging.getLogger(__name__)
 
 
 class PullRequestEvent(RepoEvent):
     """
     Base class for pull request events.
 
     :param pullrequest: a :class:`PullRequest` instance
     """
 
     def __init__(self, pullrequest):
         super(PullRequestEvent, self).__init__(pullrequest.target_repo)
         self.pullrequest = pullrequest
 
     def as_dict(self):
         from rhodecode.lib.utils2 import md5_safe
         from rhodecode.model.pull_request import PullRequestModel
         data = super(PullRequestEvent, self).as_dict()
 
         commits = _commits_as_dict(
             self,
             commit_ids=self.pullrequest.revisions,
             repos=[self.pullrequest.source_repo]
         )
         issues = _issues_as_dict(commits)
         # calculate hashes of all commits for unique identifier of commits
         # inside that pull request
         commits_hash = md5_safe(':'.join(x.get('raw_id', '') for x in commits))
 
         data.update({
             'pullrequest': {
                 'title': self.pullrequest.title,
                 'issues': issues,
                 'pull_request_id': self.pullrequest.pull_request_id,
                 'url': PullRequestModel().get_url(
                     self.pullrequest, request=self.request),
                 'permalink_url': PullRequestModel().get_url(
                     self.pullrequest, request=self.request, permalink=True),
                 'shadow_url': PullRequestModel().get_shadow_clone_url(
                     self.pullrequest, request=self.request),
                 'status': self.pullrequest.calculated_review_status(),
                 'commits_uid': commits_hash,
                 'commits': commits,
             }
         })
         return data
 
 
 class PullRequestCreateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is created.
     """
     name = 'pullrequest-create'
     display_name = lazy_ugettext('pullrequest created')
+    description = lazy_ugettext('Event triggered after pull request was created')
 
 
 class PullRequestCloseEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is closed.
     """
     name = 'pullrequest-close'
     display_name = lazy_ugettext('pullrequest closed')
+    description = lazy_ugettext('Event triggered after pull request was closed')
 
 
 class PullRequestUpdateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request's commits have been updated.
     """
     name = 'pullrequest-update'
     display_name = lazy_ugettext('pullrequest commits updated')
+    description = lazy_ugettext('Event triggered after pull requests was updated')
 
 
 class PullRequestReviewEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request review has changed. A status defines new status of review.
     """
     name = 'pullrequest-review'
     display_name = lazy_ugettext('pullrequest review changed')
+    description = lazy_ugettext('Event triggered after a review status of a '
+                                'pull requests has changed to other.')
 
     def __init__(self, pullrequest, status):
         super(PullRequestReviewEvent, self).__init__(pullrequest)
         self.status = status
 
 
 class PullRequestMergeEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is merged.
     """
     name = 'pullrequest-merge'
     display_name = lazy_ugettext('pullrequest merged')
+    description = lazy_ugettext('Event triggered after a successful merge operation '
+                                'was executed on a pull request')
 
 
 class PullRequestCommentEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request comment is created.
     """
     name = 'pullrequest-comment'
     display_name = lazy_ugettext('pullrequest commented')
+    description = lazy_ugettext('Event triggered after a comment was made on a code '
+                                'in the pull request')
 
     def __init__(self, pullrequest, comment):
         super(PullRequestCommentEvent, self).__init__(pullrequest)
         self.comment = comment
 
     def as_dict(self):
         from rhodecode.model.comment import CommentsModel
         data = super(PullRequestCommentEvent, self).as_dict()
 
         status = None
         if self.comment.status_change:
             status = self.comment.status_change[0].status
 
         data.update({
             'comment': {
                 'status': status,
                 'text': self.comment.text,
                 'type': self.comment.comment_type,
                 'file': self.comment.f_path,
                 'line': self.comment.line_no,
                 'url': CommentsModel().get_url(
                     self.comment, request=self.request),
                 'permalink_url': CommentsModel().get_url(
                     self.comment, request=self.request, permalink=True),
             }
         })
         return data

rhodecode/events/repo.py

@@ -1,370 +1,400 b''
 # Copyright (C) 2016-2020 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 collections
 import logging
 import datetime
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.model.db import User, Repository, Session
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
 
 def _commits_as_dict(event, commit_ids, repos):
     """
     Helper function to serialize commit_ids
 
     :param event: class calling this method
     :param commit_ids: commits to get
     :param repos: list of repos to check
     """
     from rhodecode.lib.utils2 import extract_mentioned_users
     from rhodecode.lib.helpers import (
         urlify_commit_message, process_patterns, chop_at_smart)
     from rhodecode.model.repo import RepoModel
 
     if not repos:
         raise Exception('no repo defined')
 
     if not isinstance(repos, (tuple, list)):
         repos = [repos]
 
     if not commit_ids:
         return []
 
     needed_commits = list(commit_ids)
 
     commits = []
     reviewers = []
     for repo in repos:
         if not needed_commits:
             return commits  # return early if we have the commits we need
 
         vcs_repo = repo.scm_instance(cache=False)
 
         try:
             # use copy of needed_commits since we modify it while iterating
             for commit_id in list(needed_commits):
                 if commit_id.startswith('tag=>'):
                     raw_id = commit_id[5:]
                     cs_data = {
                         'raw_id': commit_id, 'short_id': commit_id,
                         'branch': None,
                         'git_ref_change': 'tag_add',
                         'message': 'Added new tag {}'.format(raw_id),
                         'author': event.actor.full_contact,
                         'date': datetime.datetime.now(),
                         'refs': {
                             'branches': [],
                             'bookmarks': [],
                             'tags': []
                         }
                     }
                     commits.append(cs_data)
 
                 elif commit_id.startswith('delete_branch=>'):
                     raw_id = commit_id[15:]
                     cs_data = {
                         'raw_id': commit_id, 'short_id': commit_id,
                         'branch': None,
                         'git_ref_change': 'branch_delete',
                         'message': 'Deleted branch {}'.format(raw_id),
                         'author': event.actor.full_contact,
                         'date': datetime.datetime.now(),
                         'refs': {
                             'branches': [],
                             'bookmarks': [],
                             'tags': []
                         }
                     }
                     commits.append(cs_data)
 
                 else:
                     try:
                         cs = vcs_repo.get_commit(commit_id)
                     except CommitDoesNotExistError:
                         continue  # maybe its in next repo
 
                     cs_data = cs.__json__()
                     cs_data['refs'] = cs._get_refs()
 
                 cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
                 cs_data['reviewers'] = reviewers
                 cs_data['url'] = RepoModel().get_commit_url(
                     repo, cs_data['raw_id'], request=event.request)
                 cs_data['permalink_url'] = RepoModel().get_commit_url(
                     repo, cs_data['raw_id'], request=event.request,
                     permalink=True)
                 urlified_message, issues_data = process_patterns(
                     cs_data['message'], repo.repo_name)
                 cs_data['issues'] = issues_data
                 cs_data['message_html'] = urlify_commit_message(
                     cs_data['message'], repo.repo_name)
                 cs_data['message_html_title'] = chop_at_smart(
                     cs_data['message'], '\n', suffix_if_chopped='...')
                 commits.append(cs_data)
 
                 needed_commits.remove(commit_id)
 
         except Exception:
             log.exception('Failed to extract commits data')
             # we don't send any commits when crash happens, only full list
             # matters we short circuit then.
             return []
 
     missing_commits = set(commit_ids) - set(c['raw_id'] for c in commits)
     if missing_commits:
         log.error('Inconsistent repository state. '
                   'Missing commits: %s', ', '.join(missing_commits))
 
     return commits
 
 
 def _issues_as_dict(commits):
     """ Helper function to serialize issues from commits """
     issues = {}
     for commit in commits:
         for issue in commit['issues']:
             issues[issue['id']] = issue
     return issues
 
 
 class RepoEvent(RhodeCodeIntegrationEvent):
     """
     Base class for events acting on a repository.
 
     :param repo: a :class:`Repository` instance
     """
 
     def __init__(self, repo):
         super(RepoEvent, self).__init__()
         self.repo = repo
 
     def as_dict(self):
         from rhodecode.model.repo import RepoModel
         data = super(RepoEvent, self).as_dict()
 
         extra_fields = collections.OrderedDict()
         for field in self.repo.extra_fields:
             extra_fields[field.field_key] = field.field_value
 
         data.update({
             'repo': {
                 'repo_id': self.repo.repo_id,
                 'repo_name': self.repo.repo_name,
                 'repo_type': self.repo.repo_type,
                 'url': RepoModel().get_url(
                     self.repo, request=self.request),
                 'permalink_url': RepoModel().get_url(
                     self.repo, request=self.request, permalink=True),
                 'extra_fields': extra_fields
             }
         })
         return data
 
 
 class RepoCommitCommentEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` after a comment is made
     on repository commit.
     """
+
+    name = 'repo-commit-comment'
+    display_name = lazy_ugettext('repository commit comment')
+    description = lazy_ugettext('Event triggered after a comment was made '
+                                'on commit inside a repository')
+
     def __init__(self, repo, commit, comment):
         super(RepoCommitCommentEvent, self).__init__(repo)
         self.commit = commit
         self.comment = comment
 
-    name = 'repo-commit-comment'
-    display_name = lazy_ugettext('repository commit comment')
+    def as_dict(self):
+        data = super(RepoCommitCommentEvent, self).as_dict()
+        data['commit'] = {
+            'commit_id': self.commit.raw_id,
+            'commit_message': self.commit.message,
+            'commit_branch': self.commit.branch,
+        }
+
+        data['comment'] = {
+            'comment_id': self.comment.comment_id,
+            'comment_text': self.comment.text,
+            'comment_type': self.comment.comment_type,
+            'comment_f_path': self.comment.f_path,
+            'comment_line_no': self.comment.line_no,
+        }
+        return data
 
 
 class RepoPreCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` before a repo is
     created.
     """
     name = 'repo-pre-create'
     display_name = lazy_ugettext('repository pre create')
+    description = lazy_ugettext('Event triggered before repository is created')
 
 
 class RepoCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-create'
     display_name = lazy_ugettext('repository created')
+    description = lazy_ugettext('Event triggered after repository was created')
 
 
 class RepoPreDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-pre-delete'
     display_name = lazy_ugettext('repository pre delete')
+    description = lazy_ugettext('Event triggered before a repository is deleted')
 
 
 class RepoDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-delete'
     display_name = lazy_ugettext('repository deleted')
+    description = lazy_ugettext('Event triggered after repository was deleted')
 
 
 class RepoVCSEvent(RepoEvent):
     """
     Base class for events triggered by the VCS
     """
     def __init__(self, repo_name, extras):
         self.repo = Repository.get_by_repo_name(repo_name)
         if not self.repo:
             raise Exception('repo by this name %s does not exist' % repo_name)
         self.extras = extras
         super(RepoVCSEvent, self).__init__(self.repo)
 
     @property
     def actor(self):
         if self.extras.get('username'):
             return User.get_by_username(self.extras['username'])
 
     @property
     def actor_ip(self):
         if self.extras.get('ip'):
             return self.extras['ip']
 
     @property
     def server_url(self):
         if self.extras.get('server_url'):
             return self.extras['server_url']
 
     @property
     def request(self):
         return self.extras.get('request') or self.get_request()
 
 
 class RepoPrePullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pulled from a repo.
     """
     name = 'repo-pre-pull'
     display_name = lazy_ugettext('repository pre pull')
+    description = lazy_ugettext('Event triggered before repository code is pulled')
 
 
 class RepoPullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pulled from a repo.
     """
     name = 'repo-pull'
     display_name = lazy_ugettext('repository pull')
+    description = lazy_ugettext('Event triggered after repository code was pulled')
 
 
 class RepoPrePushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pushed to a repo.
     """
     name = 'repo-pre-push'
     display_name = lazy_ugettext('repository pre push')
+    description = lazy_ugettext('Event triggered before the code is '
+                                'pushed to a repository')
 
 
 class RepoPushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pushed to a repo.
 
     :param extras: (optional) dict of data from proxied VCS actions
     """
     name = 'repo-push'
     display_name = lazy_ugettext('repository push')
+    description = lazy_ugettext('Event triggered after the code was '
+                                'pushed to a repository')
 
     def __init__(self, repo_name, pushed_commit_ids, extras):
         super(RepoPushEvent, self).__init__(repo_name, extras)
         self.pushed_commit_ids = pushed_commit_ids
         self.new_refs = extras.new_refs
 
     def as_dict(self):
         data = super(RepoPushEvent, self).as_dict()
 
         def branch_url(branch_name):
             return '{}/changelog?branch={}'.format(
                 data['repo']['url'], branch_name)
 
         def tag_url(tag_name):
             return '{}/files/{}/'.format(
                 data['repo']['url'], tag_name)
 
         commits = _commits_as_dict(
             self, commit_ids=self.pushed_commit_ids, repos=[self.repo])
 
         last_branch = None
         for commit in reversed(commits):
             commit['branch'] = commit['branch'] or last_branch
             last_branch = commit['branch']
         issues = _issues_as_dict(commits)
 
         branches = set()
         tags = set()
         for commit in commits:
             if commit['refs']['tags']:
                 for tag in commit['refs']['tags']:
                     tags.add(tag)
             if commit['branch']:
                 branches.add(commit['branch'])
 
         # maybe we have branches in new_refs ?
         try:
             branches = branches.union(set(self.new_refs['branches']))
         except Exception:
             pass
 
         branches = [
             {
                 'name': branch,
                 'url': branch_url(branch)
             }
             for branch in branches
         ]
 
         # maybe we have branches in new_refs ?
         try:
             tags = tags.union(set(self.new_refs['tags']))
         except Exception:
             pass
 
         tags = [
             {
                 'name': tag,
                 'url': tag_url(tag)
             }
             for tag in tags
         ]
 
         data['push'] = {
             'commits': commits,
             'issues': issues,
             'branches': branches,
             'tags': tags,
         }
         return data

rhodecode/events/repo_group.py

@@ -1,80 +1,83 b''
 # Copyright (C) 2016-2020 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 rhodecode.translation import lazy_ugettext
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 
 
 log = logging.getLogger(__name__)
 
 
 class RepoGroupEvent(RhodeCodeIntegrationEvent):
     """
     Base class for events acting on a repository group.
 
     :param repo: a :class:`RepositoryGroup` instance
     """
 
     def __init__(self, repo_group):
         super(RepoGroupEvent, self).__init__()
         self.repo_group = repo_group
 
     def as_dict(self):
         data = super(RepoGroupEvent, self).as_dict()
         data.update({
             'repo_group': {
                 'group_id': self.repo_group.group_id,
                 'group_name': self.repo_group.group_name,
                 'group_parent_id': self.repo_group.group_parent_id,
                 'group_description': self.repo_group.group_description,
                 'user_id': self.repo_group.user_id,
                 'created_by': self.repo_group.user.username,
                 'created_on': self.repo_group.created_on,
                 'enable_locking': self.repo_group.enable_locking,
             }
         })
         return data
 
 
 class RepoGroupCreateEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is created.
     """
     name = 'repo-group-create'
     display_name = lazy_ugettext('repository group created')
+    description = lazy_ugettext('Event triggered after a repository group was created')
 
 
 class RepoGroupDeleteEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is deleted.
     """
     name = 'repo-group-delete'
     display_name = lazy_ugettext('repository group deleted')
+    description = lazy_ugettext('Event triggered after a repository group was deleted')
 
 
 class RepoGroupUpdateEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is updated.
     """
     name = 'repo-group-update'
     display_name = lazy_ugettext('repository group update')
+    description = lazy_ugettext('Event triggered after a repository group was updated')

rhodecode/integrations/types/base.py

@@ -1,363 +1,428 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import string
 import collections
 import logging
 import requests
 import urllib
 from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
 
 from mako import exceptions
 
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 
 class UrlTmpl(string.Template):
 
     def safe_substitute(self, **kws):
         # url encode the kw for usage in url
         kws = {k: urllib.quote(safe_str(v)) for k, v in kws.items()}
         return super(UrlTmpl, self).safe_substitute(**kws)
 
 
 class IntegrationTypeBase(object):
     """ Base class for IntegrationType plugins """
     is_dummy = False
     description = ''
 
     @classmethod
     def icon(cls):
         return '''
         <?xml version="1.0" encoding="UTF-8" standalone="no"?>
         <svg
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:cc="http://creativecommons.org/ns#"
            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:svg="http://www.w3.org/2000/svg"
            xmlns="http://www.w3.org/2000/svg"
            xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
            xmlns:inkscape="http://setwww.inkscape.org/namespaces/inkscape"
            viewBox="0 -256 1792 1792"
            id="svg3025"
            version="1.1"
            inkscape:version="0.48.3.1 r9886"
            width="100%"
            height="100%"
            sodipodi:docname="cog_font_awesome.svg">
           <metadata
              id="metadata3035">
             <rdf:RDF>
               <cc:Work
                  rdf:about="">
                 <dc:format>image/svg+xml</dc:format>
                 <dc:type
                    rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
               </cc:Work>
             </rdf:RDF>
           </metadata>
           <defs
              id="defs3033" />
           <sodipodi:namedview
              pagecolor="#ffffff"
              bordercolor="#666666"
              borderopacity="1"
              objecttolerance="10"
              gridtolerance="10"
              guidetolerance="10"
              inkscape:pageopacity="0"
              inkscape:pageshadow="2"
              inkscape:window-width="640"
              inkscape:window-height="480"
              id="namedview3031"
              showgrid="false"
              inkscape:zoom="0.13169643"
              inkscape:cx="896"
              inkscape:cy="896"
              inkscape:window-x="0"
              inkscape:window-y="25"
              inkscape:window-maximized="0"
              inkscape:current-layer="svg3025" />
           <g
              transform="matrix(1,0,0,-1,121.49153,1285.4237)"
              id="g3027">
             <path
                d="m 1024,640 q 0,106 -75,181 -75,75 -181,75 -106,0 -181,-75 -75,-75 -75,-181 0,-106 75,-181 75,-75 181,-75 106,0 181,75 75,75 75,181 z m 512,109 V 527 q 0,-12 -8,-23 -8,-11 -20,-13 l -185,-28 q -19,-54 -39,-91 35,-50 107,-138 10,-12 10,-25 0,-13 -9,-23 -27,-37 -99,-108 -72,-71 -94,-71 -12,0 -26,9 l -138,108 q -44,-23 -91,-38 -16,-136 -29,-186 -7,-28 -36,-28 H 657 q -14,0 -24.5,8.5 Q 622,-111 621,-98 L 593,86 q -49,16 -90,37 L 362,16 Q 352,7 337,7 323,7 312,18 186,132 147,186 q -7,10 -7,23 0,12 8,23 15,21 51,66.5 36,45.5 54,70.5 -27,50 -41,99 L 29,495 Q 16,497 8,507.5 0,518 0,531 v 222 q 0,12 8,23 8,11 19,13 l 186,28 q 14,46 39,92 -40,57 -107,138 -10,12 -10,24 0,10 9,23 26,36 98.5,107.5 72.5,71.5 94.5,71.5 13,0 26,-10 l 138,-107 q 44,23 91,38 16,136 29,186 7,28 36,28 h 222 q 14,0 24.5,-8.5 Q 914,1391 915,1378 l 28,-184 q 49,-16 90,-37 l 142,107 q 9,9 24,9 13,0 25,-10 129,-119 165,-170 7,-8 7,-22 0,-12 -8,-23 -15,-21 -51,-66.5 -36,-45.5 -54,-70.5 26,-50 41,-98 l 183,-28 q 13,-2 21,-12.5 8,-10.5 8,-23.5 z"
                id="path3029"
                inkscape:connector-curvature="0"
                style="fill:currentColor" />
           </g>
         </svg>
         '''
 
     def __init__(self, settings):
         """
         :param settings: dict of settings to be used for the integration
         """
         self.settings = settings
 
     def settings_schema(self):
         """
         A colander schema of settings for the integration type
         """
         return colander.Schema()
 
+    def event_enabled(self, event):
+        """
+        Checks if submitted event is enabled based on the plugin settings
+        :param event:
+        :return: bool
+        """
+        allowed_events = self.settings['events']
+        if event.name not in allowed_events:
+            log.debug('event ignored: %r event %s not in allowed set of events %s',
+                      event, event.name, allowed_events)
+            return False
+        return True
+
 
 class EEIntegration(IntegrationTypeBase):
     description = 'Integration available in RhodeCode EE edition.'
     is_dummy = True
 
     def __init__(self, name, key, settings=None):
         self.display_name = name
         self.key = key
         super(EEIntegration, self).__init__(settings)
 
 
 # Helpers #
 # updating this required to update the `common_vars` as well.
 WEBHOOK_URL_VARS = [
+    # GENERAL
+    ('General', [
     ('event_name', 'Unique name of the event type, e.g pullrequest-update'),
     ('repo_name', 'Full name of the repository'),
     ('repo_type', 'VCS type of repository'),
     ('repo_id', 'Unique id of repository'),
     ('repo_url', 'Repository url'),
+        ]
+    ),
     # extra repo fields
+    ('Repository', [
     ('extra:<extra_key_name>', 'Extra repo variables, read from its settings.'),
-
+        ]
+    ),
     # special attrs below that we handle, using multi-call
+    ('Commit push - Multicalls', [
     ('branch', 'Name of each branch submitted, if any.'),
     ('branch_head', 'Head ID of pushed branch (full sha of last commit), if any.'),
     ('commit_id', 'ID (full sha) of each commit submitted, if any.'),
-
+        ]
+    ),
     # pr events vars
+    ('Pull request', [
     ('pull_request_id', 'Unique ID of the pull request.'),
     ('pull_request_title', 'Title of the pull request.'),
     ('pull_request_url', 'Pull request url.'),
     ('pull_request_shadow_url', 'Pull request shadow repo clone url.'),
     ('pull_request_commits_uid', 'Calculated UID of all commits inside the PR. '
                                  'Changes after PR update'),
+        ]
+    ),
+    # commit comment event vars
+    ('Commit comment', [
+        ('commit_comment_id', 'Unique ID of the comment made on a commit.'),
+        ('commit_comment_text', 'Text of commit comment.'),
+        ('commit_comment_type', 'Type of comment, e.g note/todo.'),
 
+        ('commit_comment_f_path', 'Optionally path of file for inline comments.'),
+        ('commit_comment_line_no', 'Line number of the file: eg o10, or n200'),
+
+        ('commit_comment_commit_id', 'Commit id that comment was left at.'),
+        ('commit_comment_commit_branch', 'Commit branch that comment was left at'),
+        ('commit_comment_commit_message', 'Commit message that comment was left at'),
+        ]
+    ),
     # user who triggers the call
+    ('Caller', [
     ('username', 'User who triggered the call.'),
     ('user_id', 'User id who triggered the call.'),
 ]
+    ),
+]
 
 # common vars for url template used for CI plugins. Shared with webhook
 CI_URL_VARS = WEBHOOK_URL_VARS
 
 
 class CommitParsingDataHandler(object):
 
     def aggregate_branch_data(self, branches, commits):
         branch_data = collections.OrderedDict()
         for obj in branches:
             branch_data[obj['name']] = obj
 
         branches_commits = collections.OrderedDict()
         for commit in commits:
             if commit.get('git_ref_change'):
                 # special case for GIT that allows creating tags,
                 # deleting branches without associated commit
                 continue
             commit_branch = commit['branch']
 
             if commit_branch not in branches_commits:
                 _branch = branch_data[commit_branch] \
                     if commit_branch else commit_branch
                 branch_commits = {'branch': _branch,
                                   'branch_head': '',
                                   'commits': []}
                 branches_commits[commit_branch] = branch_commits
 
             branch_commits = branches_commits[commit_branch]
             branch_commits['commits'].append(commit)
             branch_commits['branch_head'] = commit['raw_id']
         return branches_commits
 
 
 class WebhookDataHandler(CommitParsingDataHandler):
     name = 'webhook'
 
     def __init__(self, template_url, headers):
         self.template_url = template_url
         self.headers = headers
 
     def get_base_parsed_template(self, data):
         """
         initially parses the passed in template with some common variables
         available on ALL calls
         """
         # note: make sure to update the `WEBHOOK_URL_VARS` if this changes
         common_vars = {
             'repo_name': data['repo']['repo_name'],
             'repo_type': data['repo']['repo_type'],
             'repo_id': data['repo']['repo_id'],
             'repo_url': data['repo']['url'],
             'username': data['actor']['username'],
             'user_id': data['actor']['user_id'],
             'event_name': data['name']
         }
 
         extra_vars = {}
         for extra_key, extra_val in data['repo']['extra_fields'].items():
             extra_vars['extra__{}'.format(extra_key)] = extra_val
         common_vars.update(extra_vars)
 
         template_url = self.template_url.replace('${extra:', '${extra__')
         for k, v in common_vars.items():
             template_url = UrlTmpl(template_url).safe_substitute(**{k: v})
         return template_url
 
     def repo_push_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         url_calls = []
 
         branches_commits = self.aggregate_branch_data(
             data['push']['branches'], data['push']['commits'])
         if '${branch}' in url or '${branch_head}' in url or '${commit_id}' in url:
             # call it multiple times, for each branch if used in variables
             for branch, commit_ids in branches_commits.items():
                 branch_url = UrlTmpl(url).safe_substitute(branch=branch)
 
                 if '${branch_head}' in branch_url:
                     # last commit in the aggregate is the head of the branch
                     branch_head = commit_ids['branch_head']
                     branch_url = UrlTmpl(branch_url).safe_substitute(branch_head=branch_head)
 
                 # call further down for each commit if used
                 if '${commit_id}' in branch_url:
                     for commit_data in commit_ids['commits']:
                         commit_id = commit_data['raw_id']
                         commit_url = UrlTmpl(branch_url).safe_substitute(commit_id=commit_id)
                         # register per-commit call
                         log.debug(
                             'register %s call(%s) to url %s',
                             self.name, event, commit_url)
                         url_calls.append(
                             (commit_url, self.headers, data))
 
                 else:
                     # register per-branch call
                     log.debug('register %s call(%s) to url %s',
                               self.name, event, branch_url)
                     url_calls.append((branch_url, self.headers, data))
 
         else:
             log.debug('register %s call(%s) to url %s', self.name, event, url)
             url_calls.append((url, self.headers, data))
 
         return url_calls
 
+    def repo_commit_comment_handler(self, event, data):
+        url = self.get_base_parsed_template(data)
+        log.debug('register %s call(%s) to url %s', self.name, event, url)
+        comment_vars = [
+            ('commit_comment_id', data['comment']['comment_id']),
+            ('commit_comment_text', data['comment']['comment_text']),
+            ('commit_comment_type', data['comment']['comment_type']),
+
+            ('commit_comment_f_path', data['comment']['comment_f_path']),
+            ('commit_comment_line_no', data['comment']['comment_line_no']),
+
+            ('commit_comment_commit_id', data['commit']['commit_id']),
+            ('commit_comment_commit_branch', data['commit']['commit_branch']),
+            ('commit_comment_commit_message', data['commit']['commit_message']),
+        ]
+        for k, v in comment_vars:
+            url = UrlTmpl(url).safe_substitute(**{k: v})
+
+        return [(url, self.headers, data)]
+
     def repo_create_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         log.debug('register %s call(%s) to url %s', self.name, event, url)
         return [(url, self.headers, data)]
 
     def pull_request_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         log.debug('register %s call(%s) to url %s', self.name, event, url)
         pr_vars = [
             ('pull_request_id', data['pullrequest']['pull_request_id']),
             ('pull_request_title', data['pullrequest']['title']),
             ('pull_request_url', data['pullrequest']['url']),
             ('pull_request_shadow_url', data['pullrequest']['shadow_url']),
             ('pull_request_commits_uid', data['pullrequest']['commits_uid']),
         ]
         for k, v in pr_vars:
             url = UrlTmpl(url).safe_substitute(**{k: v})
 
         return [(url, self.headers, data)]
 
     def __call__(self, event, data):
         from rhodecode import events
 
         if isinstance(event, events.RepoPushEvent):
             return self.repo_push_event_handler(event, data)
         elif isinstance(event, events.RepoCreateEvent):
             return self.repo_create_event_handler(event, data)
+        elif isinstance(event, events.RepoCommitCommentEvent):
+            return self.repo_commit_comment_handler(event, data)
         elif isinstance(event, events.PullRequestEvent):
             return self.pull_request_event_handler(event, data)
         else:
             raise ValueError(
-                'event type `%s` not in supported list: %s' % (
-                    event.__class__, events))
+                'event type `{}` has no handler defined'.format(event.__class__))
 
 
 def get_auth(settings):
     from requests.auth import HTTPBasicAuth
     username = settings.get('username')
     password = settings.get('password')
     if username and password:
         return HTTPBasicAuth(username, password)
     return None
 
 
 def get_web_token(settings):
     return settings['secret_token']
 
 
 def get_url_vars(url_vars):
-    return '\n'.join(
-        '{} - {}'.format('${' + key + '}', explanation)
-        for key, explanation in url_vars)
+    items = []
+
+    for section, section_items in url_vars:
+        items.append('\n*{}*'.format(section))
+        for key, explanation in section_items:
+            items.append('  {} - {}'.format('${' + key + '}', explanation))
+    return '\n'.join(items)
 
 
 def render_with_traceback(template, *args, **kwargs):
     try:
         return template.render(*args, **kwargs)
     except Exception:
         log.error(exceptions.text_error_template().render())
         raise
 
 
 STATUS_400 = (400, 401, 403)
 STATUS_500 = (500, 502, 504)
 
 
 def requests_retry_call(
         retries=3, backoff_factor=0.3, status_forcelist=STATUS_400+STATUS_500,
         session=None):
     """
     session = requests_retry_session()
     response = session.get('http://example.com')
 
     :param retries:
     :param backoff_factor:
     :param status_forcelist:
     :param session:
     """
     session = session or requests.Session()
     retry = Retry(
         total=retries,
         read=retries,
         connect=retries,
         backoff_factor=backoff_factor,
         status_forcelist=status_forcelist,
     )
     adapter = HTTPAdapter(max_retries=retry)
     session.mount('http://', adapter)
     session.mount('https://', adapter)
     return session

rhodecode/integrations/types/email.py

@@ -1,298 +1,330 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 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 __future__ import unicode_literals
-import deform
 import logging
+
 import colander
-
+import deform.widget
 from mako.template import Template
 
 from rhodecode import events
+from rhodecode.model.validation_schema.widgets import CheckboxChoiceWidgetDesc
 from rhodecode.translation import _
 from rhodecode.lib.celerylib import run_task
 from rhodecode.lib.celerylib import tasks
 from rhodecode.integrations.types.base import (
     IntegrationTypeBase, render_with_traceback)
 
 
 log = logging.getLogger(__name__)
 
 REPO_PUSH_TEMPLATE_PLAINTEXT = Template('''
 Commits:
 
 % for commit in data['push']['commits']:
 ${commit['url']} by ${commit['author']} at ${commit['date']}
 ${commit['message']}
 ----
 
 % endfor
 ''')
 
 REPO_PUSH_TEMPLATE_HTML = Template('''
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
     <title>${subject}</title>
     <style type="text/css">
         /* Based on The MailChimp Reset INLINE: Yes. */
         #outlook a {padding:0;} /* Force Outlook to provide a "view in browser" menu link. */
         body{width:100% !important; -webkit-text-size-adjust:100%; -ms-text-size-adjust:100%; margin:0; padding:0;}
         /* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/
         .ExternalClass {width:100%;} /* Force Hotmail to display emails at full width */
         .ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}
         /* Forces Hotmail to display normal line spacing.  More on that: http://www.emailonacid.com/forum/viewthread/43/ */
         #backgroundTable {margin:0; padding:0; line-height: 100% !important;}
         /* End reset */
 
         /* defaults for images*/
         img {outline:none; text-decoration:none; -ms-interpolation-mode: bicubic;}
         a img {border:none;}
         .image_fix {display:block;}
 
         body {line-height:1.2em;}
         p {margin: 0 0 20px;}
         h1, h2, h3, h4, h5, h6 {color:#323232!important;}
         a {color:#427cc9;text-decoration:none;outline:none;cursor:pointer;}
         a:focus {outline:none;}
         a:hover {color: #305b91;}
         h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {color:#427cc9!important;text-decoration:none!important;}
         h1 a:active, h2 a:active,  h3 a:active, h4 a:active, h5 a:active, h6 a:active {color: #305b91!important;}
         h1 a:visited, h2 a:visited,  h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {color: #305b91!important;}
         table {font-size:13px;border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;}
         table td {padding:.65em 1em .65em 0;border-collapse:collapse;vertical-align:top;text-align:left;}
         input {display:inline;border-radius:2px;border-style:solid;border: 1px solid #dbd9da;padding:.5em;}
         input:focus {outline: 1px solid #979797}
         @media only screen and (-webkit-min-device-pixel-ratio: 2) {
         /* Put your iPhone 4g styles in here */
         }
 
         /* Android targeting */
         @media only screen and (-webkit-device-pixel-ratio:.75){
         /* Put CSS for low density (ldpi) Android layouts in here */
         }
         @media only screen and (-webkit-device-pixel-ratio:1){
         /* Put CSS for medium density (mdpi) Android layouts in here */
         }
         @media only screen and (-webkit-device-pixel-ratio:1.5){
         /* Put CSS for high density (hdpi) Android layouts in here */
         }
         /* end Android targeting */
 
     </style>
 
     <!-- Targeting Windows Mobile -->
     <!--[if IEMobile 7]>
     <style type="text/css">
 
     </style>
     <![endif]-->
 
     <!--[if gte mso 9]>
         <style>
         /* Target Outlook 2007 and 2010 */
         </style>
     <![endif]-->
 </head>
 <body>
 <!-- Wrapper/Container Table: Use a wrapper table to control the width and the background color consistently of your email. Use this approach instead of setting attributes on the body tag. -->
 <table cellpadding="0" cellspacing="0" border="0" id="backgroundTable" align="left" style="margin:1%;width:97%;padding:0;font-family:sans-serif;font-weight:100;border:1px solid #dbd9da">
     <tr>
         <td valign="top" style="padding:0;">
             <table cellpadding="0" cellspacing="0" border="0" align="left" width="100%">
                 <tr><td style="width:100%;padding:7px;background-color:#202020" valign="top">
                     <a style="color:#eeeeee;text-decoration:none;" href="${instance_url}">
                         ${'RhodeCode'}
                     </a>
                 </td></tr>
                 <tr>
                     <td style="padding:15px;" valign="top">
                         % if data['push']['commits']:
                             % for commit in data['push']['commits']:
                             <a href="${commit['url']}">${commit['short_id']}</a> by ${commit['author']} at ${commit['date']} <br/>
                             ${commit['message_html']} <br/>
                             <br/>
                             % endfor
                         % else:
                             No commit data
                         % endif
                     </td>
                 </tr>
             </table>
         </td>
     </tr>
 </table>
 <!-- End of wrapper table -->
 <p><a style="margin-top:15px;margin-left:1%;font-family:sans-serif;font-weight:100;font-size:11px;color:#666666;text-decoration:none;" href="${instance_url}">
     ${'This is a notification from RhodeCode. %(instance_url)s' % {'instance_url': instance_url}}
 </a></p>
 </body>
 </html>
 ''')
 
 
 class EmailSettingsSchema(colander.Schema):
     @colander.instantiate(validator=colander.Length(min=1))
     class recipients(colander.SequenceSchema):
         title = _('Recipients')
         description = _('Email addresses to send push events to')
         widget = deform.widget.SequenceWidget(min_len=1)
 
         recipient = colander.SchemaNode(
             colander.String(),
             title=_('Email address'),
             description=_('Email address'),
             default='',
             validator=colander.Email(),
             widget=deform.widget.TextInputWidget(
                 placeholder='[e-mail]',
             ),
         )
 
 
 class EmailIntegrationType(IntegrationTypeBase):
     key = 'email'
     display_name = _('Email')
     description = _('Send repo push summaries to a list of recipients via email')
 
+    valid_events = [
+        events.RepoPushEvent
+    ]
+
     @classmethod
     def icon(cls):
         return '''
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <svg
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:cc="http://creativecommons.org/ns#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:svg="http://www.w3.org/2000/svg"
    xmlns="http://www.w3.org/2000/svg"
    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
    viewBox="0 -256 1850 1850"
    id="svg2989"
    version="1.1"
    inkscape:version="0.48.3.1 r9886"
    width="100%"
    height="100%"
    sodipodi:docname="envelope_font_awesome.svg">
   <metadata
      id="metadata2999">
     <rdf:RDF>
       <cc:Work
          rdf:about="">
         <dc:format>image/svg+xml</dc:format>
         <dc:type
            rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
       </cc:Work>
     </rdf:RDF>
   </metadata>
   <defs
      id="defs2997" />
   <sodipodi:namedview
      pagecolor="#ffffff"
      bordercolor="#666666"
      borderopacity="1"
      objecttolerance="10"
      gridtolerance="10"
      guidetolerance="10"
      inkscape:pageopacity="0"
      inkscape:pageshadow="2"
      inkscape:window-width="640"
      inkscape:window-height="480"
      id="namedview2995"
      showgrid="false"
      inkscape:zoom="0.13169643"
      inkscape:cx="896"
      inkscape:cy="896"
      inkscape:window-x="0"
      inkscape:window-y="25"
      inkscape:window-maximized="0"
      inkscape:current-layer="svg2989" />
   <g
      transform="matrix(1,0,0,-1,37.966102,1282.678)"
      id="g2991">
     <path
        d="m 1664,32 v 768 q -32,-36 -69,-66 -268,-206 -426,-338 -51,-43 -83,-67 -32,-24 -86.5,-48.5 Q 945,256 897,256 h -1 -1 Q 847,256 792.5,280.5 738,305 706,329 674,353 623,396 465,528 197,734 160,764 128,800 V 32 Q 128,19 137.5,9.5 147,0 160,0 h 1472 q 13,0 22.5,9.5 9.5,9.5 9.5,22.5 z m 0,1051 v 11 13.5 q 0,0 -0.5,13 -0.5,13 -3,12.5 -2.5,-0.5 -5.5,9 -3,9.5 -9,7.5 -6,-2 -14,2.5 H 160 q -13,0 -22.5,-9.5 Q 128,1133 128,1120 128,952 275,836 468,684 676,519 682,514 711,489.5 740,465 757,452 774,439 801.5,420.5 829,402 852,393 q 23,-9 43,-9 h 1 1 q 20,0 43,9 23,9 50.5,27.5 27.5,18.5 44.5,31.5 17,13 46,37.5 29,24.5 35,29.5 208,165 401,317 54,43 100.5,115.5 46.5,72.5 46.5,131.5 z m 128,37 V 32 q 0,-66 -47,-113 -47,-47 -113,-47 H 160 Q 94,-128 47,-81 0,-34 0,32 v 1088 q 0,66 47,113 47,47 113,47 h 1472 q 66,0 113,-47 47,-47 47,-113 z"
        id="path2993"
        inkscape:connector-curvature="0"
        style="fill:currentColor" />
   </g>
 </svg>
 '''
 
     def settings_schema(self):
         schema = EmailSettingsSchema()
+        schema.add(colander.SchemaNode(
+            colander.Set(),
+            widget=CheckboxChoiceWidgetDesc(
+                values=sorted(
+                    [(e.name, e.display_name, e.description) for e in self.valid_events]
+                ),
+            ),
+            description="List of events activated for this integration",
+            name='events'
+        ))
         return schema
 
     def send_event(self, event):
-        data = event.as_dict()
-        log.debug('got event: %r', event)
+        log.debug('handling event %s with integration %s', event.name, self)
+
+        if event.__class__ not in self.valid_events:
+            log.debug('event %r not present in valid event list (%s)', event, self.valid_events)
+            return
+
+        if not self.event_enabled(event):
+            # NOTE(marcink): for legacy reasons we're skipping this check...
+            # since the email event haven't had any settings...
+            pass
 
+        handler = EmailEventHandler(self.settings)
+        handler(event, event_data=event.as_dict())
+
+
+class EmailEventHandler(object):
+    def __init__(self, integration_settings):
+        self.integration_settings = integration_settings
+
+    def __call__(self, event, event_data):
         if isinstance(event, events.RepoPushEvent):
-            repo_push_handler(data, self.settings)
+            self.repo_push_handler(event, event_data)
         else:
             log.debug('ignoring event: %r', event)
 
-
-def repo_push_handler(data, settings):
+    def repo_push_handler(self, event, data):
     commit_num = len(data['push']['commits'])
     server_url = data['server_url']
 
     if commit_num == 1:
         if data['push']['branches']:
             _subject = '[{repo_name}] {author} pushed {commit_num} commit on branches: {branches}'
         else:
             _subject = '[{repo_name}] {author} pushed {commit_num} commit'
         subject = _subject.format(
             author=data['actor']['username'],
             repo_name=data['repo']['repo_name'],
             commit_num=commit_num,
             branches=', '.join(
                 branch['name'] for branch in data['push']['branches'])
         )
     else:
         if data['push']['branches']:
             _subject = '[{repo_name}] {author} pushed {commit_num} commits on branches: {branches}'
         else:
             _subject = '[{repo_name}] {author} pushed {commit_num} commits'
         subject = _subject.format(
             author=data['actor']['username'],
             repo_name=data['repo']['repo_name'],
             commit_num=commit_num,
             branches=', '.join(
                 branch['name'] for branch in data['push']['branches']))
 
     email_body_plaintext = render_with_traceback(
         REPO_PUSH_TEMPLATE_PLAINTEXT,
         data=data,
         subject=subject,
         instance_url=server_url)
 
     email_body_html = render_with_traceback(
         REPO_PUSH_TEMPLATE_HTML,
         data=data,
         subject=subject,
         instance_url=server_url)
 
-    for email_address in settings['recipients']:
+        recipients = self.integration_settings['recipients']
+        for email_address in recipients:
         run_task(
             tasks.send_email, email_address, subject,
             email_body_plaintext, email_body_html)

rhodecode/integrations/types/hipchat.py

@@ -1,255 +1,251 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 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 __future__ import unicode_literals
 import deform
 import logging
 import requests
 import colander
 import textwrap
 from mako.template import Template
 from rhodecode import events
+from rhodecode.model.validation_schema.widgets import CheckboxChoiceWidgetDesc
 from rhodecode.translation import _
 from rhodecode.lib import helpers as h
 from rhodecode.lib.celerylib import run_task, async_task, RequestContextTask
 from rhodecode.lib.colander_utils import strip_whitespace
 from rhodecode.integrations.types.base import (
     IntegrationTypeBase, CommitParsingDataHandler, render_with_traceback,
     requests_retry_call)
 
 log = logging.getLogger(__name__)
 
 REPO_PUSH_TEMPLATE = Template('''
 <b>${data['actor']['username']}</b> pushed to repo <a href="${data['repo']['url']}">${data['repo']['repo_name']}</a>:
 <br>
 <ul>
 %for branch, branch_commits in branches_commits.items():
     <li>
         % if branch:
         <a href="${branch_commits['branch']['url']}">branch: ${branch_commits['branch']['name']}</a>
         % else:
         to trunk
         % endif
         <ul>
         % for commit in branch_commits['commits']:
             <li><a href="${commit['url']}">${commit['short_id']}</a> - ${commit['message_html']}</li>
         % endfor
         </ul>
     </li>
 %endfor
 ''')
 
 
 class HipchatSettingsSchema(colander.Schema):
     color_choices = [
         ('yellow', _('Yellow')),
         ('red', _('Red')),
         ('green', _('Green')),
         ('purple', _('Purple')),
         ('gray', _('Gray')),
     ]
 
     server_url = colander.SchemaNode(
         colander.String(),
         title=_('Hipchat server URL'),
         description=_('Hipchat integration url.'),
         default='',
         preparer=strip_whitespace,
         validator=colander.url,
         widget=deform.widget.TextInputWidget(
             placeholder='https://?.hipchat.com/v2/room/?/notification?auth_token=?',
         ),
     )
     notify = colander.SchemaNode(
         colander.Bool(),
         title=_('Notify'),
         description=_('Make a notification to the users in room.'),
         missing=False,
         default=False,
     )
     color = colander.SchemaNode(
         colander.String(),
         title=_('Color'),
         description=_('Background color of message.'),
         missing='',
         validator=colander.OneOf([x[0] for x in color_choices]),
         widget=deform.widget.Select2Widget(
             values=color_choices,
         ),
     )
 
 
 class HipchatIntegrationType(IntegrationTypeBase, CommitParsingDataHandler):
     key = 'hipchat'
     display_name = _('Hipchat')
     description = _('Send events such as repo pushes and pull requests to '
                     'your hipchat channel.')
 
     @classmethod
     def icon(cls):
         return '''<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 1000 1000" enable-background="new 0 0 1000 1000" xml:space="preserve"><g><g transform="translate(0.000000,511.000000) scale(0.100000,-0.100000)"><path fill="#205281" d="M4197.1,4662.4c-1661.5-260.4-3018-1171.6-3682.6-2473.3C219.9,1613.6,100,1120.3,100,462.6c0-1014,376.8-1918.4,1127-2699.4C2326.7-3377.6,3878.5-3898.3,5701-3730.5l486.5,44.5l208.9-123.3c637.2-373.4,1551.8-640.6,2240.4-650.9c304.9-6.9,335.7,0,417.9,75.4c185,174.7,147.3,411.1-89.1,548.1c-315.2,181.6-620,544.7-733.1,870.1l-51.4,157.6l472.7,472.7c349.4,349.4,520.7,551.5,657.7,774.2c784.5,1281.2,784.5,2788.5,0,4052.6c-236.4,376.8-794.8,966-1178.4,1236.7c-572.1,407.7-1264.1,709.1-1993.7,870.1c-267.2,58.2-479.6,75.4-1038,82.2C4714.4,4686.4,4310.2,4679.6,4197.1,4662.4z M5947.6,3740.9c1856.7-380.3,3127.6-1709.4,3127.6-3275c0-1000.3-534.4-1949.2-1466.2-2600.1c-188.4-133.6-287.8-226.1-301.5-284.4c-41.1-157.6,263.8-938.6,397.4-1020.8c20.5-10.3,34.3-44.5,34.3-75.4c0-167.8-811.9,195.3-1363.4,609.8l-181.6,137l-332.3-58.2c-445.3-78.8-1281.2-78.8-1702.6,0C2796-2569.2,1734.1-1832.6,1220.2-801.5C983.8-318.5,905,51.5,929,613.3c27.4,640.6,243.2,1192.1,685.1,1740.3c620,770.8,1661.5,1305.2,2822.8,1452.5C4806.9,3854,5553.7,3819.7,5947.6,3740.9z"/><path fill="#205281" d="M2381.5-345.9c-75.4-106.2-68.5-167.8,34.3-322c332.3-500.2,1010.6-928.4,1760.8-1120.2c417.9-106.2,1226.4-106.2,1644.3,0c712.5,181.6,1270.9,517.3,1685.4,1014C7681-561.7,7715.3-424.7,7616-325.4c-89.1,89.1-167.9,65.1-431.7-133.6c-835.8-630.3-2028-856.4-3086.5-585.8C3683.3-938.6,3142-685,2830.3-448.7C2576.8-253.4,2463.7-229.4,2381.5-345.9z"/></g></g><!-- Svg Vector Icons : http://www.onlinewebfonts.com/icon --></svg>'''
 
     valid_events = [
         events.PullRequestCloseEvent,
         events.PullRequestMergeEvent,
         events.PullRequestUpdateEvent,
         events.PullRequestCommentEvent,
         events.PullRequestReviewEvent,
         events.PullRequestCreateEvent,
         events.RepoPushEvent,
         events.RepoCreateEvent,
     ]
 
     def send_event(self, event):
         if event.__class__ not in self.valid_events:
-            log.debug('event not valid: %r', event)
+            log.debug('event %r not present in valid event list (%s)', event, self.valid_events)
             return
 
-        allowed_events = self.settings['events']
-        if event.name not in allowed_events:
-            log.debug('event ignored: %r event %s not in allowed events %s',
-                      event, event.name, allowed_events)
+        if not self.event_enabled(event):
             return
 
         data = event.as_dict()
 
         text = '<b>%s<b> caused a <b>%s</b> event' % (
             data['actor']['username'], event.name)
 
-        log.debug('handling hipchat event for %s', event.name)
-
         if isinstance(event, events.PullRequestCommentEvent):
             text = self.format_pull_request_comment_event(event, data)
         elif isinstance(event, events.PullRequestReviewEvent):
             text = self.format_pull_request_review_event(event, data)
         elif isinstance(event, events.PullRequestEvent):
             text = self.format_pull_request_event(event, data)
         elif isinstance(event, events.RepoPushEvent):
             text = self.format_repo_push_event(data)
         elif isinstance(event, events.RepoCreateEvent):
             text = self.format_repo_create_event(data)
         else:
             log.error('unhandled event type: %r', event)
 
         run_task(post_text_to_hipchat, self.settings, text)
 
     def settings_schema(self):
         schema = HipchatSettingsSchema()
         schema.add(colander.SchemaNode(
             colander.Set(),
-            widget=deform.widget.CheckboxChoiceWidget(
+            widget=CheckboxChoiceWidgetDesc(
                 values=sorted(
-                    [(e.name, e.display_name) for e in self.valid_events]
-                )
+                    [(e.name, e.display_name, e.description) for e in self.valid_events]
             ),
-            description="Events activated for this integration",
+            ),
+            description="List of events activated for this integration",
             name='events'
         ))
 
         return schema
 
     def format_pull_request_comment_event(self, event, data):
         comment_text = data['comment']['text']
         if len(comment_text) > 200:
             comment_text = '{comment_text}<a href="{comment_url}">...<a/>'.format(
                 comment_text=h.html_escape(comment_text[:200]),
                 comment_url=data['comment']['url'],
             )
 
         comment_status = ''
         if data['comment']['status']:
             comment_status = '[{}]: '.format(data['comment']['status'])
 
         return (textwrap.dedent(
             '''
             {user} commented on pull request <a href="{pr_url}">{number}</a> - {pr_title}:
             >>> {comment_status}{comment_text}
             ''').format(
                 comment_status=comment_status,
                 user=data['actor']['username'],
                 number=data['pullrequest']['pull_request_id'],
                 pr_url=data['pullrequest']['url'],
                 pr_status=data['pullrequest']['status'],
                 pr_title=h.html_escape(data['pullrequest']['title']),
                 comment_text=h.html_escape(comment_text)
             )
         )
 
     def format_pull_request_review_event(self, event, data):
         return (textwrap.dedent(
             '''
             Status changed to {pr_status} for pull request <a href="{pr_url}">#{number}</a> - {pr_title}
             ''').format(
                 user=data['actor']['username'],
                 number=data['pullrequest']['pull_request_id'],
                 pr_url=data['pullrequest']['url'],
                 pr_status=data['pullrequest']['status'],
                 pr_title=h.html_escape(data['pullrequest']['title']),
             )
         )
 
     def format_pull_request_event(self, event, data):
         action = {
             events.PullRequestCloseEvent: 'closed',
             events.PullRequestMergeEvent: 'merged',
             events.PullRequestUpdateEvent: 'updated',
             events.PullRequestCreateEvent: 'created',
         }.get(event.__class__, str(event.__class__))
 
         return ('Pull request <a href="{url}">#{number}</a> - {title} '
                 '{action} by <b>{user}</b>').format(
             user=data['actor']['username'],
             number=data['pullrequest']['pull_request_id'],
             url=data['pullrequest']['url'],
             title=h.html_escape(data['pullrequest']['title']),
             action=action
         )
 
     def format_repo_push_event(self, data):
         branches_commits = self.aggregate_branch_data(
             data['push']['branches'], data['push']['commits'])
 
         result = render_with_traceback(
             REPO_PUSH_TEMPLATE,
             data=data,
             branches_commits=branches_commits,
         )
         return result
 
     def format_repo_create_event(self, data):
         return '<a href="{}">{}</a> ({}) repository created by <b>{}</b>'.format(
             data['repo']['url'],
             h.html_escape(data['repo']['repo_name']),
             data['repo']['repo_type'],
             data['actor']['username'],
         )
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def post_text_to_hipchat(settings, text):
     log.debug('sending %s to hipchat %s', text, settings['server_url'])
     json_message = {
         "message": text,
         "color": settings.get('color', 'yellow'),
         "notify": settings.get('notify', False),
     }
     req_session = requests_retry_call()
     resp = req_session.post(settings['server_url'], json=json_message, timeout=60)
     resp.raise_for_status()  # raise exception on a failed request

rhodecode/integrations/types/slack.py

@@ -1,353 +1,351 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 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 __future__ import unicode_literals
 import re
 import time
 import textwrap
 import logging
 
 import deform
 import requests
 import colander
 from mako.template import Template
 
 from rhodecode import events
+from rhodecode.model.validation_schema.widgets import CheckboxChoiceWidgetDesc
 from rhodecode.translation import _
 from rhodecode.lib import helpers as h
 from rhodecode.lib.celerylib import run_task, async_task, RequestContextTask
 from rhodecode.lib.colander_utils import strip_whitespace
 from rhodecode.integrations.types.base import (
     IntegrationTypeBase, CommitParsingDataHandler, render_with_traceback,
     requests_retry_call)
 
 log = logging.getLogger(__name__)
 
 
 def html_to_slack_links(message):
     return re.compile(r'<a .*?href=["\'](.+?)".*?>(.+?)</a>').sub(
         r'<\1|\2>', message)
 
 
 REPO_PUSH_TEMPLATE = Template('''
 <%
     def branch_text(branch):
         if branch:
             return 'on branch: <{}|{}>'.format(branch_commits['branch']['url'], branch_commits['branch']['name'])
         else:
             ## case for SVN no branch push...
             return 'to trunk'
 %> \
 
 % for branch, branch_commits in branches_commits.items():
 ${len(branch_commits['commits'])} ${'commit' if len(branch_commits['commits']) == 1 else 'commits'} ${branch_text(branch)}
 % for commit in branch_commits['commits']:
 `<${commit['url']}|${commit['short_id']}>` - ${commit['message_html']|html_to_slack_links}
 % endfor
 % endfor
 ''')
 
 
 class SlackSettingsSchema(colander.Schema):
     service = colander.SchemaNode(
         colander.String(),
         title=_('Slack service URL'),
         description=h.literal(_(
             'This can be setup at the '
             '<a href="https://my.slack.com/services/new/incoming-webhook/">'
             'slack app manager</a>')),
         default='',
         preparer=strip_whitespace,
         validator=colander.url,
         widget=deform.widget.TextInputWidget(
             placeholder='https://hooks.slack.com/services/...',
         ),
     )
     username = colander.SchemaNode(
         colander.String(),
         title=_('Username'),
         description=_('Username to show notifications coming from.'),
         missing='Rhodecode',
         preparer=strip_whitespace,
         widget=deform.widget.TextInputWidget(
             placeholder='Rhodecode'
         ),
     )
     channel = colander.SchemaNode(
         colander.String(),
         title=_('Channel'),
         description=_('Channel to send notifications to.'),
         missing='',
         preparer=strip_whitespace,
         widget=deform.widget.TextInputWidget(
             placeholder='#general'
         ),
     )
     icon_emoji = colander.SchemaNode(
         colander.String(),
         title=_('Emoji'),
         description=_('Emoji to use eg. :studio_microphone:'),
         missing='',
         preparer=strip_whitespace,
         widget=deform.widget.TextInputWidget(
             placeholder=':studio_microphone:'
         ),
     )
 
 
 class SlackIntegrationType(IntegrationTypeBase, CommitParsingDataHandler):
     key = 'slack'
     display_name = _('Slack')
     description = _('Send events such as repo pushes and pull requests to '
                     'your slack channel.')
 
     @classmethod
     def icon(cls):
         return '''<?xml version="1.0" encoding="UTF-8" standalone="no"?><svg viewBox="0 0 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid"><g><path d="M165.963541,15.8384262 C162.07318,3.86308197 149.212328,-2.69009836 137.239082,1.20236066 C125.263738,5.09272131 118.710557,17.9535738 122.603016,29.9268197 L181.550164,211.292328 C185.597902,222.478689 197.682361,228.765377 209.282098,225.426885 C221.381246,221.943607 228.756984,209.093246 224.896,197.21023 C224.749115,196.756984 165.963541,15.8384262 165.963541,15.8384262" fill="#DFA22F"></path><path d="M74.6260984,45.515541 C70.7336393,33.5422951 57.8727869,26.9891148 45.899541,30.8794754 C33.9241967,34.7698361 27.3710164,47.6306885 31.2634754,59.6060328 L90.210623,240.971541 C94.2583607,252.157902 106.34282,258.44459 117.942557,255.104 C130.041705,251.62282 137.417443,238.772459 133.556459,226.887344 C133.409574,226.436197 74.6260984,45.515541 74.6260984,45.515541" fill="#3CB187"></path><path d="M240.161574,166.045377 C252.136918,162.155016 258.688,149.294164 254.797639,137.31882 C250.907279,125.345574 238.046426,118.792393 226.07318,122.682754 L44.7076721,181.632 C33.5213115,185.677639 27.234623,197.762098 30.5731148,209.361836 C34.0563934,221.460984 46.9067541,228.836721 58.7897705,224.975738 C59.2430164,224.828852 240.161574,166.045377 240.161574,166.045377" fill="#CE1E5B"></path><path d="M82.507541,217.270557 C94.312918,213.434754 109.528131,208.491016 125.855475,203.186361 C122.019672,191.380984 117.075934,176.163672 111.76918,159.83423 L68.4191475,173.924721 L82.507541,217.270557" fill="#392538"></path><path d="M173.847082,187.591344 C190.235279,182.267803 205.467279,177.31777 217.195016,173.507148 C213.359213,161.70177 208.413377,146.480262 203.106623,130.146623 L159.75659,144.237115 L173.847082,187.591344" fill="#BB242A"></path><path d="M210.484459,74.7058361 C222.457705,70.8154754 229.010885,57.954623 225.120525,45.9792787 C221.230164,34.0060328 208.369311,27.4528525 196.393967,31.3432131 L15.028459,90.292459 C3.84209836,94.3380984 -2.44459016,106.422557 0.896,118.022295 C4.37718033,130.121443 17.227541,137.49718 29.1126557,133.636197 C29.5638033,133.489311 210.484459,74.7058361 210.484459,74.7058361" fill="#72C5CD"></path><path d="M52.8220328,125.933115 C64.6274098,122.097311 79.8468197,117.151475 96.1762623,111.84682 C90.8527213,95.4565246 85.9026885,80.2245246 82.0920656,68.4946885 L38.731541,82.5872787 L52.8220328,125.933115" fill="#248C73"></path><path d="M144.159475,96.256 C160.551869,90.9303607 175.785967,85.9803279 187.515803,82.1676066 C182.190164,65.7752131 177.240131,50.5390164 173.42741,38.807082 L130.068984,52.8996721 L144.159475,96.256" fill="#62803A"></path></g></svg>'''
 
     valid_events = [
         events.PullRequestCloseEvent,
         events.PullRequestMergeEvent,
         events.PullRequestUpdateEvent,
         events.PullRequestCommentEvent,
         events.PullRequestReviewEvent,
         events.PullRequestCreateEvent,
         events.RepoPushEvent,
         events.RepoCreateEvent,
     ]
 
     def send_event(self, event):
+        log.debug('handling event %s with integration %s', event.name, self)
+
         if event.__class__ not in self.valid_events:
-            log.debug('event not valid: %r', event)
+            log.debug('event %r not present in valid event list (%s)', event, self.valid_events)
             return
 
-        allowed_events = self.settings['events']
-        if event.name not in allowed_events:
-            log.debug('event ignored: %r event %s not in allowed events %s',
-                      event, event.name, allowed_events)
+        if not self.event_enabled(event):
             return
 
         data = event.as_dict()
 
         # defaults
         title = '*%s* caused a *%s* event' % (
             data['actor']['username'], event.name)
         text = '*%s* caused a *%s* event' % (
             data['actor']['username'], event.name)
         fields = None
         overrides = None
 
-        log.debug('handling slack event for %s', event.name)
-
         if isinstance(event, events.PullRequestCommentEvent):
             (title, text, fields, overrides) \
                 = self.format_pull_request_comment_event(event, data)
         elif isinstance(event, events.PullRequestReviewEvent):
             title, text = self.format_pull_request_review_event(event, data)
         elif isinstance(event, events.PullRequestEvent):
             title, text = self.format_pull_request_event(event, data)
         elif isinstance(event, events.RepoPushEvent):
             title, text = self.format_repo_push_event(data)
         elif isinstance(event, events.RepoCreateEvent):
             title, text = self.format_repo_create_event(data)
         else:
             log.error('unhandled event type: %r', event)
 
         run_task(post_text_to_slack, self.settings, title, text, fields, overrides)
 
     def settings_schema(self):
         schema = SlackSettingsSchema()
         schema.add(colander.SchemaNode(
             colander.Set(),
-            widget=deform.widget.CheckboxChoiceWidget(
+            widget=CheckboxChoiceWidgetDesc(
                 values=sorted(
-                    [(e.name, e.display_name) for e in self.valid_events]
-                )
+                    [(e.name, e.display_name, e.description) for e in self.valid_events]
             ),
-            description="Events activated for this integration",
+            ),
+            description="List of events activated for this integration",
             name='events'
         ))
 
         return schema
 
     def format_pull_request_comment_event(self, event, data):
         comment_text = data['comment']['text']
         if len(comment_text) > 200:
             comment_text = '<{comment_url}|{comment_text}...>'.format(
                 comment_text=comment_text[:200],
                 comment_url=data['comment']['url'],
             )
 
         fields = None
         overrides = None
         status_text = None
 
         if data['comment']['status']:
             status_color = {
                 'approved': '#0ac878',
                 'rejected': '#e85e4d'}.get(data['comment']['status'])
 
             if status_color:
                 overrides = {"color": status_color}
 
             status_text = data['comment']['status']
 
         if data['comment']['file']:
             fields = [
                 {
                     "title": "file",
                     "value": data['comment']['file']
                 },
                 {
                     "title": "line",
                     "value": data['comment']['line']
                 }
             ]
 
         template = Template(textwrap.dedent(r'''
         *${data['actor']['username']}* left ${data['comment']['type']} on pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']}>:
         '''))
         title = render_with_traceback(
             template, data=data, comment=event.comment)
 
         template = Template(textwrap.dedent(r'''
         *pull request title*: ${pr_title}
         % if status_text:
         *submitted status*: `${status_text}`
         % endif
         >>> ${comment_text}
         '''))
         text = render_with_traceback(
             template,
             comment_text=comment_text,
             pr_title=data['pullrequest']['title'],
             status_text=status_text)
 
         return title, text, fields, overrides
 
     def format_pull_request_review_event(self, event, data):
         template = Template(textwrap.dedent(r'''
         *${data['actor']['username']}* changed status of pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']} to `${data['pullrequest']['status']}`>:
         '''))
         title = render_with_traceback(template, data=data)
 
         template = Template(textwrap.dedent(r'''
         *pull request title*: ${pr_title}
         '''))
         text = render_with_traceback(
             template,
             pr_title=data['pullrequest']['title'])
 
         return title, text
 
     def format_pull_request_event(self, event, data):
         action = {
             events.PullRequestCloseEvent: 'closed',
             events.PullRequestMergeEvent: 'merged',
             events.PullRequestUpdateEvent: 'updated',
             events.PullRequestCreateEvent: 'created',
         }.get(event.__class__, str(event.__class__))
 
         template = Template(textwrap.dedent(r'''
         *${data['actor']['username']}* `${action}` pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']}>:
         '''))
         title = render_with_traceback(template, data=data, action=action)
 
         template = Template(textwrap.dedent(r'''
         *pull request title*: ${pr_title}
         %if data['pullrequest']['commits']:
         *commits*: ${len(data['pullrequest']['commits'])}
         %endif
         '''))
         text = render_with_traceback(
             template,
             pr_title=data['pullrequest']['title'],
             data=data)
 
         return title, text
 
     def format_repo_push_event(self, data):
         branches_commits = self.aggregate_branch_data(
             data['push']['branches'], data['push']['commits'])
 
         template = Template(r'''
         *${data['actor']['username']}* pushed to repo <${data['repo']['url']}|${data['repo']['repo_name']}>:
         ''')
         title = render_with_traceback(template, data=data)
 
         text = render_with_traceback(
             REPO_PUSH_TEMPLATE,
             data=data,
             branches_commits=branches_commits,
             html_to_slack_links=html_to_slack_links,
         )
 
         return title, text
 
     def format_repo_create_event(self, data):
         template = Template(r'''
         *${data['actor']['username']}* created new repository ${data['repo']['repo_name']}:
         ''')
         title = render_with_traceback(template, data=data)
 
         template = Template(textwrap.dedent(r'''
         repo_url: ${data['repo']['url']}
         repo_type: ${data['repo']['repo_type']}
         '''))
         text = render_with_traceback(template, data=data)
 
         return title, text
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def post_text_to_slack(settings, title, text, fields=None, overrides=None):
     log.debug('sending %s (%s) to slack %s', title, text, settings['service'])
 
     fields = fields or []
     overrides = overrides or {}
 
     message_data = {
                 "fallback": text,
                 "color": "#427cc9",
                 "pretext": title,
                 #"author_name": "Bobby Tables",
                 #"author_link": "http://flickr.com/bobby/",
                 #"author_icon": "http://flickr.com/icons/bobby.jpg",
                 #"title": "Slack API Documentation",
                 #"title_link": "https://api.slack.com/",
                 "text": text,
                 "fields": fields,
                 #"image_url": "http://my-website.com/path/to/image.jpg",
                 #"thumb_url": "http://example.com/path/to/thumb.png",
                 "footer": "RhodeCode",
                 #"footer_icon": "",
                 "ts": time.time(),
                 "mrkdwn_in": ["pretext", "text"]
     }
     message_data.update(overrides)
     json_message = {
         "icon_emoji": settings.get('icon_emoji', ':studio_microphone:'),
         "channel": settings.get('channel', ''),
         "username": settings.get('username', 'Rhodecode'),
         "attachments": [message_data]
     }
     req_session = requests_retry_call()
     resp = req_session.post(settings['service'], json=json_message, timeout=60)
     resp.raise_for_status()  # raise exception on a failed request

rhodecode/integrations/types/webhook.py

@@ -1,265 +1,264 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 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 __future__ import unicode_literals
 
-import deform
 import deform.widget
 import logging
 import colander
 
 import rhodecode
 from rhodecode import events
+from rhodecode.lib.colander_utils import strip_whitespace
+from rhodecode.model.validation_schema.widgets import CheckboxChoiceWidgetDesc
 from rhodecode.translation import _
 from rhodecode.integrations.types.base import (
     IntegrationTypeBase, get_auth, get_web_token, get_url_vars,
     WebhookDataHandler, WEBHOOK_URL_VARS, requests_retry_call)
 from rhodecode.lib.celerylib import run_task, async_task, RequestContextTask
 from rhodecode.model.validation_schema import widgets
 
 log = logging.getLogger(__name__)
 
 
 # updating this required to update the `common_vars` passed in url calling func
 
 URL_VARS = get_url_vars(WEBHOOK_URL_VARS)
 
 
 class WebhookSettingsSchema(colander.Schema):
     url = colander.SchemaNode(
         colander.String(),
         title=_('Webhook URL'),
         description=
             _('URL to which Webhook should submit data. If used some of the '
               'variables would trigger multiple calls, like ${branch} or '
               '${commit_id}. Webhook will be called as many times as unique '
               'objects in data in such cases.'),
         missing=colander.required,
         required=True,
+        preparer=strip_whitespace,
         validator=colander.url,
         widget=widgets.CodeMirrorWidget(
             help_block_collapsable_name='Show url variables',
             help_block_collapsable=(
-                'E.g http://my-serv/trigger_job/${{event_name}}'
+                'E.g http://my-serv.com/trigger_job/${{event_name}}'
                 '?PR_ID=${{pull_request_id}}'
                 '\nFull list of vars:\n{}'.format(URL_VARS)),
             codemirror_mode='text',
             codemirror_options='{"lineNumbers": false, "lineWrapping": true}'),
     )
     secret_token = colander.SchemaNode(
         colander.String(),
         title=_('Secret Token'),
         description=_('Optional string used to validate received payloads. '
                       'It will be sent together with event data in JSON'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. secret_token'
         ),
     )
     username = colander.SchemaNode(
         colander.String(),
         title=_('Username'),
         description=_('Optional username to authenticate the call.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. admin'
         ),
     )
     password = colander.SchemaNode(
         colander.String(),
         title=_('Password'),
         description=_('Optional password to authenticate the call.'),
         default='',
         missing='',
         widget=deform.widget.PasswordWidget(
             placeholder='e.g. secret.',
             redisplay=True,
         ),
     )
     custom_header_key = colander.SchemaNode(
         colander.String(),
         title=_('Custom Header Key'),
         description=_('Custom Header name to be set when calling endpoint.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g: Authorization'
         ),
     )
     custom_header_val = colander.SchemaNode(
         colander.String(),
         title=_('Custom Header Value'),
         description=_('Custom Header value to be set when calling endpoint.'),
         default='',
         missing='',
         widget=deform.widget.TextInputWidget(
             placeholder='e.g. Basic XxXxXx'
         ),
     )
     method_type = colander.SchemaNode(
         colander.String(),
         title=_('Call Method'),
         description=_('Select a HTTP method to use when calling the Webhook.'),
         default='post',
         missing='',
         widget=deform.widget.RadioChoiceWidget(
             values=[('get', 'GET'), ('post', 'POST'), ('put', 'PUT')],
             inline=True
         ),
     )
 
 
 class WebhookIntegrationType(IntegrationTypeBase):
     key = 'webhook'
     display_name = _('Webhook')
     description = _('send JSON data to a url endpoint')
 
     @classmethod
     def icon(cls):
         return '''<?xml version="1.0" encoding="UTF-8" standalone="no"?><svg viewBox="0 0 256 239" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid"><g><path d="M119.540432,100.502743 C108.930124,118.338815 98.7646301,135.611455 88.3876025,152.753617 C85.7226696,157.154315 84.4040417,160.738531 86.5332204,166.333309 C92.4107024,181.787152 84.1193605,196.825836 68.5350381,200.908244 C53.8383677,204.759349 39.5192953,195.099955 36.6032893,179.365384 C34.0194114,165.437749 44.8274148,151.78491 60.1824106,149.608284 C61.4694072,149.424428 62.7821041,149.402681 64.944891,149.240571 C72.469175,136.623655 80.1773157,123.700312 88.3025935,110.073173 C73.611854,95.4654658 64.8677898,78.3885437 66.803227,57.2292132 C68.1712787,42.2715849 74.0527146,29.3462646 84.8033863,18.7517722 C105.393354,-1.53572199 136.805164,-4.82141828 161.048542,10.7510424 C184.333097,25.7086706 194.996783,54.8450075 185.906752,79.7822957 C179.052655,77.9239597 172.151111,76.049808 164.563565,73.9917997 C167.418285,60.1274266 165.306899,47.6765751 155.95591,37.0109123 C149.777932,29.9690049 141.850349,26.2780332 132.835442,24.9178894 C114.764113,22.1877169 97.0209573,33.7983633 91.7563309,51.5355878 C85.7800012,71.6669027 94.8245623,88.1111998 119.540432,100.502743 L119.540432,100.502743 Z" fill="#C73A63"></path><path d="M149.841194,79.4106285 C157.316054,92.5969067 164.905578,105.982857 172.427885,119.246236 C210.44865,107.483365 239.114472,128.530009 249.398582,151.063322 C261.81978,178.282014 253.328765,210.520191 228.933162,227.312431 C203.893073,244.551464 172.226236,241.605803 150.040866,219.46195 C155.694953,214.729124 161.376716,209.974552 167.44794,204.895759 C189.360489,219.088306 208.525074,218.420096 222.753207,201.614016 C234.885769,187.277151 234.622834,165.900356 222.138374,151.863988 C207.730339,135.66681 188.431321,135.172572 165.103273,150.721309 C155.426087,133.553447 145.58086,116.521995 136.210101,99.2295848 C133.05093,93.4015266 129.561608,90.0209366 122.440622,88.7873178 C110.547271,86.7253555 102.868785,76.5124151 102.408155,65.0698097 C101.955433,53.7537294 108.621719,43.5249733 119.04224,39.5394355 C129.363912,35.5914599 141.476705,38.7783085 148.419765,47.554004 C154.093621,54.7244134 155.896602,62.7943365 152.911402,71.6372484 C152.081082,74.1025091 151.00562,76.4886916 149.841194,79.4106285 L149.841194,79.4106285 Z" fill="#4B4B4B"></path><path d="M167.706921,187.209935 L121.936499,187.209935 C117.54964,205.253587 108.074103,219.821756 91.7464461,229.085759 C79.0544063,236.285822 65.3738898,238.72736 50.8136292,236.376762 C24.0061432,232.053165 2.08568567,207.920497 0.156179306,180.745298 C-2.02835403,149.962159 19.1309765,122.599149 47.3341915,116.452801 C49.2814904,123.524363 51.2485589,130.663141 53.1958579,137.716911 C27.3195169,150.919004 18.3639187,167.553089 25.6054984,188.352614 C31.9811726,206.657224 50.0900643,216.690262 69.7528413,212.809503 C89.8327554,208.847688 99.9567329,192.160226 98.7211371,165.37844 C117.75722,165.37844 136.809118,165.180745 155.847178,165.475311 C163.280522,165.591951 169.019617,164.820939 174.620326,158.267339 C183.840836,147.48306 200.811003,148.455721 210.741239,158.640984 C220.88894,169.049642 220.402609,185.79839 209.663799,195.768166 C199.302587,205.38802 182.933414,204.874012 173.240413,194.508846 C171.247644,192.37176 169.677943,189.835329 167.706921,187.209935 L167.706921,187.209935 Z" fill="#4A4A4A"></path></g></svg>'''
 
     valid_events = [
         events.PullRequestCloseEvent,
         events.PullRequestMergeEvent,
         events.PullRequestUpdateEvent,
         events.PullRequestCommentEvent,
         events.PullRequestReviewEvent,
         events.PullRequestCreateEvent,
         events.RepoPushEvent,
         events.RepoCreateEvent,
+        events.RepoCommitCommentEvent,
     ]
 
     def settings_schema(self):
         schema = WebhookSettingsSchema()
         schema.add(colander.SchemaNode(
             colander.Set(),
-            widget=deform.widget.CheckboxChoiceWidget(
+            widget=CheckboxChoiceWidgetDesc(
                 values=sorted(
-                    [(e.name, e.display_name) for e in self.valid_events]
-                )
+                    [(e.name, e.display_name, e.description) for e in self.valid_events]
             ),
-            description="Events activated for this integration",
+            ),
+            description="List of events activated for this integration",
             name='events'
         ))
         return schema
 
     def send_event(self, event):
-        log.debug(
-            'handling event %s with Webhook integration %s', event.name, self)
+        log.debug('handling event %s with integration %s', event.name, self)
 
         if event.__class__ not in self.valid_events:
-            log.debug('event not valid: %r', event)
+            log.debug('event %r not present in valid event list (%s)', event, self.valid_events)
             return
 
-        allowed_events = self.settings['events']
-        if event.name not in allowed_events:
-            log.debug('event ignored: %r event %s not in allowed events %s',
-                      event, event.name, allowed_events)
+        if not self.event_enabled(event):
             return
 
         data = event.as_dict()
         template_url = self.settings['url']
 
         headers = {}
         head_key = self.settings.get('custom_header_key')
         head_val = self.settings.get('custom_header_val')
         if head_key and head_val:
             headers = {head_key: head_val}
 
         handler = WebhookDataHandler(template_url, headers)
 
         url_calls = handler(event, data)
         log.debug('Webhook: calling following urls: %s', [x[0] for x in url_calls])
 
         run_task(post_to_webhook, url_calls, self.settings)
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def post_to_webhook(url_calls, settings):
     """
     Example data::
 
         {'actor': {'user_id': 2, 'username': u'admin'},
          'actor_ip': u'192.168.157.1',
          'name': 'repo-push',
          'push': {'branches': [{'name': u'default',
                                 'url': 'http://rc.local:8080/hg-repo/changelog?branch=default'}],
                   'commits': [{'author': u'Marcin Kuzminski <[e-mail]>',
                                'branch': u'default',
                                'date': datetime.datetime(2017, 11, 30, 12, 59, 48),
                                'issues': [],
                                'mentions': [],
                                'message': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'message_html': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'message_html_title': u'commit Thu 30 Nov 2017 13:59:48 CET',
                                'parents': [{'raw_id': '431b772a5353dad9974b810dd3707d79e3a7f6e0'}],
                                'permalink_url': u'http://rc.local:8080/_7/changeset/a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf',
                                'raw_id': 'a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf',
                                'refs': {'bookmarks': [],
                                         'branches': [u'default'],
                                         'tags': [u'tip']},
                                'reviewers': [],
                                'revision': 9L,
                                'short_id': 'a815cc738b96',
                                'url': u'http://rc.local:8080/hg-repo/changeset/a815cc738b9651eb5ffbcfb1ce6ccd7c701a5ddf'}],
                   'issues': {}},
          'repo': {'extra_fields': '',
                   'permalink_url': u'http://rc.local:8080/_7',
                   'repo_id': 7,
                   'repo_name': u'hg-repo',
                   'repo_type': u'hg',
                   'url': u'http://rc.local:8080/hg-repo'},
          'server_url': u'http://rc.local:8080',
          'utc_timestamp': datetime.datetime(2017, 11, 30, 13, 0, 1, 569276)
          }
     """
 
     call_headers = {
         'User-Agent': 'RhodeCode-webhook-caller/{}'.format(rhodecode.__version__)
     }  # updated below with custom ones, allows override
 
     auth = get_auth(settings)
     token = get_web_token(settings)
 
     for url, headers, data in url_calls:
         req_session = requests_retry_call()
 
         method = settings.get('method_type') or 'post'
         call_method = getattr(req_session, method)
 
         headers = headers or {}
         call_headers.update(headers)
 
         log.debug('calling Webhook with method: %s, and auth:%s', call_method, auth)
         if settings.get('log_data'):
             log.debug('calling webhook with data: %s', data)
         resp = call_method(url, json={
             'token': token,
             'event': data
         }, headers=call_headers, auth=auth, timeout=60)
         log.debug('Got Webhook response: %s', resp)
 
         try:
             resp.raise_for_status()  # raise exception on a failed request
         except Exception:
             log.error(resp.text)
             raise

rhodecode/model/validation_schema/widgets.py

@@ -1,32 +1,59 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 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 deform
 import deform.widget
+from deform.widget import null, OptGroup, string_types
+
+log = logging.getLogger(__name__)
 
 
-log = logging.getLogger(__name__)
+def _normalize_choices(values):
+    result = []
+    for item in values:
+        if isinstance(item, OptGroup):
+            normalized_options = _normalize_choices(item.options)
+            result.append(OptGroup(item.label, *normalized_options))
+        else:
+            value, description, help_block = item
+            if not isinstance(value, string_types):
+                value = str(value)
+            result.append((value, description, help_block))
+    return result
 
 
 class CodeMirrorWidget(deform.widget.TextAreaWidget):
     template = 'codemirror'
     requirements = (('deform', None), ('codemirror', None))
+
+
+class CheckboxChoiceWidgetDesc(deform.widget.CheckboxChoiceWidget):
+    template = "checkbox_choice_desc"
+
+    def serialize(self, field, cstruct, **kw):
+        if cstruct in (null, None):
+            cstruct = ()
+        readonly = kw.get("readonly", self.readonly)
+        values = kw.get("values", self.values)
+        kw["values"] = _normalize_choices(values)
+        template = readonly and self.readonly_template or self.template
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(template, **tmpl_values)

rhodecode/templates/forms/checkbox_choice.pt

@@ -1,25 +1,25 b''
 <div tal:define="css_class css_class|field.widget.css_class;
                  style style|field.widget.style;
                  oid oid|field.oid;
                  inline getattr(field.widget, 'inline', False)"
      tal:omit-tag="not inline">
   ${field.start_sequence()}
   <div tal:repeat="choice values | field.widget.values"
        tal:omit-tag="inline"
        class="checkbox">
     <div tal:define="(value, title) choice">
       <input tal:attributes="checked value in cstruct;
                              class css_class;
                              style style"
              type="checkbox"
              name="checkbox"
              value="${value}"
              id="${oid}-${repeat.choice.index}"/>
       <label for="${oid}-${repeat.choice.index}"
              tal:attributes="class inline and 'checkbox-inline'">
         ${title}
       </label>
     </div>
   </div>
   ${field.end_sequence()}
-</div>
  No newline at end of file
+</div>

rhodecode/tests/events/test_pullrequest.py

@@ -1,100 +1,100 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.events.conftest import EventCatcher
 
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.events import (
     PullRequestCreateEvent,
     PullRequestUpdateEvent,
     PullRequestCommentEvent,
     PullRequestReviewEvent,
     PullRequestMergeEvent,
     PullRequestCloseEvent,
 )
 
 # TODO: dan: make the serialization tests complete json comparisons
 @pytest.mark.backends("git", "hg")
 @pytest.mark.parametrize('EventClass', [
     PullRequestCreateEvent,
     PullRequestUpdateEvent,
     PullRequestReviewEvent,
     PullRequestMergeEvent,
-    PullRequestCloseEvent,
+    PullRequestCloseEvent
 ])
 def test_pullrequest_events_serialized(EventClass, pr_util, config_stub):
     pr = pr_util.create_pull_request()
     if EventClass == PullRequestReviewEvent:
         event = EventClass(pr, 'approved')
     else:
         event = EventClass(pr)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == pr.target_repo.repo_name
     assert data['pullrequest']['pull_request_id'] == pr.pull_request_id
     assert data['pullrequest']['url']
     assert data['pullrequest']['permalink_url']
 
 
 @pytest.mark.backends("git", "hg")
 def test_create_pull_request_events(pr_util, config_stub):
     with EventCatcher() as event_catcher:
         pr_util.create_pull_request()
 
     assert PullRequestCreateEvent in event_catcher.events_types
 
 
 @pytest.mark.backends("git", "hg")
 def test_pullrequest_comment_events_serialized(pr_util, config_stub):
     pr = pr_util.create_pull_request()
     comment = CommentsModel().get_comments(
         pr.target_repo.repo_id, pull_request=pr)[0]
     event = PullRequestCommentEvent(pr, comment)
     data = event.as_dict()
     assert data['name'] == PullRequestCommentEvent.name
     assert data['repo']['repo_name'] == pr.target_repo.repo_name
     assert data['pullrequest']['pull_request_id'] == pr.pull_request_id
     assert data['pullrequest']['url']
     assert data['pullrequest']['permalink_url']
     assert data['comment']['text'] == comment.text
 
 
 @pytest.mark.backends("git", "hg")
 def test_close_pull_request_events(pr_util, user_admin, config_stub):
     pr = pr_util.create_pull_request()
 
     with EventCatcher() as event_catcher:
         PullRequestModel().close_pull_request(pr, user_admin)
 
     assert PullRequestCloseEvent in event_catcher.events_types
 
 
 @pytest.mark.backends("git", "hg")
 def test_close_pull_request_with_comment_events(pr_util, user_admin, config_stub):
     pr = pr_util.create_pull_request()
 
     with EventCatcher() as event_catcher:
         PullRequestModel().close_pull_request_with_comment(
             pr, user_admin, pr.target_repo)
 
     assert PullRequestCloseEvent in event_catcher.events_types

rhodecode/tests/events/test_repo.py

@@ -1,123 +1,145 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.lib.utils2 import StrictAttributeDict
 from rhodecode.tests.events.conftest import EventCatcher
 
 from rhodecode.lib import hooks_base, utils2
 from rhodecode.model.repo import RepoModel
 from rhodecode.events.repo import (
     RepoPrePullEvent, RepoPullEvent,
     RepoPrePushEvent, RepoPushEvent,
     RepoPreCreateEvent, RepoCreateEvent,
-    RepoPreDeleteEvent, RepoDeleteEvent,
+    RepoPreDeleteEvent, RepoDeleteEvent, RepoCommitCommentEvent,
 )
 
 
 @pytest.fixture()
 def scm_extras(user_regular, repo_stub):
     extras = utils2.AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': '',
         'repository': repo_stub.repo_name,
         'scm': repo_stub.scm_instance().alias,
         'config': '',
         'repo_store': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': ['a' * 40] * 3,
         'hook_type': 'scm_extras_test',
         'is_shadow_repo': False,
     })
     return extras
 
 
 # TODO: dan: make the serialization tests complete json comparisons
 @pytest.mark.parametrize('EventClass', [
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
 ])
 def test_repo_events_serialized(config_stub, repo_stub, EventClass):
     event = EventClass(repo_stub)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [
     RepoPrePullEvent, RepoPullEvent, RepoPrePushEvent
 ])
 def test_vcs_repo_events_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name, extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [RepoPushEvent])
 def test_vcs_repo_push_event_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name,
                        pushed_commit_ids=scm_extras['commit_ids'],
                        extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 def test_create_delete_repo_fires_events(backend):
     with EventCatcher() as event_catcher:
         repo = backend.create_repo()
     assert event_catcher.events_types == [RepoPreCreateEvent, RepoCreateEvent]
 
     with EventCatcher() as event_catcher:
         RepoModel().delete(repo)
     assert event_catcher.events_types == [RepoPreDeleteEvent, RepoDeleteEvent]
 
 
 def test_pull_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_push(scm_extras)
     assert event_catcher.events_types == [RepoPrePushEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_push(scm_extras)
     assert event_catcher.events_types == [RepoPushEvent]
 
 
 def test_push_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_pull(scm_extras)
     assert event_catcher.events_types == [RepoPrePullEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_pull(scm_extras)
     assert event_catcher.events_types == [RepoPullEvent]
 
+
[e-mail]('EventClass', [RepoCommitCommentEvent])
+def test_repo_commit_event(config_stub, repo_stub, EventClass):
+
+    commit = StrictAttributeDict({
+        'raw_id': 'raw_id',
+        'message': 'message',
+        'branch': 'branch',
+    })
+
+    comment = StrictAttributeDict({
+        'comment_id': 'comment_id',
+        'text': 'text',
+        'comment_type': 'comment_type',
+        'f_path': 'f_path',
+        'line_no': 'line_no',
+    })
+    event = EventClass(repo=repo_stub, commit=commit, comment=comment)
+    data = event.as_dict()
+    assert data['commit']['commit_id']
+    assert data['comment']['comment_id']

rhodecode/tests/integrations/test_integration.py

@@ -1,224 +1,225 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 pytest
 
 from rhodecode import events
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Session, Integration
 from rhodecode.model.integration import IntegrationModel
 
 
 class TestDeleteScopesDeletesIntegrations(object):
     def test_delete_repo_with_integration_deletes_integration(
             self, repo_integration_stub):
 
         Session().delete(repo_integration_stub.repo)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repo_integration_stub.integration_id)
         assert integration is None
 
     def test_delete_repo_group_with_integration_deletes_integration(
             self, repogroup_integration_stub):
 
         Session().delete(repogroup_integration_stub.repo_group)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repogroup_integration_stub.integration_id)
         assert integration is None
 
 
 count = 1
 
+
 def counter():
     global count
     val = count
     count += 1
     return '{}_{}'.format(val, time.time())
 
 
 @pytest.fixture()
 def integration_repos(request, StubIntegrationType, stub_integration_settings):
     """
     Create repositories and integrations for testing, and destroy them after
 
     Structure:
         root_repo
         parent_group/
             parent_repo
             child_group/
                 child_repo
         other_group/
             other_repo
     """
     fixture = Fixture()
 
     parent_group_id = 'int_test_parent_group_{}'.format(counter())
     parent_group = fixture.create_repo_group(parent_group_id)
 
     other_group_id = 'int_test_other_group_{}'.format(counter())
     other_group = fixture.create_repo_group(other_group_id)
 
     child_group_id = (
         parent_group_id + '/' + 'int_test_child_group_{}'.format(counter()))
     child_group = fixture.create_repo_group(child_group_id)
 
     parent_repo_id = 'int_test_parent_repo_{}'.format(counter())
     parent_repo = fixture.create_repo(parent_repo_id, repo_group=parent_group)
 
     child_repo_id = 'int_test_child_repo_{}'.format(counter())
     child_repo = fixture.create_repo(child_repo_id, repo_group=child_group)
 
     other_repo_id = 'int_test_other_repo_{}'.format(counter())
     other_repo = fixture.create_repo(other_repo_id, repo_group=other_group)
 
     root_repo_id = 'int_test_repo_root_{}'.format(counter())
     root_repo = fixture.create_repo(root_repo_id)
 
     integrations = {}
     for name, repo, repo_group, child_repos_only in [
             ('global', None, None, None),
             ('root_repos', None, None, True),
             ('parent_repo', parent_repo, None, None),
             ('child_repo', child_repo, None, None),
             ('other_repo', other_repo, None, None),
             ('root_repo', root_repo, None, None),
             ('parent_group', None, parent_group, True),
             ('parent_group_recursive', None, parent_group, False),
             ('child_group', None, child_group, True),
             ('child_group_recursive', None, child_group, False),
             ('other_group', None, other_group, True),
             ('other_group_recursive', None, other_group, False),
         ]:
         integrations[name] = IntegrationModel().create(
             StubIntegrationType, settings=stub_integration_settings,
             enabled=True, name='test %s integration' % name,
             repo=repo, repo_group=repo_group, child_repos_only=child_repos_only)
 
     Session().commit()
 
     def _cleanup():
         for integration in integrations.values():
             Session.delete(integration)
 
         fixture.destroy_repo(root_repo)
         fixture.destroy_repo(child_repo)
         fixture.destroy_repo(parent_repo)
         fixture.destroy_repo(other_repo)
         fixture.destroy_repo_group(child_group)
         fixture.destroy_repo_group(parent_group)
         fixture.destroy_repo_group(other_group)
 
     request.addfinalizer(_cleanup)
 
     return {
         'integrations': integrations,
         'repos': {
             'root_repo': root_repo,
             'other_repo': other_repo,
             'parent_repo': parent_repo,
             'child_repo': child_repo,
         }
     }
 
 
 def test_enabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['root_repos'],
         integrations['root_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['other_group'],
         integrations['other_group_recursive'],
         integrations['other_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['parent_group'],
         integrations['parent_group_recursive'],
         integrations['parent_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['child_group'],
         integrations['parent_group_recursive'],
         integrations['child_group_recursive'],
         integrations['child_repo'],
     ]
 
 
 def test_disabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     for integration in integrations.values():
         integration.enabled = False
     Session().commit()
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == []
 
 
 def test_enabled_non_repo_integrations(integration_repos):
     integrations = integration_repos['integrations']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.UserPreCreate({}))
 
     assert triggered_integrations == [integrations['global']]

rhodecode/tests/integrations/test_webhook.py

@@ -1,135 +1,134 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 import events
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.integrations.types.webhook import WebhookDataHandler
 
 
 @pytest.fixture()
 def base_data():
     return {
         'name': 'event',
         'repo': {
             'repo_name': 'foo',
             'repo_type': 'hg',
             'repo_id': '12',
             'url': 'http://repo.url/foo',
             'extra_fields': {},
         },
         'actor': {
             'username': 'actor_name',
             'user_id': 1
         }
     }
 
 
 def test_webhook_parse_url_invalid_event():
     template_url = 'http://server.com/${repo_name}/build'
     handler = WebhookDataHandler(
         template_url, {'exmaple-header': 'header-values'})
     event = events.RepoDeleteEvent('')
     with pytest.raises(ValueError) as err:
         handler(event, {})
 
     err = str(err.value)
-    assert err.startswith(
-        'event type `%s` not in supported list' % event.__class__)
+    assert err == "event type `<class 'rhodecode.events.repo.RepoDeleteEvent'>` has no handler defined"
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/build',
      ['http://server.com/foo/build']),
     ('http://server.com/${repo_name}/${repo_type}',
      ['http://server.com/foo/hg']),
     ('http://${server}.com/${repo_name}/${repo_id}',
      ['http://${server}.com/foo/12']),
     ('http://server.com/${branch}/build',
      ['http://server.com/${branch}/build']),
 ])
 def test_webook_parse_url_for_create_event(base_data, template, expected_urls):
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.RepoCreateEvent(''), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/${pull_request_id}',
      ['http://server.com/foo/999']),
     ('http://server.com/${repo_name}/${pull_request_url}',
      ['http://server.com/foo/http%3A//pr-url.com']),
     ('http://server.com/${repo_name}/${pull_request_url}/?TITLE=${pull_request_title}',
      ['http://server.com/foo/http%3A//pr-url.com/?TITLE=example-pr-title%20Ticket%20%23123']),
     ('http://server.com/${repo_name}/?SHADOW_URL=${pull_request_shadow_url}',
      ['http://server.com/foo/?SHADOW_URL=http%3A//pr-url.com/repository']),
 ])
 def test_webook_parse_url_for_pull_request_event(base_data, template, expected_urls):
 
     base_data['pullrequest'] = {
         'pull_request_id': 999,
         'url': 'http://pr-url.com',
         'title': 'example-pr-title Ticket #123',
         'commits_uid': 'abcdefg1234',
         'shadow_url': 'http://pr-url.com/repository'
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.PullRequestCreateEvent(
         AttributeDict({'target_repo': 'foo'})), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${branch}/build',
         ['http://server.com/stable/build',
          'http://server.com/dev/build']),
     ('http://server.com/${branch}/${commit_id}',
         ['http://server.com/stable/stable-xxx',
          'http://server.com/stable/stable-yyy',
          'http://server.com/dev/dev-xxx',
          'http://server.com/dev/dev-yyy']),
     ('http://server.com/${branch_head}',
      ['http://server.com/stable-yyy',
       'http://server.com/dev-yyy']),
     ('http://server.com/${commit_id}',
      ['http://server.com/stable-xxx',
       'http://server.com/stable-yyy',
       'http://server.com/dev-xxx',
       'http://server.com/dev-yyy']),
 ])
 def test_webook_parse_url_for_push_event(
         baseapp, repo_push_event, base_data, template, expected_urls):
     base_data['push'] = {
         'branches': [{'name': 'stable'}, {'name': 'dev'}],
         'commits': [{'branch': 'stable', 'raw_id': 'stable-xxx'},
                     {'branch': 'stable', 'raw_id': 'stable-yyy'},
                     {'branch': 'dev', 'raw_id': 'dev-xxx'},
                     {'branch': 'dev', 'raw_id': 'dev-yyy'}]
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(repo_push_event, base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]