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()