def api_raygun_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: Text = REQ(default='raygun'),
topic: Optional[Text] = REQ(default='test')) -> HttpResponse:
# The payload contains 'event' key. This 'event' key has a value of either
# 'error_notification' or 'error_activity'. 'error_notification' happens
# when an error is caught in an application, where as 'error_activity'
# happens when an action is being taken for the error itself
# (ignored/resolved/assigned/etc.).
event = payload['event']
# Because we wanted to create a message for all of the payloads, it is best
# to handle them separately. This is because some payload keys don't exist
# in the other event.
if event == 'error_notification':
message = compose_notification_message(payload)
elif event == 'error_activity':
message = compose_activity_message(payload)
else:
message = "Unsupported event type: {}".format(event)
check_send_stream_message(user_profile, request.client, stream, topic,
message)
return json_success()
def api_bitbucket_webhook(request, user_profile, payload=REQ(validator=check_dict([])),
stream=REQ(default='commits'), branches=REQ(default=None)):
# type: (HttpRequest, UserProfile, Mapping[Text, Any], Text, Optional[Text]) -> HttpResponse
repository = payload['repository']
commits = [
{
'name': payload.get('user'),
'sha': commit.get('raw_node'),
'message': commit.get('message'),
'url': u'{}{}commits/{}'.format(
payload.get('canon_url'),
repository.get('absolute_url'),
commit.get('raw_node'))
}
for commit in payload['commits']
]
if len(commits) == 0:
# Bitbucket doesn't give us enough information to really give
# a useful message :/
subject = repository['name']
content = (u"%s [force pushed](%s)"
% (payload['user'],
payload['canon_url'] + repository['absolute_url']))
else:
branch = payload['commits'][-1]['branch']
if branches is not None and branches.find(branch) == -1:
return json_success()
content = get_push_commits_event_message(payload['user'], None, branch, commits)
subject = SUBJECT_WITH_BRANCH_TEMPLATE.format(repo=repository['name'], branch=branch)
check_send_stream_message(user_profile, get_client("ZulipBitBucketWebhook"),
stream, subject, content)
return json_success()
def api_splunk_webhook(request, user_profile,
payload=REQ(argument_type='body'), stream=REQ(default='splunk'),
topic=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text, Optional[Text]) -> HttpResponse
# use default values if expected data is not provided
search_name = payload.get('search_name', 'Missing search_name')
results_link = payload.get('results_link', 'Missing results_link')
host = payload.get('result', {}).get('host', 'Missing host')
source = payload.get('result', {}).get('source', 'Missing source')
raw = payload.get('result', {}).get('_raw', 'Missing _raw')
# if no topic provided, use search name but truncate if too long
if topic is None:
if len(search_name) >= MAX_SUBJECT_LENGTH:
topic = "{}...".format(search_name[:(MAX_SUBJECT_LENGTH - 3)])
else:
topic = search_name
# construct the message body
body = "Splunk alert from saved search"
body_template = ('\n[{search}]({link})\nhost: {host}'
'\nsource: {source}\n\nraw: {raw}')
body += body_template.format(search = search_name, link = results_link,
host = host, source = source, raw = raw)
# send the message
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def api_jira_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='jira')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
event = get_event_type(payload)
if event == 'jira:issue_created':
subject = get_issue_subject(payload)
content = handle_created_issue_event(payload)
elif event == 'jira:issue_deleted':
subject = get_issue_subject(payload)
content = handle_deleted_issue_event(payload)
elif event == 'jira:issue_updated':
subject = get_issue_subject(payload)
content = handle_updated_issue_event(payload, user_profile)
elif event in IGNORED_EVENTS:
return json_success()
else:
if event is None:
if not settings.TEST_SUITE:
message = u"Got JIRA event with None event type: {}".format(payload)
logging.warning(message)
return json_error(_("Event is not given by JIRA"))
else:
if not settings.TEST_SUITE:
logging.warning("Got JIRA event type we don't support: {}".format(event))
return json_success()
check_send_stream_message(user_profile, request.client, stream, subject, content)
return json_success()
def api_wordpress_webhook(request, user_profile,
stream=REQ(default="wordpress"),
topic=REQ(default="WordPress Notification"),
hook=REQ(default="WordPress Action"),
post_title=REQ(default="New WordPress Post"),
post_type=REQ(default="post"),
post_url=REQ(default="WordPress Post URL"),
display_name=REQ(default="New User Name"),
user_email=REQ(default="New User Email"),
user_login=REQ(default="Logged in User")):
# type: (HttpRequest, UserProfile, text_type, text_type, text_type, text_type, text_type, text_type, text_type, text_type, text_type) -> HttpResponse
# remove trailing whitespace (issue for some test fixtures)
hook = hook.rstrip()
if hook == 'publish_post' or hook == 'publish_page':
data = PUBLISH_POST_OR_PAGE_TEMPLATE.format(type=post_type, title=post_title, url=post_url)
elif hook == 'user_register':
data = USER_REGISTER_TEMPLATE.format(name=display_name, email=user_email)
elif hook == 'wp_login':
data = WP_LOGIN_TEMPLATE.format(name=user_login)
else:
return json_error(_("Unknown WordPress webhook action: " + hook))
check_send_stream_message(user_profile, get_client("ZulipWordPressWebhook"),
stream, topic, data)
return json_success()
def api_deskdotcom_webhook(request, user_profile, data=REQ(),
topic=REQ(default="Desk.com notification"),
stream=REQ(default="desk.com")):
# type: (HttpRequest, UserProfile, Text, Text, Text) -> HttpResponse
check_send_stream_message(user_profile, get_client("ZulipDeskWebhook"),
stream, topic, data)
return json_success()
def api_beanstalk_webhook(request, user_profile,
payload=REQ(validator=check_dict([])),
branches=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Any], Optional[Text]) -> HttpResponse
# Beanstalk supports both SVN and git repositories
# We distinguish between the two by checking for a
# 'uri' key that is only present for git repos
git_repo = 'uri' in payload
if git_repo:
if branches is not None and branches.find(payload['branch']) == -1:
return json_success()
# To get a linkable url,
for commit in payload['commits']:
commit['author'] = {'username': commit['author']['name']}
subject, content = build_message_from_gitlog(user_profile, payload['repository']['name'],
payload['ref'], payload['commits'],
payload['before'], payload['after'],
payload['repository']['url'],
payload['pusher_name'])
else:
author = payload.get('author_full_name')
url = payload.get('changeset_url')
revision = payload.get('revision')
(short_commit_msg, _, _) = payload['message'].partition("\n")
subject = "svn r%s" % (revision,)
content = "%s pushed [revision %s](%s):\n\n> %s" % (author, revision, url, short_commit_msg)
check_send_stream_message(user_profile, get_client("ZulipBeanstalkWebhook"),
"commits", subject, content)
return json_success()
def api_travis_webhook(request: HttpRequest, user_profile: UserProfile,
stream: str = REQ(default='travis'),
topic: str = REQ(default=None),
ignore_pull_requests: bool = REQ(validator=check_bool, default=True),
message: Dict[str, str]=REQ('payload', validator=check_dict([
('author_name', check_string),
('status_message', check_string),
('compare_url', check_string),
]))) -> HttpResponse:
message_status = message['status_message']
if ignore_pull_requests and message['type'] == 'pull_request':
return json_success()
if message_status in GOOD_STATUSES:
emoji = ':thumbsup:'
elif message_status in BAD_STATUSES:
emoji = ':thumbsdown:'
else:
emoji = "(No emoji specified for status '{}'.)".format(message_status)
body = MESSAGE_TEMPLATE.format(
message['author_name'],
message_status,
emoji,
message['compare_url'],
message['build_url']
)
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def api_basecamp_webhook(request, user_profile, payload=REQ(argument_type='body'),
stream=REQ(default='basecamp')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
event = get_event_type(payload)
if event not in SUPPORT_EVENTS:
logging.warning("Basecamp {} event is not supported".format(event))
return json_success()
subject = get_project_name(payload)
if event.startswith('document_'):
body = get_document_body(event, payload)
elif event.startswith('question_answer_'):
body = get_questions_answer_body(event, payload)
elif event.startswith('question_'):
body = get_questions_body(event, payload)
elif event.startswith('message_'):
body = get_message_body(event, payload)
elif event.startswith('todolist_'):
body = get_todo_list_body(event, payload)
elif event.startswith('todo_'):
body = get_todo_body(event, payload)
elif event.startswith('comment_'):
body = get_comment_body(event, payload)
else:
logging.warning("Basecamp handling of {} event is not implemented".format(event))
return json_success()
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def send_formated_pagerduty(user_profile: UserProfile,
client: Client,
stream: Text,
message_type: Text,
format_dict: Dict[str, Any],
topic: Optional[Text]) -> None:
if message_type in ('incident.trigger', 'incident.unacknowledge'):
template = (u':imp: Incident '
u'[{incident_num}]({incident_url}) {action} by '
u'[{service_name}]({service_url}) and assigned to '
u'[{assigned_to_username}@]({assigned_to_url})\n\n>{trigger_message}')
elif message_type == 'incident.resolve' and format_dict['resolved_by_url']:
template = (u':grinning: Incident '
u'[{incident_num}]({incident_url}) resolved by '
u'[{resolved_by_username}@]({resolved_by_url})\n\n>{trigger_message}')
elif message_type == 'incident.resolve' and not format_dict['resolved_by_url']:
template = (u':grinning: Incident '
u'[{incident_num}]({incident_url}) resolved\n\n>{trigger_message}')
else:
template = (u':no_good: Incident [{incident_num}]({incident_url}) '
u'{action} by [{assigned_to_username}@]({assigned_to_url})\n\n>{trigger_message}')
subject = topic or u'incident {incident_num}'.format(**format_dict)
body = template.format(**format_dict)
check_send_stream_message(user_profile, client, stream, subject, body)
def api_gogs_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any]=REQ(argument_type='body'),
stream: Text=REQ(default='commits'),
branches: Optional[Text]=REQ(default=None)) -> HttpResponse:
repo = payload['repository']['name']
event = request.META['HTTP_X_GOGS_EVENT']
if event == 'push':
branch = payload['ref'].replace('refs/heads/', '')
if branches is not None and branches.find(branch) == -1:
return json_success()
body = format_push_event(payload)
topic = SUBJECT_WITH_BRANCH_TEMPLATE.format(
repo=repo,
branch=branch
)
elif event == 'create':
body = format_new_branch_event(payload)
topic = SUBJECT_WITH_BRANCH_TEMPLATE.format(
repo=repo,
branch=payload['ref']
)
elif event == 'pull_request':
body = format_pull_request_event(payload)
topic = SUBJECT_WITH_PR_OR_ISSUE_INFO_TEMPLATE.format(
repo=repo,
type='PR',
id=payload['pull_request']['id'],
title=payload['pull_request']['title']
)
else:
return json_error(_('Invalid event "{}" in request headers').format(event))
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def api_papertrail_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='papertrail'),
topic=REQ(default='logs')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text, Text) -> HttpResponse
# construct the message of the message
message_template = '**"{}"** search found **{}** matches - {}\n```'
message = [message_template.format(payload["saved_search"]["name"],
str(len(payload["events"])),
payload["saved_search"]["html_search_url"])]
for i, event in enumerate(payload["events"]):
event_text = '{} {} {}:\n {}'.format(event["display_received_at"],
event["source_name"],
payload["saved_search"]["query"],
event["message"])
message.append(event_text)
if i >= 3:
message.append('```\n[See more]({})'.format(payload["saved_search"]["html_search_url"]))
break
else:
message.append('```')
post = '\n'.join(message)
# send the message
check_send_stream_message(user_profile, request.client, stream, topic, post)
# return json result
return json_success()
def api_freshdesk_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any]=REQ(argument_type='body'),
stream: Text=REQ(default='freshdesk')) -> HttpResponse:
ticket_data = payload["freshdesk_webhook"]
required_keys = [
"triggered_event", "ticket_id", "ticket_url", "ticket_type",
"ticket_subject", "ticket_description", "ticket_status",
"ticket_priority", "requester_name", "requester_email",
]
for key in required_keys:
if ticket_data.get(key) is None:
logging.warning("Freshdesk webhook error. Payload was:")
logging.warning(request.body)
return json_error(_("Missing key %s in JSON") % (key,))
ticket = TicketDict(ticket_data)
subject = "#%s: %s" % (ticket.id, ticket.subject)
event_info = parse_freshdesk_event(ticket.triggered_event)
if event_info[1] == "created":
content = format_freshdesk_ticket_creation_message(ticket)
elif event_info[0] == "note_type":
content = format_freshdesk_note_message(ticket, event_info)
elif event_info[0] in ("status", "priority"):
content = format_freshdesk_property_change_message(ticket, event_info)
else:
# Not an event we know handle; do nothing.
return json_success()
check_send_stream_message(user_profile, get_client("ZulipFreshdeskWebhook"),
stream, subject, content)
return json_success()
def api_airbrake_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: Text = REQ(default='airbrake')) -> HttpResponse:
subject = get_subject(payload)
body = get_body(payload)
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def api_heroku_webhook(request: HttpRequest, user_profile: UserProfile,
stream: Text=REQ(default="heroku"), head: Text=REQ(),
app: Text=REQ(), user: Text=REQ(),
url: Text=REQ(), git_log: Text=REQ()) -> HttpResponse:
template = "{} deployed version {} of [{}]({})\n> {}"
content = template.format(user, head, app, url, git_log)
check_send_stream_message(user_profile, request.client, stream, app, content)
return json_success()
def api_circleci_webhook(request, user_profile, payload=REQ(argument_type='body'),
stream=REQ(default='circleci')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
payload = payload['payload']
subject = get_subject(payload)
body = get_body(payload)
check_send_stream_message(user_profile, request.client, stream, subject, body)
return json_success()
def api_hellosign_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Dict[str, Any]]=REQ(argument_type='body'),
stream: str=REQ(default='hellosign'),
topic: str=REQ(default=None)) -> HttpResponse:
model_payload = ready_payload(payload['signature_request']['signatures'], payload)
body = format_body(payload['signature_request']['signatures'], model_payload)
topic = topic or model_payload['contract_title']
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def api_dropbox_webhook(request: HttpRequest, user_profile: UserProfile,
stream: Text=REQ(default='test'),
topic: Text=REQ(default='Dropbox')) -> HttpResponse:
if request.method == 'GET':
return HttpResponse(request.GET['challenge'])
elif request.method == 'POST':
check_send_stream_message(user_profile, request.client,
stream, topic, "File has been updated on Dropbox!")
return json_success()
def api_appfollow_webhook(request, user_profile, stream=REQ(default="appfollow"),
payload=REQ(argument_type="body")):
# type: (HttpRequest, UserProfile, Text, Dict[str, Any]) -> HttpResponse
message = payload["text"]
app_name = re.search('\A(.+)', message).group(0)
check_send_stream_message(user_profile, request.client, stream,
app_name, convert_markdown(message))
return json_success()
def api_codeship_webhook(request, user_profile, payload=REQ(argument_type='body'),
stream=REQ(default='codeship')):
# type: (HttpRequest, UserProfile, Dict[str, Any], str) -> HttpResponse
payload = payload['build']
subject = get_subject_for_http_request(payload)
body = get_body_for_http_request(payload)
check_send_stream_message(user_profile, request.client, stream, subject, body)
return json_success()
def api_sentry_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='sentry')):
# type: (HttpRequest, UserProfile, Dict[str, Any], str) -> HttpResponse
subject = "{}".format(payload.get('project_name'))
body = "New {} [issue]({}): {}.".format(payload['level'].upper(),
payload.get('url'),
payload.get('message'))
check_send_stream_message(user_profile, request.client, stream, subject, body)
return json_success()
def api_github_webhook(
request, user_profile, payload=REQ(argument_type='body'),
stream=REQ(default='github'), branches=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text, Text) -> HttpResponse
event = get_event(request, payload, branches)
if event is not None:
subject = get_subject_based_on_type(payload, event)
body = get_body_function_based_on_type(event)(payload)
check_send_stream_message(user_profile, request.client, stream, subject, body)
return json_success()
def api_zapier_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any]=REQ(argument_type='body'),
stream: str=REQ(default='zapier')) -> HttpResponse:
subject = payload.get('subject')
content = payload.get('content')
if subject is None:
return json_error(_("Subject can't be empty"))
if content is None:
return json_error(_("Content can't be empty"))
check_send_stream_message(user_profile, request.client, stream, subject, content)
return json_success()
def api_appfollow_webhook(request: HttpRequest, user_profile: UserProfile,
stream: Text=REQ(default="appfollow"),
topic: Optional[Text]=REQ(default=None),
payload: Dict[str, Any]=REQ(argument_type="body")) -> HttpResponse:
message = payload["text"]
app_name = re.search('\A(.+)', message).group(0)
if topic is None:
topic = app_name
check_send_stream_message(sender=user_profile, client=request.client, stream_name=stream,
topic=topic, body=convert_markdown(message))
return json_success()
def api_zendesk_webhook(request, user_profile, ticket_title=REQ(), ticket_id=REQ(),
message=REQ(), stream=REQ(default="zendesk")):
# type: (HttpRequest, UserProfile, str, str, str, str) -> HttpResponse
"""
Zendesk uses trigers with message templates. This webhook uses the
ticket_id and ticket_title to create a subject. And passes with zendesk
user's configured message to zulip.
"""
subject = truncate('#%s: %s' % (ticket_id, ticket_title), 60)
check_send_stream_message(user_profile, get_client('ZulipZenDeskWebhook'),
stream, subject, message)
return json_success()
def send_raw_pagerduty_json(user_profile: UserProfile,
client: Client,
stream: Text,
message: Dict[str, Any],
topic: Optional[Text]) -> None:
subject = topic or 'pagerduty'
body = (
u'Unknown pagerduty message\n'
u'```\n'
u'%s\n'
u'```') % (ujson.dumps(message, indent=2),)
check_send_stream_message(user_profile, client, stream, subject, body)
def api_gitlab_webhook(request: HttpRequest, user_profile: UserProfile,
stream: Text=REQ(default='gitlab'),
topic: Text=REQ(default=None),
payload: Dict[str, Any]=REQ(argument_type='body'),
branches: Optional[Text]=REQ(default=None)) -> HttpResponse:
event = get_event(request, payload, branches)
if event is not None:
body = get_body_based_on_event(event)(payload)
if topic is None:
topic = get_subject_based_on_event(event, payload)
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def api_gci_webhook(request: HttpRequest, user_profile: UserProfile, stream: Text=REQ(default='gci'),
payload: Dict[Text, Any]=REQ(argument_type='body')) -> HttpResponse:
event = get_event(payload)
if event is not None:
body = get_body_based_on_event(event)(payload)
subject = GCI_SUBJECT_TEMPLATE.format(
student_name=payload['task_claimed_by']
)
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def api_gci_webhook(request, user_profile, stream=REQ(default='gci'),
payload=REQ(argument_type='body')):
# type: (HttpRequest, UserProfile, Text, Dict[Text, Any]) -> HttpResponse
event = get_event(payload)
if event is not None:
body = get_body_based_on_event(event)(payload)
subject = GCI_SUBJECT_TEMPLATE.format(
task_name=payload['task_definition_name']
)
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def api_taiga_webhook(request, user_profile, message=REQ(argument_type='body'),
stream=REQ(default='taiga'), topic=REQ(default='General')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text, Text) -> HttpResponse
parsed_events = parse_message(message)
content_lines = []
for event in parsed_events:
content_lines.append(generate_content(event) + '\n')
content = "".join(sorted(content_lines))
check_send_stream_message(user_profile, request.client, stream, topic, content)
return json_success()
def api_pivotal_webhook(request, user_profile, stream=REQ()):
# type: (HttpRequest, UserProfile, Text) -> HttpResponse
subject = content = None
try:
subject, content = api_pivotal_webhook_v3(request, user_profile,
stream)
except Exception:
# Attempt to parse v5 JSON payload
subject, content = api_pivotal_webhook_v5(request, user_profile,
stream)
if subject is None or content is None:
return json_error(_("Unable to handle Pivotal payload"))
check_send_stream_message(user_profile, request.client, stream, subject,
content)
return json_success()
def api_taiga_webhook(request,
user_profile,
message=REQ(argument_type='body'),
stream=REQ(default='taiga'),
topic=REQ(default='General')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text, Text) -> HttpResponse
parsed_events = parse_message(message)
content_lines = []
for event in parsed_events:
content_lines.append(generate_content(event) + '\n')
content = "".join(sorted(content_lines))
check_send_stream_message(user_profile, request.client, stream, topic,
content)
return json_success()
def api_gosquared_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='gosquared'),
topic=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Dict[str, Any]], Text, Text) -> HttpResponse
domain_name = payload['siteDetails']['domain']
user_num = payload['concurrents']
user_acc = payload['siteDetails']['acct']
acc_url = 'https://www.gosquared.com/now/' + user_acc
body = BODY_TEMPLATE.format(website_name=domain_name, website_url=acc_url, user_num=user_num)
# allows for customisable topics
if topic is None:
topic = 'GoSquared - {website_name}'.format(website_name=domain_name)
check_send_stream_message(user_profile, request.client, stream,
topic, body)
return json_success()
def api_mention_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='mention'),
topic=REQ(default='news')):
# type: (HttpRequest, UserProfile, Dict[str, Iterable[Dict[str, Any]]], Text, Optional[Text]) -> HttpResponse
title = payload["title"]
source_url = payload["url"]
description = payload["description"]
# construct the body of the message
body = '**[%s](%s)**:\n%s' % (title, source_url, description)
# send the message
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
def api_delighted_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='delighted'),
topic=REQ(default='Survey Response')):
# type: (HttpRequest, UserProfile, Dict[str, Dict[str, Any]], text_type, text_type) -> HttpResponse
person = payload['event_data']['person']
selected_payload = {'email': person['email']}
selected_payload['score'] = payload['event_data']['score']
selected_payload['comment'] = payload['event_data']['comment']
BODY_TEMPLATE = body_template(selected_payload['score'])
body = BODY_TEMPLATE.format(**selected_payload)
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
def api_freshdesk_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='freshdesk')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
ticket_data = payload["freshdesk_webhook"]
required_keys = [
"triggered_event",
"ticket_id",
"ticket_url",
"ticket_type",
"ticket_subject",
"ticket_description",
"ticket_status",
"ticket_priority",
"requester_name",
"requester_email",
]
for key in required_keys:
if ticket_data.get(key) is None:
logging.warning("Freshdesk webhook error. Payload was:")
logging.warning(request.body)
return json_error(_("Missing key %s in JSON") % (key, ))
ticket = TicketDict(ticket_data)
subject = "#%s: %s" % (ticket.id, ticket.subject)
event_info = parse_freshdesk_event(ticket.triggered_event)
if event_info[1] == "created":
content = format_freshdesk_ticket_creation_message(ticket)
elif event_info[0] == "note_type":
content = format_freshdesk_note_message(ticket, event_info)
elif event_info[0] in ("status", "priority"):
content = format_freshdesk_property_change_message(ticket, event_info)
else:
# Not an event we know handle; do nothing.
return json_success()
check_send_stream_message(user_profile,
get_client("ZulipFreshdeskWebhook"), stream,
subject, content)
return json_success()
def api_pingdom_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='pingdom')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
check_type = get_check_type(payload)
if check_type in SUPPORTED_CHECK_TYPES:
subject = get_subject_for_http_request(payload)
body = get_body_for_http_request(payload)
else:
return json_error(
_('Unsupported check_type: {check_type}').format(
check_type=check_type))
check_send_stream_message(user_profile, request.client, stream, subject,
body)
return json_success()
def api_appfollow_webhook(
request: HttpRequest,
user_profile: UserProfile,
stream: Text = REQ(default="appfollow"),
topic: Optional[Text] = REQ(default=None),
payload: Dict[str, Any] = REQ(argument_type="body")
) -> HttpResponse:
message = payload["text"]
app_name = re.search('\A(.+)', message).group(0)
if topic is None:
topic = app_name
check_send_stream_message(sender=user_profile,
client=request.client,
stream_name=stream,
topic=topic,
body=convert_markdown(message))
return json_success()
def api_flock_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: str = REQ(default='test'),
topic: str = REQ(default='Flock notifications')
) -> HttpResponse:
if len(payload["text"]) != 0:
message_body = payload["text"]
else:
message_body = payload["notification"]
body = u"{}".format(message_body)
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
def check_send_webhook_message(
request: HttpRequest,
user_profile: UserProfile,
topic: Text,
body: Text,
stream: Optional[Text] = REQ(default=None),
user_specified_topic: Optional[Text] = REQ("topic", default=None)
) -> None:
if stream is None:
assert user_profile.bot_owner is not None
check_send_private_message(user_profile, request.client,
user_profile.bot_owner, body)
else:
if user_specified_topic is not None:
topic = user_specified_topic
check_send_stream_message(user_profile, request.client, stream, topic,
body)
def api_facebook_webhook(request: HttpRequest, user_profile: UserProfile,
stream: Text=REQ(default='Facebook'), token: Text=REQ()) -> HttpResponse:
if request.method == 'GET': # facebook webhook verify
if request.GET.get("hub.mode") == 'subscribe':
if request.GET.get('hub.verify_token') == token:
return HttpResponse(request.GET.get('hub.challenge'))
else:
return json_error(_('Error: Token is wrong'))
return json_error(_('Error: Unsupported method'))
payload = json.loads(request.body.decode("UTF-8"))
event = get_event(payload)
if event is not None:
body = get_body_based_on_event(event)(payload)
subject = event + " notification"
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def api_opbeat_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: str = REQ(default="opbeat")
) -> HttpResponse:
"""
This uses the subject name from opbeat to make the subject,
and the summary from Opbeat as the message body, with
details about the object mentioned.
"""
message_subject = payload['title']
message = format_object(payload, 'base', '')
check_send_stream_message(user_profile, get_client('ZulipOpbeatWebhook'),
stream, message_subject, message)
return json_success()
def api_transifex_webhook(request,
user_profile,
project=REQ(),
resource=REQ(),
language=REQ(),
translated=REQ(default=None),
reviewed=REQ(default=None),
stream=REQ(default='transifex')):
# type: (HttpRequest, UserProfile, str, str, str, Optional[int], Optional[int], str) -> HttpResponse
subject = "{} in {}".format(project, language)
if translated:
body = "Resource {} fully translated.".format(resource)
elif reviewed:
body = "Resource {} fully reviewed.".format(resource)
else:
return json_error(_("Transifex wrong request"))
check_send_stream_message(user_profile, request.client, stream, subject,
body)
return json_success()
def api_statuspage_webhook(request: HttpRequest, user_profile: UserProfile,
payload: Dict[str, Any]=REQ(argument_type='body'),
stream: str=REQ(default='statuspage-test')) -> HttpResponse:
status = payload["page"]["status_indicator"]
if status == "none":
topic = get_incident_topic(payload)
body = get_incident_events_body(payload)
else:
topic = get_component_topic(payload)
body = get_components_update_body(payload)
check_send_stream_message(user_profile,
request.client,
stream,
topic,
body)
return json_success()
def api_groove_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: Text = REQ(default='groove'),
topic: Optional[Text] = REQ(default='notifications')
) -> HttpResponse:
# The event identifier is stored in the X_GROOVE_EVENT header.
event = request.META['X_GROOVE_EVENT']
# We listen to several events that are used for notifications.
# Other events are ignored.
if event in EVENTS_FUNCTION_MAPPER:
body = EVENTS_FUNCTION_MAPPER[event](payload)
if body is not None:
check_send_stream_message(user_profile, request.client, stream,
topic, body)
return json_success()
def api_beeminder_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: Text = REQ(default="beeminder"),
email: str = REQ(default='*****@*****.**'),
topic: Text = REQ(default='beekeeper')
) -> HttpResponse:
secret = payload["goal"]["secret"]
goal_name = payload["goal"]["slug"]
losedate = payload["goal"]["losedate"]
limsum = payload["goal"]["limsum"]
pledge = payload["goal"]["pledge"]
time_remain = (losedate - current_time) / 3600 # time in hours
# To show user's probable reaction by looking at pledge amount
if pledge > 0:
expression = ':worried:'
else:
expression = ':relieved:'
if not secret:
# In this case notifications will be sent to stream
name = get_user_name(email)
body = u"Hello **{}**! I am the Beeminder bot! :octopus: \n You are going to derail \
from goal **{}** in **{:0.1f} hours** \n You need **{}** to avoid derailing \n * Pledge: **{}$** {}"
body = body.format(name, goal_name, time_remain, limsum, pledge,
expression)
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
else:
# In this case PM will be sent to user
p = get_user_profile_by_email(email)
body = u"I am the Beeminder bot! :octopus: \n You are going to derail from \
goal **{}** in **{:0.1f} hours** \n You need **{}** to avoid derailing \n * Pledge: **{}$**{}"
body = body.format(goal_name, time_remain, limsum, pledge, expression)
check_send_private_message(user_profile, request.client, p, body)
return json_success()
def api_slack_webhook(request: HttpRequest, user_profile: UserProfile,
user_name: str=REQ(),
text: str=REQ(),
channel_name: str=REQ(),
stream: str=REQ(default='slack'),
channels_map_to_topics: str=REQ(default='1')) -> HttpRequest:
if channels_map_to_topics not in list(VALID_OPTIONS.values()):
return json_error(_('Error: channels_map_to_topics parameter other than 0 or 1'))
if channels_map_to_topics == VALID_OPTIONS['SHOULD_BE_MAPPED']:
subject = "channel: {}".format(channel_name)
else:
stream = channel_name
subject = _("Message from Slack")
content = ZULIP_MESSAGE_TEMPLATE.format(message_sender=user_name, text=text)
check_send_stream_message(user_profile, request.client, stream, subject, content)
return json_success()
def api_bitbucket_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Mapping[Text, Any] = REQ(validator=check_dict([])),
stream: Text = REQ(default='commits'),
branches: Optional[Text] = REQ(default=None)
) -> HttpResponse:
repository = payload['repository']
commits = [{
'name':
payload.get('user'),
'sha':
commit.get('raw_node'),
'message':
commit.get('message'),
'url':
u'{}{}commits/{}'.format(payload.get('canon_url'),
repository.get('absolute_url'),
commit.get('raw_node'))
} for commit in payload['commits']]
if len(commits) == 0:
# Bitbucket doesn't give us enough information to really give
# a useful message :/
subject = repository['name']
content = (u"%s [force pushed](%s)" %
(payload['user'],
payload['canon_url'] + repository['absolute_url']))
else:
branch = payload['commits'][-1]['branch']
if branches is not None and branches.find(branch) == -1:
return json_success()
content = get_push_commits_event_message(payload['user'], None, branch,
commits)
subject = SUBJECT_WITH_BRANCH_TEMPLATE.format(repo=repository['name'],
branch=branch)
check_send_stream_message(user_profile,
get_client("ZulipBitBucketWebhook"), stream,
subject, content)
return json_success()
def api_crashlytics_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='crashlytics')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
event = payload['event']
if event == VERIFICATION_EVENT:
subject = CRASHLYTICS_SETUP_SUBJECT_TEMPLATE
body = CRASHLYTICS_SETUP_MESSAGE_TEMPLATE
else:
issue_body = payload['payload']
subject = CRASHLYTICS_SUBJECT_TEMPLATE.format(
display_id=issue_body['display_id'], title=issue_body['title'])
body = CRASHLYTICS_MESSAGE_TEMPLATE.format(
impacted_devices_count=issue_body['impacted_devices_count'],
url=issue_body['url'])
check_send_stream_message(user_profile, request.client, stream, subject,
body)
return json_success()
def api_bitbucket2_webhook(request, user_profile, payload=REQ(argument_type='body'),
stream=REQ(default='bitbucket'), branches=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Any], str, Optional[Text]) -> HttpResponse
type = get_type(request, payload)
if type != 'push':
subject = get_subject_based_on_type(payload, type)
body = get_body_based_on_type(type)(payload)
check_send_stream_message(user_profile, request.client,
stream, subject, body)
else:
branch = get_branch_name_for_push_event(payload)
if branch and branches:
if branches.find(branch) == -1:
return json_success()
subjects = get_push_subjects(payload)
bodies_list = get_push_bodies(payload)
for body, subject in zip(bodies_list, subjects):
check_send_stream_message(user_profile, request.client,
stream, subject, body)
return json_success()
def api_helloworld_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Iterable[Dict[str, Any]]] = REQ(argument_type='body'),
stream: Text = REQ(default='test'),
topic: Text = REQ(default='Hello World')
) -> HttpResponse:
# construct the body of the message
body = 'Hello! I am happy to be here! :smile:'
# try to add the Wikipedia article of the day
body_template = '\nThe Wikipedia featured article for today is **[{featured_title}]({featured_url})**'
body += body_template.format(**payload)
# send the message
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
def api_semaphore_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='builds')):
# type: (HttpRequest, UserProfile, Dict[str, Any], str) -> HttpResponse
# semaphore only gives the last commit, even if there were multiple commits
# since the last build
branch_name = payload["branch_name"]
project_name = payload["project_name"]
result = payload["result"]
event = payload["event"]
commit_id = payload["commit"]["id"]
commit_url = payload["commit"]["url"]
author_email = payload["commit"]["author_email"]
message = payload["commit"]["message"]
if event == "build":
build_url = payload["build_url"]
build_number = payload["build_number"]
content = u"[build %s](%s): %s\n" % (build_number, build_url, result)
elif event == "deploy":
build_url = payload["build_html_url"]
build_number = payload["build_number"]
deploy_url = payload["html_url"]
deploy_number = payload["number"]
server_name = payload["server_name"]
content = u"[deploy %s](%s) of [build %s](%s) on server %s: %s\n" % \
(deploy_number, deploy_url, build_number, build_url, server_name, result)
else: # should never get here
content = u"%s: %s\n" % (event, result)
content += "!avatar(%s) [`%s`](%s): %s" % (author_email, commit_id[:7],
commit_url, message)
subject = u"%s/%s" % (project_name, branch_name)
check_send_stream_message(user_profile, request.client, stream, subject,
content)
return json_success()
def api_newrelic_webhook(request, user_profile, stream=REQ(default='newrelic'),
alert=REQ(validator=check_dict([]), default=None),
deployment=REQ(validator=check_dict([]), default=None)):
# type: (HttpRequest, UserProfile, Text, Optional[Dict[str, Any]], Optional[Dict[str, Any]]) -> HttpResponse
if alert:
# Use the message as the subject because it stays the same for
# "opened", "acknowledged", and "closed" messages that should be
# grouped.
subject = alert['message']
content = "%(long_description)s\n[View alert](%(alert_url)s)" % (alert)
elif deployment:
subject = "%s deploy" % (deployment['application_name'])
content = """`%(revision)s` deployed by **%(deployed_by)s**
%(description)s
%(changelog)s""" % (deployment)
else:
return json_error(_("Unknown webhook request"))
check_send_stream_message(user_profile, request.client, stream, subject, content)
return json_success()
def api_trello_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='trello')):
# type: (HttpRequest, UserProfile, Mapping[str, Any], Text) -> HttpResponse
payload = ujson.loads(request.body)
action_type = payload['action'].get('type')
try:
message = get_subject_and_body(payload, action_type)
if message is None:
return json_success()
else:
subject, body = message
except UnsupportedAction:
return json_error(
_('Unsupported action_type: {action_type}'.format(
action_type=action_type)))
check_send_stream_message(user_profile, request.client, stream, subject,
body)
return json_success()
def api_homeassistant_webhook(request,
user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default="homeassistant")):
# type: (HttpRequest, UserProfile, Dict[str, str], Text) -> HttpResponse
# construct the body of the message
body = payload["message"]
# set the topic to the topic parameter, if given
if "topic" in payload:
topic = payload["topic"]
else:
topic = "homeassistant"
# send the message
check_send_stream_message(user_profile, request.client, stream, topic,
body)
# return json result
return json_success()
def api_opsgenie_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='opsgenie')):
# type: (HttpRequest, UserProfile, Dict[str, Any], Text) -> HttpResponse
# construct the body of the message
info = {"additional_info": '',
"alert_type": payload['action'],
"alert_id": payload['alert']['alertId'],
"integration_name": payload['integrationName'],
"tags": ' '.join(['`' + tag + '`' for tag in payload['alert'].get('tags', [])]),
}
topic = info['integration_name']
if 'note' in payload['alert']:
info['additional_info'] += "Note: *{}*\n".format(payload['alert']['note'])
if 'recipient' in payload['alert']:
info['additional_info'] += "Recipient: *{}*\n".format(payload['alert']['recipient'])
if 'addedTags' in payload['alert']:
info['additional_info'] += "Added tags: *{}*\n".format(payload['alert']['addedTags'])
if 'team' in payload['alert']:
info['additional_info'] += "Added team: *{}*\n".format(payload['alert']['team'])
if 'owner' in payload['alert']:
info['additional_info'] += "Assigned owner: *{}*\n".format(payload['alert']['owner'])
if 'escalationName' in payload:
info['additional_info'] += "Escalation: *{}*\n".format(payload['escalationName'])
if 'removedTags' in payload['alert']:
info['additional_info'] += "Removed tags: *{}*\n".format(payload['alert']['removedTags'])
if 'message' in payload['alert']:
info['additional_info'] += "Message: *{}*\n".format(payload['alert']['message'])
body = ''
body_template = "**OpsGenie: [Alert for {integration_name}.]" \
"(https://app.opsgenie.com/alert/V2#/show/{alert_id})**\n" \
"Type: *{alert_type}*\n" \
"{additional_info}" \
"{tags}"
body += body_template.format(**info)
# send the message
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def send_stream_message(self, sender_email: Text, stream_name: Text, content: Text="test content",
topic_name: Text="test", sender_realm: Text="zulip") -> int:
sender = get_user(sender_email, get_realm(sender_realm))
(sending_client, _) = Client.objects.get_or_create(name="test suite")
return check_send_stream_message(
sender=sender,
client=sending_client,
stream_name=stream_name,
topic=topic_name,
body=content,
)
def api_greenhouse_webhook(request, user_profile,
payload=REQ(argument_type='body'),
stream=REQ(default='greenhouse'), topic=REQ(default=None)):
# type: (HttpRequest, UserProfile, Dict[str, Any], str, str) -> HttpResponse
if payload['action'] == 'update_candidate':
candidate = payload['payload']['candidate']
else:
candidate = payload['payload']['application']['candidate']
action = payload['action'].replace('_', ' ').title()
body = "{}\n>{} {}\nID: {}\n{}".format(
action,
candidate['first_name'],
candidate['last_name'],
str(candidate['id']),
message_creator(payload['action'],
payload['payload']['application']))
if topic is None:
topic = "{} - {}".format(action, str(candidate['id']))
check_send_stream_message(user_profile, request.client, stream, topic, body)
return json_success()
def send_stream_message(self, sender: UserProfile, stream_name: str, content: str="test content",
topic_name: str="test",
recipient_realm: Optional[Realm]=None,
sending_client_name: str="test suite") -> int:
(sending_client, _) = Client.objects.get_or_create(name=sending_client_name)
return check_send_stream_message(
sender=sender,
client=sending_client,
stream_name=stream_name,
topic=topic_name,
body=content,
realm=recipient_realm,
)
def api_intercom_webhook(
request: HttpRequest,
user_profile: UserProfile,
payload: Dict[str, Any] = REQ(argument_type='body'),
stream: Text = REQ(default='intercom')
) -> HttpResponse:
topic = payload['topic']
topic = topic.replace('.', ' ')
created_at = datetime.datetime.fromtimestamp(int(
payload['created_at'])).strftime('%H:%M:%S %Y-%m-%d')
body = '*{created_at}* **{topic}**: \n'.format(topic=topic,
created_at=created_at)
if payload['data']['item']['type'] == 'user_tag':
data = payload['data']['item']['user']
body += ' - User Name: {}\n' \
' - User Email: {}\n' \
' - User Phone: {}\n'.format(data['name'], data['email'], data['phone'])
check_send_stream_message(user_profile, request.client, stream, topic,
body)
return json_success()
