slack: updated slack integration to use the attachements for nicer formatting.

rhodecode/events/pullrequest.py

@@ -1,134 +1,137 b''
 # Copyright (C) 2016-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import 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.model.pull_request import PullRequestModel
         data = super(PullRequestEvent, self).as_dict()
 
         commits = _commits_as_dict(
             commit_ids=self.pullrequest.revisions,
             repos=[self.pullrequest.source_repo]
         )
         issues = _issues_as_dict(commits)
 
         data.update({
             'pullrequest': {
                 'title': self.pullrequest.title,
                 'issues': issues,
                 'pull_request_id': self.pullrequest.pull_request_id,
                 'url': PullRequestModel().get_url(self.pullrequest),
                 'status': self.pullrequest.calculated_review_status(),
                 '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')
 
 
 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')
 
 
 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')
 
 
 class PullRequestReviewEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request review has changed.
     """
     name = 'pullrequest-review'
     display_name = lazy_ugettext('pullrequest review changed')
 
 
 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')
 
 
 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')
 
     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)
             }
         })
         return data

rhodecode/events/repo.py

@@ -1,265 +1,265 b''
 # Copyright (C) 2016-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.model.db import User, Repository, Session
 from rhodecode.events.base import RhodecodeEvent
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
 
 def _commits_as_dict(commit_ids, repos):
     """
     Helper function to serialize commit_ids
 
     :param commit_ids: commits to get
     :param repos: list of repos to check
     """
     from rhodecode.lib.utils2 import extract_mentioned_users
-    from rhodecode.model.db import Repository
     from rhodecode.lib import helpers as h
-    from rhodecode.lib.helpers import process_patterns
-    from rhodecode.lib.helpers import urlify_commit_message
+    from rhodecode.lib.helpers import (
+        urlify_commit_message, process_patterns, chop_at_smart)
 
     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):
                 try:
                     cs = vcs_repo.get_changeset(commit_id)
                 except CommitDoesNotExistError:
                     continue # maybe its in next repo
 
                 cs_data = cs.__json__()
                 cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
                 cs_data['reviewers'] = reviewers
                 cs_data['url'] = h.url('changeset_home',
                     repo_name=repo.repo_name,
                     revision=cs_data['raw_id'],
                     qualified=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 as e:
             log.exception(e)
-            # we don't send any commits when crash happens, only full list matters
-            # we short circuit then.
+            # 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('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(RhodecodeEvent):
     """
     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()
         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)
             }
         })
         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')
 
 
 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')
 
 
 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')
 
 
 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')
 
 
 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']
 
 
 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')
 
 
 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')
 
 
 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')
 
 
 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')
 
     def __init__(self, repo_name, pushed_commit_ids, extras):
         super(RepoPushEvent, self).__init__(repo_name, extras)
         self.pushed_commit_ids = pushed_commit_ids
 
     def as_dict(self):
         data = super(RepoPushEvent, self).as_dict()
         branch_url = repo_url = data['repo']['url']
 
         commits = _commits_as_dict(
             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(
             commit['branch'] for commit in commits if commit['branch'])
         branches = [
             {
                 'name': branch,
                 'url': '{}/changelog?branch={}'.format(
                     data['repo']['url'], branch)
             }
             for branch in branches
         ]
 
         data['push'] = {
             'commits': commits,
             'issues': issues,
             'branches': branches,
         }
         return data

rhodecode/integrations/types/slack.py

@@ -1,263 +1,334 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from __future__ import unicode_literals
+import re
+import time
+import textwrap
+import logging
+
 import deform
-import re
-import logging
 import requests
 import colander
-import textwrap
 from celery.task import task
 from mako.template import Template
 
 from rhodecode import events
 from rhodecode.translation import _
 from rhodecode.lib import helpers as h
 from rhodecode.lib.celerylib import run_task
 from rhodecode.lib.colander_utils import strip_whitespace
 from rhodecode.integrations.types.base import IntegrationTypeBase
 
 log = logging.getLogger(__name__)
 
 
 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:'
         ),
     )
 
 
-repo_push_template = Template(r'''
-*${data['actor']['username']}* pushed to repo <${data['repo']['url']}|${data['repo']['repo_name']}>:
-%for branch, branch_commits in branches_commits.items():
-branch: <${branch_commits['branch']['url']}|${branch_commits['branch']['name']}>
-    %for commit in branch_commits['commits']:
-> <${commit['url']}|${commit['short_id']}> - ${commit['message_html']|html_to_slack_links}
-    %endfor
-%endfor
-''')
-
-
 class SlackIntegrationType(IntegrationTypeBase):
     key = 'slack'
     display_name = _('Slack')
     description = _('Send events such as repo pushes and pull requests to '
                     'your slack channel.')
     icon = '''<?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):
         if event.__class__ not in self.valid_events:
             log.debug('event not valid: %r' % event)
             return
 
         if event.name not in self.settings['events']:
             log.debug('event ignored: %r' % 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):
-            text = self.format_pull_request_comment_event(event, data)
+            (title, text, fields, overrides) \
+                = self.format_pull_request_comment_event(event, data)
         elif isinstance(event, events.PullRequestReviewEvent):
-            text = self.format_pull_request_review_event(event, data)
+            title, text = self.format_pull_request_review_event(event, data)
         elif isinstance(event, events.PullRequestEvent):
-            text = self.format_pull_request_event(event, data)
+            title, text = self.format_pull_request_event(event, data)
         elif isinstance(event, events.RepoPushEvent):
-            text = self.format_repo_push_event(data)
+            title, text = self.format_repo_push_event(data)
         elif isinstance(event, events.RepoCreateEvent):
-            text = self.format_repo_create_event(data)
+            title, text = self.format_repo_create_event(data)
         else:
             log.error('unhandled event type: %r' % event)
 
-        run_task(post_text_to_slack, self.settings, text)
+        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(
                 values=sorted(
                     [(e.name, e.display_name) for e in self.valid_events]
                 )
             ),
             description="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'],
             )
 
-        comment_status = ''
+        fields = None
+        overrides = None
+        status_text = None
+
         if data['comment']['status']:
-            comment_status = '[{}]: '.format(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']
+                }
+            ]
 
-        return (textwrap.dedent(
-            '''
-            *{user}* commented on pull request <{pr_url}|#{number}> - {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=data['pullrequest']['title'],
-                comment_text=comment_text
-            )
+        title = Template(textwrap.dedent(r'''
+        *${data['actor']['username']}* left ${data['comment']['type']} on pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']}>:
+        ''')).render(data=data, comment=event.comment)
+
+        text = Template(textwrap.dedent(r'''
+        *pull request title*: ${pr_title}
+        % if status_text:
+        *submitted status*: `${status_text}`
+        % endif
+        >>> ${comment_text}
+        ''')).render(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):
+        title = Template(textwrap.dedent(r'''
+        *${data['actor']['username']}* changed status of pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']} to `${data['pullrequest']['status']}`>:
+        ''')).render(data=data)
+
+        text = Template(textwrap.dedent(r'''
+        *pull request title*: ${pr_title}
+        ''')).render(
+            pr_title=data['pullrequest']['title'],
         )
 
-    def format_pull_request_review_event(self, event, data):
-        return (textwrap.dedent(
-            '''
-            Status changed to {pr_status} for pull request <{pr_url}|#{number}> - {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=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__))
 
-        return ('Pull request <{url}|#{number}> - {title} '
-                '`{action}` by *{user}*').format(
-            user=data['actor']['username'],
-            number=data['pullrequest']['pull_request_id'],
-            url=data['pullrequest']['url'],
-            title=data['pullrequest']['title'],
-            action=action
+        title = Template(textwrap.dedent(r'''
+        *${data['actor']['username']}* `${action}` pull request <${data['pullrequest']['url']}|#${data['pullrequest']['pull_request_id']}>:
+        ''')).render(data=data, action=action)
+
+        text = Template(textwrap.dedent(r'''
+        *pull request title*: ${pr_title}
+        %if data['pullrequest']['commits']:
+        *commits*: ${len(data['pullrequest']['commits'])}
+        %endif
+        ''')).render(
+            pr_title=data['pullrequest']['title'],
+            data=data
         )
 
+        return title, text
+
     def format_repo_push_event(self, data):
         branch_data = {branch['name']: branch
                        for branch in data['push']['branches']}
 
         branches_commits = {}
         for commit in data['push']['commits']:
             if commit['branch'] not in branches_commits:
                 branch_commits = {'branch': branch_data[commit['branch']],
                                   'commits': []}
                 branches_commits[commit['branch']] = branch_commits
 
             branch_commits = branches_commits[commit['branch']]
             branch_commits['commits'].append(commit)
 
-        result = repo_push_template.render(
+        title = Template(r'''
+        *${data['actor']['username']}* pushed to repo <${data['repo']['url']}|${data['repo']['repo_name']}>:
+        ''').render(data=data)
+
+        repo_push_template = Template(textwrap.dedent(r'''
+        %for branch, branch_commits in branches_commits.items():
+        branch: <${branch_commits['branch']['url']}|${branch_commits['branch']['name']}>
+        %for commit in branch_commits['commits']:
+        `<${commit['url']}|${commit['short_id']}>` - ${commit['message_html_title']|html_to_slack_links}
+        %endfor
+        %endfor
+        '''))
+
+        text = repo_push_template.render(
             data=data,
             branches_commits=branches_commits,
             html_to_slack_links=html_to_slack_links,
         )
-        return result
+
+        return title, text
 
     def format_repo_create_event(self, data):
-        return '<{}|{}> ({}) repository created by *{}*'.format(
-            data['repo']['url'],
-            data['repo']['repo_name'],
-            data['repo']['repo_type'],
-            data['actor']['username'],
-        )
+        title = Template(r'''
+        *${data['actor']['username']}* created new repository ${data['repo']['repo_name']}:
+        ''').render(data=data)
+
+        text = Template(textwrap.dedent(r'''
+        repo_url: ${data['repo']['url']}
+        repo_type: ${data['repo']['repo_type']}
+        ''')).render(data=data)
+
+        return title, text
 
 
 def html_to_slack_links(message):
     return re.compile(r'<a .*?href=["\'](.+?)".*?>(.+?)</a>').sub(
         r'<\1|\2>', message)
 
 
 @task(ignore_result=True)
-def post_text_to_slack(settings, text):
-    log.debug('sending %s to slack %s' % (text, settings['service']))
-    resp = requests.post(settings['service'], json={
+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'),
-        "text": text,
-        "icon_emoji": settings.get('icon_emoji', ':studio_microphone:')
-    })
+        "attachments": [message_data]
+    }
+
+    resp = requests.post(settings['service'], json=json_message)
     resp.raise_for_status()  # raise exception on a failed request