Zulip server and web application. Open-source team chat that helps teams stay productive and focused.
import re
from collections.abc import Callable
from datetime import datetime
from django.http import HttpRequest, HttpResponse
from pydantic import Json
from typing_extensions import override
from zerver.decorator import log_unsupported_webhook_event, webhook_view
from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
from zerver.lib.external_accounts import DEFAULT_EXTERNAL_ACCOUNTS
from zerver.lib.markdown.fenced_code import get_unused_fence
from zerver.lib.mention import silent_mention_syntax_for_user
from zerver.lib.partial import partial
from zerver.lib.response import json_success
from zerver.lib.typed_endpoint import JsonBodyPayload, typed_endpoint
from zerver.lib.validator import WildValue, check_bool, check_int, check_none_or, check_string
from zerver.lib.webhooks.common import (
OptionalUserSpecifiedTopicStr,
check_send_webhook_message,
default_fixture_to_headers,
get_event_header,
get_setup_webhook_message,
guess_zulip_user_from_external_account,
)
from zerver.lib.webhooks.git import (
CONTENT_MESSAGE_TEMPLATE,
TOPIC_WITH_BRANCH_TEMPLATE,
TOPIC_WITH_PR_OR_ISSUE_INFO_TEMPLATE,
get_commits_comment_action_message,
get_issue_event_message,
get_issue_labeled_or_unlabeled_event_message,
get_issue_milestoned_or_demilestoned_event_message,
get_pull_request_event_message,
get_push_commits_event_message,
get_push_tag_event_message,
get_release_event_message,
get_short_sha,
is_branch_name_notifiable,
)
from zerver.models import UserProfile
fixture_to_headers = default_fixture_to_headers("HTTP_X_GITHUB_EVENT")
TOPIC_FOR_DISCUSSION = "{repo} discussion #{number}: {title}"
DISCUSSION_TEMPLATES = {
"created": "{sender} created [discussion #{discussion_number}]({url}) in {category}:\n\n{body_fence} quote\n### {title}\n{body}\n{body_fence}",
"generic_action": "{sender} {action} [discussion #{discussion_number}{configured_title}]({url}).",
"deleted": "{sender} {action} discussion #{discussion_number}{configured_title}.",
"closed": "{sender} {action} [discussion #{discussion_number}{configured_title}]({url}) as {closed_reason}.",
"locked": "{sender} {action} [discussion #{discussion_number}{configured_title}]({url}){locked_reason}.",
"labeled": "{sender} added the {label} label to [discussion #{discussion_number}{configured_title}]({url}).",
"unlabeled": "{sender} removed the {label} label from [discussion #{discussion_number}{configured_title}]({url}).",
"category_changed": "{sender} changed the category of [discussion #{discussion_number}{configured_title}]({url}) from {old_category} to {category}.",
"transferred": "{sender} {action} discussion #{discussion_number}{configured_title} from {repository_name} to {new_repository_name} as [discussion #{new_discussion_number}]({url}).",
"answered": "{sender} marked [comment #{comment_id}]({answer_url}) as the answer:\n\n{answer_body_fence} quote\n{answer_body}\n{answer_body_fence}",
"unanswered": "{sender} marked [comment #{comment_id}]({answer_url}) as not the answer.",
"edited_title": "{sender} edited the title of [discussion #{discussion_number}{configured_title}]({url}):\n\n``` quote\n### {title}\n```",
"edited_body": "{sender} edited [discussion #{discussion_number}{configured_title}]({url}):\n\n{body_fence} quote\n{body}\n{body_fence}",
}
CHECK_RUN_CONCLUSION_EMOJI = {
"success": ":check:",
"failure": ":warning:",
"cancelled": ":not_allowed:",
"skipped": ":fast_forward:",
"timed_out": ":times_up:",
"action_required": ":wrench:",
"neutral": ":minus:",
"stale": ":sleeping:",
}
PR_REVIEW_STATE_EMOJI = {
"approved": ":thumbs_up:",
"changes_requested": ":repeat:",
"commented": ":memo:",
}
PR_REVIEW_COMMENT_EMOJI = ":speech_balloon:"
PR_CLOSE_ACTION_EMOJI = {
"merged": ":check:",
"closed without merge": ":cross_mark:",
}
DEPLOYMENT_AND_COMMIT_STATUS_EMOJI = {
"success": ":check:",
"failure": ":warning:",
"error": ":rotating_light:",
"pending": ":time_ticking:",
}
class Helper:
def __init__(
self,
request: HttpRequest,
payload: WildValue,
include_title: bool,
include_repository_name: bool,
include_emoji_indicators: bool,
user_profile: UserProfile,
concise_edit_format: bool,
) -> None:
self.request = request
self.payload = payload
self.include_title = include_title
self.include_repository_name = include_repository_name
self.include_emoji_indicators = include_emoji_indicators
self.realm = user_profile.realm
self.concise_edit_format = concise_edit_format
def log_unsupported(self, event: str) -> None:
summary = f"The '{event}' event isn't currently supported by the GitHub webhook; ignoring"
log_unsupported_webhook_event(request=self.request, summary=summary)
def get_opened_or_update_pull_request_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
pull_request = payload["pull_request"]
action = payload["action"].tame(check_string)
if action == "synchronize":
action = "updated"
assignee = None
if pull_request.get("assignee"):
assignee = pull_request["assignee"]["login"].tame(check_string)
description = None
changes = payload.get("changes", {})
if action == "opened" or (
action == "edited" and not helper.concise_edit_format and "body" in changes
):
description = pull_request["body"].tame(check_none_or(check_string))
target_branch = None
base_branch = None
if action in ("opened", "merged", "reopened"):
target_branch = pull_request["head"]["label"].tame(check_string)
base_branch = pull_request["base"]["label"].tame(check_string)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=action,
url=pull_request["html_url"].tame(check_string),
target_branch=target_branch,
base_branch=base_branch,
message=description,
assignee=assignee,
number=pull_request["number"].tame(check_int),
title=pull_request["title"].tame(check_string) if include_title else None,
)
def get_assigned_or_unassigned_pull_request_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
pull_request = payload["pull_request"]
assignee = payload["assignee"]["login"].tame(check_string)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=payload["action"].tame(check_string),
url=pull_request["html_url"].tame(check_string),
number=pull_request["number"].tame(check_int),
title=pull_request["title"].tame(check_string) if include_title else None,
assignee_updated=assignee,
)
def get_closed_pull_request_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
pull_request = payload["pull_request"]
action = "merged" if pull_request["merged"].tame(check_bool) else "closed without merge"
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=action,
url=pull_request["html_url"].tame(check_string),
number=pull_request["number"].tame(check_int),
title=pull_request["title"].tame(check_string) if include_title else None,
emoji=PR_CLOSE_ACTION_EMOJI.get(action) if helper.include_emoji_indicators else None,
)
def get_membership_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
member = payload["member"]
team_name = payload["team"]["name"].tame(check_string)
return "{sender} {action} [{username}]({html_url}) {preposition} the {team_name} team.".format(
sender=get_sender_name(helper),
action=action,
username=member["login"].tame(check_string),
html_url=member["html_url"].tame(check_string),
preposition="from" if action == "removed" else "to",
team_name=team_name,
)
def get_member_body(helper: Helper) -> str:
payload = helper.payload
return "{} {} [{}]({}) to [{}]({}).".format(
get_sender_name(helper),
payload["action"].tame(check_string),
payload["member"]["login"].tame(check_string),
payload["member"]["html_url"].tame(check_string),
get_repository_name(payload),
payload["repository"]["html_url"].tame(check_string),
)
def get_issue_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
action = payload["action"].tame(check_string)
issue = payload["issue"]
use_concise_format = action == "edited" and helper.concise_edit_format
is_assignment_action = action in ("assigned", "unassigned")
message = (
None
if (use_concise_format or is_assignment_action)
else issue["body"].tame(check_none_or(check_string))
)
return get_issue_event_message(
user_name=get_sender_name(helper),
action=action,
url=issue["html_url"].tame(check_string),
number=issue["number"].tame(check_int),
message=message,
title=issue["title"].tame(check_string) if include_title else None,
assignee_updated=(
payload["assignee"]["login"].tame(check_string) if "assignee" in payload else None
),
)
def get_issue_comment_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
comment = payload["comment"]
issue = payload["issue"]
message = (
None
if payload["action"].tame(check_string) == "edited" and helper.concise_edit_format
else comment["body"].tame(check_string)
)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=get_comment_action(payload),
url=issue["html_url"].tame(check_string),
number=issue["number"].tame(check_int),
message=message,
title=issue["title"].tame(check_string) if include_title else None,
type="PR" if is_pull_request_comment_event(payload) else "issue",
)
def get_issue_labeled_or_unlabeled_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
issue = payload["issue"]
return get_issue_labeled_or_unlabeled_event_message(
user_name=get_sender_name(helper),
action="added" if payload["action"].tame(check_string) == "labeled" else "removed",
url=issue["html_url"].tame(check_string),
number=issue["number"].tame(check_int),
label_name=payload["label"]["name"].tame(check_string),
user_url=get_sender_url(payload),
title=issue["title"].tame(check_string) if include_title else None,
)
def get_issue_milestoned_or_demilestoned_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
issue = payload["issue"]
return get_issue_milestoned_or_demilestoned_event_message(
user_name=get_sender_name(helper),
action="added" if payload["action"].tame(check_string) == "milestoned" else "removed",
url=issue["html_url"].tame(check_string),
number=issue["number"].tame(check_int),
milestone_name=payload["milestone"]["title"].tame(check_string),
milestone_url=payload["milestone"]["html_url"].tame(check_string),
user_url=get_sender_url(payload),
title=issue["title"].tame(check_string) if include_title else None,
)
def get_fork_body(helper: Helper) -> str:
payload = helper.payload
forkee = payload["forkee"]
return "{} forked [{}]({}).".format(
get_sender_name(helper),
forkee["name"].tame(check_string),
forkee["html_url"].tame(check_string),
)
def get_deployment_body(helper: Helper) -> str:
return f"{get_sender_name(helper)} created new deployment."
def get_change_deployment_status_body(helper: Helper) -> str:
payload = helper.payload
state = payload["deployment_status"]["state"].tame(check_string)
emoji = (
DEPLOYMENT_AND_COMMIT_STATUS_EMOJI.get(state, "") if helper.include_emoji_indicators else ""
)
return f"{emoji} Deployment changed status to {state}.".strip()
def get_create_or_delete_body(action: str, helper: Helper) -> str:
payload = helper.payload
ref_type = payload["ref_type"].tame(check_string)
return "{} {} {} {}.".format(
get_sender_name(helper),
action,
ref_type,
payload["ref"].tame(check_string),
).rstrip()
def get_commit_comment_body(helper: Helper) -> str:
payload = helper.payload
comment = payload["comment"]
comment_url = comment["html_url"].tame(check_string)
commit_url = comment_url.split("#", 1)[0]
action = f"[commented]({comment_url})"
return get_commits_comment_action_message(
get_sender_name(helper),
action,
commit_url,
comment["commit_id"].tame(check_string),
comment["body"].tame(check_string),
)
def get_push_tags_body(helper: Helper) -> str:
payload = helper.payload
return get_push_tag_event_message(
get_sender_name(helper),
get_tag_name_from_ref(payload["ref"].tame(check_string)),
action="pushed" if payload["created"].tame(check_bool) else "removed",
)
def get_push_commits_body(helper: Helper) -> str:
payload = helper.payload
commits_data = []
for commit in payload["commits"]:
if commit["author"].get("username"):
name = commit["author"]["username"].tame(check_string)
else:
name = commit["author"]["name"].tame(check_string)
commits_data.append(
{
"name": name,
"sha": commit["id"].tame(check_string),
"url": commit["url"].tame(check_string),
"message": commit["message"].tame(check_string),
}
)
return get_push_commits_event_message(
get_sender_name(helper),
payload["compare"].tame(check_string),
get_branch_name_from_ref(payload["ref"].tame(check_string)),
commits_data,
deleted=payload["deleted"].tame(check_bool),
force_push=payload["forced"].tame(check_bool),
repository_name=get_repository_full_name(payload)
if helper.include_repository_name
else None,
repository_url=get_repository_url(payload) if helper.include_repository_name else None,
)
class LazyContext(dict[str, str | int]):
"""Template rendering context for discussions."""
def __init__(self, helper: Helper) -> None:
super().__init__()
self.helper = helper
self.payload = helper.payload
self.include_title = helper.include_title
self.template_values: dict[str, Callable[[], str | int]] = {
"sender": lambda: get_sender_name(self.helper),
"author": lambda: get_user_mention(
self.helper,
self.payload["discussion"]["user"]["login"].tame(check_string),
),
"url": lambda: self.payload["discussion"]["html_url"].tame(check_string),
"action": lambda: self.payload["action"].tame(check_string),
"configured_title": lambda: (
f" {self.template_values['title']()}" if self.include_title else ""
),
"category": lambda: self.payload["discussion"]["category"]["name"].tame(check_string),
"title": lambda: self.payload["discussion"]["title"].tame(check_string),
"body": lambda: self.payload["discussion"]["body"].tame(check_string),
"body_fence": lambda: get_unused_fence(str(self.template_values["body"]())),
"repository_name": lambda: self.payload["repository"]["name"].tame(check_string),
"new_repository_name": lambda: self.payload["changes"]["new_repository"]["name"].tame(
check_string
),
"discussion_number": lambda: self.payload["discussion"]["number"].tame(check_int),
"new_discussion_number": lambda: self.payload["changes"]["new_discussion"][
"number"
].tame(check_int),
"label": lambda: self.payload["label"]["name"].tame(check_string),
"old_category": lambda: self.payload["changes"]["category"]["from"]["name"].tame(
check_string
),
# locked_reason includes the " as " as prefix,
# because locked_reason could be null too, in which case,
# we drop this entire part from the message.
"locked_reason": lambda: (
f" as {self.payload['discussion']['active_lock_reason'].tame(check_string)}"
if self.payload["discussion"]["active_lock_reason"]
else ""
),
"closed_reason": lambda: self.payload["discussion"]["state_reason"].tame(check_string),
# answer_field is used to determine which payload field to use.
# It is either "answer" (for answered action)
# or "old_answer" (for unanswered action)
"answer_field": lambda: (
"old_answer"
if self.payload["action"].tame(check_string) == "unanswered"
else "answer"
),
"answer_url": lambda: self.payload[self.template_values["answer_field"]()][
"html_url"
].tame(check_string),
"answer_body": lambda: self.payload[self.template_values["answer_field"]()][
"body"
].tame(check_string),
"answer_body_fence": lambda: get_unused_fence(
str(self.template_values["answer_body"]())
),
"comment_id": lambda: self.payload[self.template_values["answer_field"]()]["id"].tame(
check_int
),
}
@override
def __getitem__(self, key: str) -> str | int:
return self.template_values[key]()
def get_discussion_body(helper: Helper) -> str:
payload = helper.payload
action = get_discussion_action(payload, helper.concise_edit_format)
DISCUSSION_TEMPLATE = DISCUSSION_TEMPLATES[action]
context = LazyContext(helper)
return DISCUSSION_TEMPLATE.format_map(context)
def get_discussion_action(payload: WildValue, concise_edit_format: bool) -> str:
action = payload["action"].tame(check_string)
if action in ("unlocked", "pinned", "unpinned", "reopened"):
action = "generic_action"
if action == "edited":
if "body" in payload["changes"]:
action = "generic_action" if concise_edit_format else "edited_body"
else:
action = "edited_title"
return action
def get_discussion_comment_body(helper: Helper) -> str:
payload = helper.payload
message = (
None
if payload["action"].tame(check_string) == "edited" and helper.concise_edit_format
else payload["comment"]["body"].tame(check_string)
)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=get_comment_action(payload),
url=payload["discussion"]["html_url"].tame(check_string),
number=payload["discussion"]["number"].tame(check_int),
message=message,
title=payload["discussion"]["title"].tame(check_string) if helper.include_title else None,
type="discussion",
)
def get_comment_action(payload: WildValue) -> str:
action = payload["action"].tame(check_string)
if action == "created":
action = "[commented]"
else:
action = f"{action} a [comment]"
action += "({}) on".format(payload["comment"]["html_url"].tame(check_string))
return action
def get_public_body(helper: Helper) -> str:
payload = helper.payload
return "{} made the repository [{}]({}) public.".format(
get_sender_name(helper),
get_repository_full_name(payload),
payload["repository"]["html_url"].tame(check_string),
)
def get_wiki_pages_body(helper: Helper) -> str:
payload = helper.payload
wiki_page_info_template = "* {action} [{title}]({url})\n"
wiki_info = ""
for page in payload["pages"]:
wiki_info += wiki_page_info_template.format(
action=page["action"].tame(check_string),
title=page["title"].tame(check_string),
url=page["html_url"].tame(check_string),
)
return f"{get_sender_name(helper)}:\n{wiki_info.rstrip()}"
def get_watch_body(helper: Helper) -> str:
payload = helper.payload
return "{} starred the repository [{}]({}).".format(
get_sender_name(helper),
get_repository_full_name(payload),
payload["repository"]["html_url"].tame(check_string),
)
def get_repository_advisory_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
if action == "reported":
description = payload["repository_advisory"]["description"].tame(check_string)
fence = get_unused_fence(description)
return "{} reported [{}]({}) in {}: {}\n\n{}quote\n{}\n{}".format(
get_sender_name(helper),
payload["repository_advisory"]["ghsa_id"].tame(check_string),
payload["repository_advisory"]["html_url"].tame(check_string),
get_repository_full_name(payload),
payload["repository_advisory"]["summary"].tame(check_string),
fence,
description,
fence,
)
else:
return "{} published [{}]({})".format(
get_sender_name(helper),
payload["repository_advisory"]["ghsa_id"].tame(check_string),
payload["repository_advisory"]["html_url"].tame(check_string),
)
def get_repository_body(helper: Helper) -> str:
payload = helper.payload
return "{} {} the repository [{}]({}).".format(
get_sender_name(helper),
payload["action"].tame(check_string),
get_repository_full_name(payload),
payload["repository"]["html_url"].tame(check_string),
)
def get_add_team_body(helper: Helper) -> str:
payload = helper.payload
return "The repository [{}]({}) was added to team {}.".format(
get_repository_full_name(payload),
payload["repository"]["html_url"].tame(check_string),
payload["team"]["name"].tame(check_string),
)
def get_team_body(helper: Helper) -> str:
payload = helper.payload
changes = payload["changes"]
if "description" in changes:
actor = get_sender_name(helper)
new_description = payload["team"]["description"].tame(check_string)
fence = get_unused_fence(new_description)
return (
f"{actor} changed the team description to:\n\n{fence} quote\n{new_description}\n{fence}"
)
if "name" in changes:
original_name = changes["name"]["from"].tame(check_string)
new_name = payload["team"]["name"].tame(check_string)
return f"Team `{original_name}` was renamed to `{new_name}`."
if "privacy" in changes:
new_visibility = payload["team"]["privacy"].tame(check_string)
return f"Team visibility changed to `{new_visibility}`"
missing_keys = "/".join(sorted(changes.keys()))
helper.log_unsupported(f"team/edited (changes: {missing_keys})")
# Do our best to give useful info to the customer--at least
# if they know something changed, they can go to GitHub for
# more details. And if it's just spam, you can control that
# from GitHub.
return f"Team has changes to `{missing_keys}` data."
def get_release_body(helper: Helper) -> str:
payload = helper.payload
if payload["release"]["name"]:
release_name = payload["release"]["name"].tame(check_string)
else:
release_name = payload["release"]["tag_name"].tame(check_string)
data = {
"user_name": get_sender_name(helper),
"action": payload["action"].tame(check_string),
"tagname": payload["release"]["tag_name"].tame(check_string),
# Not every GitHub release has a "name" set; if not there, use the tag name.
"release_name": release_name,
"url": payload["release"]["html_url"].tame(check_string),
}
return get_release_event_message(**data)
def get_page_build_body(helper: Helper) -> str:
payload = helper.payload
build = payload["build"]
status = build["status"].tame(check_string)
actions = {
"null": "has yet to be built",
"building": "is being built",
"errored": "has failed: {}",
"built": "has finished building",
}
action = actions.get(status, f"is {status}")
if build["error"]["message"]:
message = build["error"]["message"].tame(check_string)
action = action.format(
CONTENT_MESSAGE_TEMPLATE.format(
message=message,
fence=get_unused_fence(message),
),
)
return "GitHub Pages build, triggered by {}, {}.".format(
payload["build"]["pusher"]["login"].tame(check_string),
action,
)
def get_status_body(helper: Helper) -> str:
payload = helper.payload
state = payload["state"].tame(check_string)
if payload["target_url"]:
status = "[{state}]({target_url})".format(
state=state,
target_url=payload["target_url"].tame(check_string),
)
else:
status = state
return "{emoji} [{commit}]({url}) changed its status to {status}.".format(
emoji=DEPLOYMENT_AND_COMMIT_STATUS_EMOJI.get(state, "")
if helper.include_emoji_indicators
else "",
commit=get_short_sha(payload["sha"].tame(check_string)),
url=payload["commit"]["html_url"].tame(check_string),
status=status,
).strip()
def get_locked_or_unlocked_pull_request_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
message = "{sender} has locked [PR #{pr_number}]({pr_url}) as {reason} and limited conversation to collaborators."
if action == "unlocked":
message = "{sender} has unlocked [PR #{pr_number}]({pr_url})."
if payload["pull_request"]["active_lock_reason"]:
active_lock_reason = payload["pull_request"]["active_lock_reason"].tame(check_string)
else:
active_lock_reason = None
return message.format(
sender=get_sender_name(helper),
pr_number=payload["pull_request"]["number"].tame(check_int),
pr_url=payload["pull_request"]["html_url"].tame(check_string),
reason=active_lock_reason,
)
def get_pull_request_auto_merge_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
message = "{sender} has enabled auto merge for [PR #{pr_number}]({pr_url})."
if action == "auto_merge_disabled":
message = "{sender} has disabled auto merge for [PR #{pr_number}]({pr_url})."
return message.format(
sender=get_sender_name(helper),
pr_number=payload["pull_request"]["number"].tame(check_int),
pr_url=payload["pull_request"]["html_url"].tame(check_string),
)
def get_pull_request_ready_for_review_body(helper: Helper) -> str:
payload = helper.payload
message = "{sender} has marked [PR #{pr_number}]({pr_url}) as ready for review."
return message.format(
sender=get_sender_name(helper),
pr_number=payload["pull_request"]["number"].tame(check_int),
pr_url=payload["pull_request"]["html_url"].tame(check_string),
)
def get_pull_request_review_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
title = "for #{} {}".format(
payload["pull_request"]["number"].tame(check_int),
payload["pull_request"]["title"].tame(check_string),
)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action="submitted",
url=payload["review"]["html_url"].tame(check_string),
type="PR review",
title=title if include_title else None,
message=payload["review"]["body"].tame(check_none_or(check_string)),
emoji=PR_REVIEW_STATE_EMOJI.get(payload["review"]["state"].tame(check_string))
if helper.include_emoji_indicators
else None,
)
def get_requested_reviewer_link(payload: WildValue) -> str:
# Requested review from a user
if "requested_reviewer" in payload:
reviewer = payload["requested_reviewer"]
reviewer_name = reviewer["login"].tame(check_string)
# Requested review from a team
else:
reviewer = payload["requested_team"]
reviewer_name = reviewer["name"].tame(check_string)
return f"[{reviewer_name}]({reviewer['html_url'].tame(check_string)})"
def get_pull_request_review_requested_or_removed_body(helper: Helper) -> str:
payload = helper.payload
sender = get_sender_name(helper)
reviewer_link = get_requested_reviewer_link(payload)
pr_number = payload["pull_request"]["number"].tame(check_int)
pr_title = payload["pull_request"]["title"].tame(check_string)
pr_url = payload["pull_request"]["html_url"].tame(check_string)
pr_reference = f"PR #{pr_number} {pr_title}" if helper.include_title else f"PR #{pr_number}"
review_request_change = (
f"requested {reviewer_link} for a review on"
if payload["action"].tame(check_string) == "review_requested"
else f"removed the review request for {reviewer_link} from"
)
return f"{sender} {review_request_change} [{pr_reference}]({pr_url})."
def get_pull_request_converted_to_draft_body(helper: Helper) -> str:
payload = helper.payload
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action="converted",
url=payload["pull_request"]["html_url"].tame(check_string),
number=payload["pull_request"]["number"].tame(check_int),
title=payload["pull_request"]["title"].tame(check_string),
suffix="to a draft",
)
def get_pull_request_labeled_or_unlabeled_body(helper: Helper) -> str:
payload = helper.payload
label_name = payload["label"]["name"].tame(check_string)
action = payload["action"].tame(check_string)
sender = get_sender_name(helper)
pr_number = payload["pull_request"]["number"].tame(check_int)
pr_url = payload["pull_request"]["html_url"].tame(check_string)
preposition = "on" if action == "labeled" else "from"
action_word = "added" if action == "labeled" else "removed"
return f"{sender} {action_word} the label `{label_name}` {preposition} [PR #{pr_number}]({pr_url})."
def get_pull_request_milestoned_or_demilestoned_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
if action == "milestoned":
suffix = (
f"to the milestone `{payload['pull_request']['milestone']['title'].tame(check_string)}`"
)
else:
suffix = f"from the milestone `{payload['milestone']['title'].tame(check_string)}`"
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=action,
url=payload["pull_request"]["html_url"].tame(check_string),
number=payload["pull_request"]["number"].tame(check_int),
suffix=suffix,
)
def get_pull_request_enqueued_or_dequeued_body(helper: Helper) -> str:
payload = helper.payload
action = payload["action"].tame(check_string)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=action,
url=payload["pull_request"]["html_url"].tame(check_string),
number=payload["pull_request"]["number"].tame(check_int),
title=payload["pull_request"]["title"].tame(check_string),
suffix=("to the merge queue" if action == "enqueued" else "from the merge queue"),
)
def get_pull_request_review_comment_body(helper: Helper) -> str:
payload = helper.payload
include_title = helper.include_title
action = payload["action"].tame(check_string)
message = None
if action == "created" or (action == "edited" and not helper.concise_edit_format):
message = payload["comment"]["body"].tame(check_string)
title = "on #{} {}".format(
payload["pull_request"]["number"].tame(check_int),
payload["pull_request"]["title"].tame(check_string),
)
return get_pull_request_event_message(
user_name=get_sender_name(helper),
action=action,
url=payload["comment"]["html_url"].tame(check_string),
message=message,
type="PR review comment",
title=title if include_title else None,
emoji=PR_REVIEW_COMMENT_EMOJI if helper.include_emoji_indicators else None,
)
def get_check_run_body(helper: Helper) -> str:
payload = helper.payload
template = """
{emoji} Check [{name}]({html_url}) {status} ({conclusion}). ([{short_hash}]({commit_url}))
"""
kwargs = {
"name": payload["check_run"]["name"].tame(check_string),
"html_url": payload["check_run"]["html_url"].tame(check_string),
"status": payload["check_run"]["status"].tame(check_string),
"short_hash": get_short_sha(payload["check_run"]["head_sha"].tame(check_string)),
"commit_url": "{}/commit/{}".format(
payload["repository"]["html_url"].tame(check_string),
payload["check_run"]["head_sha"].tame(check_string),
),
"conclusion": payload["check_run"]["conclusion"].tame(check_string),
"emoji": CHECK_RUN_CONCLUSION_EMOJI.get(
payload["check_run"]["conclusion"].tame(check_string), ""
)
if helper.include_emoji_indicators
else "",
}
return template.format(**kwargs).strip()
def get_star_body(helper: Helper) -> str:
payload = helper.payload
template = "[{user}]({user_url}) {action} the repository [{repo}]({url})."
return template.format(
user=get_sender_name(helper),
user_url=get_sender_url(payload),
action="starred" if payload["action"].tame(check_string) == "created" else "unstarred",
repo=get_repository_full_name(payload),
url=payload["repository"]["html_url"].tame(check_string),
)
def get_ping_body(helper: Helper) -> str:
return get_setup_webhook_message("GitHub", get_sender_name(helper))
def get_cancelled_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name} cancelled their {subscription} subscription."
return template.format(
user_name=get_sender_name(helper),
subscription=get_subscription(payload),
).rstrip()
def get_created_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name} subscribed for {subscription}."
return template.format(
user_name=get_sender_name(helper),
subscription=get_subscription(payload),
).rstrip()
def get_edited_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name} changed who can see their sponsorship from {prior_privacy_level} to {privacy_level}."
return template.format(
user_name=get_sender_name(helper),
prior_privacy_level=payload["changes"]["privacy_level"]["from"].tame(check_string),
privacy_level=payload["sponsorship"]["privacy_level"].tame(check_string),
).rstrip()
def get_pending_cancellation_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name}'s {subscription} subscription will be cancelled on {effective_date}."
return template.format(
user_name=get_sender_name(helper),
subscription=get_subscription(payload),
effective_date=get_effective_date(payload),
).rstrip()
def get_pending_tier_change_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name}'s subscription will change from {prior_subscription} to {subscription} on {effective_date}."
return template.format(
user_name=get_sender_name(helper),
prior_subscription=get_prior_subscription(payload),
subscription=get_subscription(payload),
effective_date=get_effective_date(payload),
).rstrip()
def get_tier_changed_body(helper: Helper) -> str:
payload = helper.payload
template = "{user_name} changed their subscription from {prior_subscription} to {subscription}."
return template.format(
user_name=get_sender_name(helper),
prior_subscription=get_prior_subscription(payload),
subscription=get_subscription(payload),
).rstrip()
def get_issue_transferred_body(helper: Helper) -> str:
payload = helper.payload
template = "{sender} transferred [issue #{old_issue_number} {title}]({old_issue_url}) to [{new_repo_full_name}/#{new_issue_number}]({new_issue_url})."
return template.format(
sender=get_sender_name(helper),
old_issue_number=payload["issue"]["number"].tame(check_int),
old_issue_url=payload["issue"]["html_url"].tame(check_string),
title=payload["issue"]["title"].tame(check_string),
new_repo_full_name=payload["changes"]["new_repository"]["full_name"].tame(check_string),
new_issue_number=payload["changes"]["new_issue"]["number"].tame(check_int),
new_issue_url=payload["changes"]["new_issue"]["html_url"].tame(check_string),
)
def get_issue_opened_via_transfer_body(helper: Helper) -> str:
payload = helper.payload
template = "[Issue #{new_issue_number} {title}]({new_issue_url}) was transferred from [{old_repo_full_name}#{old_issue_number}]({old_issue_url})."
return template.format(
new_issue_number=payload["issue"]["number"].tame(check_int),
new_issue_url=payload["issue"]["html_url"].tame(check_string),
title=payload["issue"]["title"].tame(check_string),
old_repo_full_name=payload["changes"]["old_repository"]["full_name"].tame(check_string),
old_issue_number=payload["changes"]["old_issue"]["number"].tame(check_int),
old_issue_url=payload["changes"]["old_issue"]["html_url"].tame(check_string),
)
def get_subscription(payload: WildValue) -> str:
return payload["sponsorship"]["tier"]["name"].tame(check_string)
def get_effective_date(payload: WildValue) -> str:
effective_date = payload["effective_date"].tame(check_string)[:10]
return datetime.fromisoformat(effective_date).strftime("%B %d, %Y")
def get_prior_subscription(payload: WildValue) -> str:
return payload["changes"]["tier"]["from"]["name"].tame(check_string)
def get_repository_name(payload: WildValue) -> str:
return payload["repository"]["name"].tame(check_string)
def get_repository_full_name(payload: WildValue) -> str:
return payload["repository"]["full_name"].tame(check_string)
def get_repository_url(payload: WildValue) -> str:
return payload["repository"]["html_url"].tame(check_string)
def get_organization_name(payload: WildValue) -> str:
return payload["organization"]["login"].tame(check_string)
def get_user_mention(helper: Helper, github_username: str) -> str:
external_account_field_name = str(DEFAULT_EXTERNAL_ACCOUNTS["github"].name)
zulip_user = guess_zulip_user_from_external_account(
helper.realm,
github_username,
external_account_field_name,
external_username_case_insensitive=True,
)
if zulip_user is not None:
return silent_mention_syntax_for_user(zulip_user)
return github_username
def get_sender_name(helper: Helper) -> str:
return get_user_mention(helper, helper.payload["sender"]["login"].tame(check_string))
def get_sender_url(payload: WildValue) -> str:
return payload["sender"]["html_url"].tame(check_string)
def get_branch_name_from_ref(ref_string: str) -> str:
return re.sub(r"^refs/heads/", "", ref_string)
def get_tag_name_from_ref(ref_string: str) -> str:
return re.sub(r"^refs/tags/", "", ref_string)
def is_commit_push_event(payload: WildValue) -> bool:
return payload["ref"].tame(check_string).startswith("refs/heads/")
def is_merge_queue_push_event(payload: WildValue) -> bool:
return payload["ref"].tame(check_string).startswith("refs/heads/gh-readonly-queue/")
def is_pull_request_comment_event(payload: WildValue) -> bool:
# When a comment is made on a PR, the event still has the header
# "issue_comment", but the payload has a "pull_request" key.
# This is just a workaround to get the correct topic.
if "pull_request" in payload["issue"]:
return True
return False
def get_topic_based_on_type(payload: WildValue, event: str) -> str:
if "pull_request" in event:
return TOPIC_WITH_PR_OR_ISSUE_INFO_TEMPLATE.format(
repo=get_repository_name(payload),
type="PR",
id=payload["pull_request"]["number"].tame(check_int),
title=payload["pull_request"]["title"].tame(check_string),
)
elif event.startswith("issue"):
type_for_topic = "PR" if is_pull_request_comment_event(payload) else "issue"
return TOPIC_WITH_PR_OR_ISSUE_INFO_TEMPLATE.format(
repo=get_repository_name(payload),
type=type_for_topic,
id=payload["issue"]["number"].tame(check_int),
title=payload["issue"]["title"].tame(check_string),
)
elif event.startswith("deployment"):
return "{} / Deployment on {}".format(
get_repository_name(payload),
payload["deployment"]["environment"].tame(check_string),
)
elif event == "membership":
return "{} organization".format(payload["organization"]["login"].tame(check_string))
elif event == "team":
return "team {}".format(payload["team"]["name"].tame(check_string))
elif event == "push_commits":
return TOPIC_WITH_BRANCH_TEMPLATE.format(
repo=get_repository_name(payload),
branch=get_branch_name_from_ref(payload["ref"].tame(check_string)),
)
elif event == "gollum":
return TOPIC_WITH_BRANCH_TEMPLATE.format(
repo=get_repository_name(payload),
branch="wiki pages",
)
elif event == "ping":
if "repository" in payload:
return get_repository_name(payload)
if "organization" in payload:
return get_organization_name(payload)
# GitHub Sponsors webhook pings include neither "repository" nor
# "organization"; group them under the topic SPONSORS_EVENT_TYPES use.
hook_type = payload["hook"]["type"].tame(check_string)
if hook_type == "SponsorsListing":
return "sponsors"
raise UnsupportedWebhookEventTypeError(f"ping:{hook_type}")
elif event == "check_run":
return f"{get_repository_name(payload)} / checks"
elif event.startswith("discussion"):
return TOPIC_FOR_DISCUSSION.format(
repo=get_repository_name(payload),
number=payload["discussion"]["number"].tame(check_int),
title=payload["discussion"]["title"].tame(check_string),
)
elif event in SPONSORS_EVENT_TYPES:
return "sponsors"
return get_repository_name(payload)
EVENT_FUNCTION_MAPPER: dict[str, Callable[[Helper], str]] = {
"commit_comment": get_commit_comment_body,
"closed_pull_request": get_closed_pull_request_body,
"create": partial(get_create_or_delete_body, "created"),
"check_run": get_check_run_body,
"delete": partial(get_create_or_delete_body, "deleted"),
"deployment": get_deployment_body,
"deployment_status": get_change_deployment_status_body,
"discussion": get_discussion_body,
"discussion_comment": get_discussion_comment_body,
"fork": get_fork_body,
"gollum": get_wiki_pages_body,
"issue_comment": get_issue_comment_body,
"issue_labeled_or_unlabeled": get_issue_labeled_or_unlabeled_body,
"issue_milestoned_or_demilestoned": get_issue_milestoned_or_demilestoned_body,
"issues_opened_via_transfer": get_issue_opened_via_transfer_body,
"issues_transferred": get_issue_transferred_body,
"issues": get_issue_body,
"member": get_member_body,
"membership": get_membership_body,
"opened_pull_request": get_opened_or_update_pull_request_body,
"updated_pull_request": get_opened_or_update_pull_request_body,
"assigned_or_unassigned_pull_request": get_assigned_or_unassigned_pull_request_body,
"page_build": get_page_build_body,
"ping": get_ping_body,
"public": get_public_body,
"pull_request_ready_for_review": get_pull_request_ready_for_review_body,
"pull_request_review": get_pull_request_review_body,
"pull_request_review_comment": get_pull_request_review_comment_body,
"pull_request_review_requested": get_pull_request_review_requested_or_removed_body,
"pull_request_milestoned_or_demilestoned": get_pull_request_milestoned_or_demilestoned_body,
"pull_request_enqueued_or_dequeued": get_pull_request_enqueued_or_dequeued_body,
"pull_request_labeled_or_unlabeled": get_pull_request_labeled_or_unlabeled_body,
"pull_request_converted_to_draft": get_pull_request_converted_to_draft_body,
"pull_request_review_request_removed": get_pull_request_review_requested_or_removed_body,
"pull_request_auto_merge": get_pull_request_auto_merge_body,
"locked_or_unlocked_pull_request": get_locked_or_unlocked_pull_request_body,
"push_commits": get_push_commits_body,
"push_tags": get_push_tags_body,
"release": get_release_body,
"repository_advisory": get_repository_advisory_body,
"repository": get_repository_body,
"star": get_star_body,
"status": get_status_body,
"team": get_team_body,
"team_add": get_add_team_body,
"watch": get_watch_body,
"cancelled": get_cancelled_body,
"created": get_created_body,
"edited": get_edited_body,
"pending_cancellation": get_pending_cancellation_body,
"pending_tier_change": get_pending_tier_change_body,
"tier_changed": get_tier_changed_body,
}
SPONSORS_EVENT_TYPES = [
"cancelled",
"created",
"edited",
"pending_cancellation",
"pending_tier_change",
"tier_changed",
]
IGNORED_EVENTS = [
"check_suite",
"label",
"meta",
"milestone",
"organization",
"project_card",
"push__merge_queue",
"repository_vulnerability_alert",
]
IGNORED_PULL_REQUEST_ACTIONS = [
"approved",
]
IGNORED_TEAM_ACTIONS = [
# These are actions that are well documented by github
# (https://docs.github.com/en/developers/webhooks-and-events/webhook-events-and-payloads)
# but we ignore them for now, possibly just due to laziness.
# One curious example here is team/added_to_repository, which is
# possibly the same as team_add.
"added_to_repository",
"created",
"deleted",
"removed_from_repository",
]
ALL_EVENT_TYPES = list(EVENT_FUNCTION_MAPPER.keys())
@webhook_view("GitHub", notify_bot_owner_on_invalid_json=True, all_event_types=ALL_EVENT_TYPES)
@typed_endpoint
def api_github_webhook(
request: HttpRequest,
user_profile: UserProfile,
*,
payload: JsonBodyPayload[WildValue],
branches: str | None = None,
user_specified_topic: OptionalUserSpecifiedTopicStr = None,
ignore_private_repositories: Json[bool] = False,
include_repository_name: Json[bool] = False,
include_emoji_indicators: Json[bool] = True,
concise_edit_format: Json[bool] = True,
) -> HttpResponse:
"""
GitHub sends the event as an HTTP header. We have our
own Zulip-specific concept of an event that often maps
directly to the X-GitHub-Event header's event, but we sometimes
refine it based on the payload.
"""
header_event = get_event_header(request, "X-GitHub-Event", "GitHub")
if is_ignored_event(header_event, payload, ignore_private_repositories):
return json_success(request)
event = get_zulip_event_name(header_event, payload, branches)
if event is None:
# This is nothing to worry about--get_event() returns None
# for events that are valid but not yet handled by us.
# See IGNORED_EVENTS, for example.
return json_success(request)
topic_name = get_topic_based_on_type(payload, event)
body_function = EVENT_FUNCTION_MAPPER[event]
helper = Helper(
request=request,
payload=payload,
include_title=user_specified_topic is not None,
include_repository_name=include_repository_name,
include_emoji_indicators=include_emoji_indicators,
user_profile=user_profile,
concise_edit_format=concise_edit_format,
)
body = body_function(helper)
check_send_webhook_message(request, user_profile, topic_name, body, event)
return json_success(request)
def is_ignored_event(
header_event: str,
payload: WildValue,
ignore_private_repositories: bool,
) -> bool:
action = payload.get("action", "").tame(check_string)
# Ignore events from private repositories if the URL option is set.
if (
"repository" in payload
and payload["repository"]["private"].tame(check_bool)
and ignore_private_repositories
):
return True
# Ignore 'comment edited' events (except discussion comments)
# if the comment body remains unchanged.
if (
"comment" in header_event
and "discussion" not in header_event
and action == "edited"
and payload["changes"]["body"]["from"].tame(check_string)
== payload["comment"]["body"].tame(check_string)
):
return True
# Deleting a label removes it from all issues, PRs, and discussions.
# Suppress noisy per-item "unlabeled" notifications when the "label"
# does not exist.
return action == "unlabeled" and "label" not in payload
def is_empty_pull_request_review_event(payload: WildValue) -> bool:
# When submitting a review, GitHub has a bug where it'll send a
# duplicate empty "edited" event for the main review body. We ignore
# those, to avoid triggering duplicate notifications.
action = payload["action"].tame(check_string)
changes = payload.get("changes", {})
return action == "edited" and len(changes) == 0
PULL_REQUEST_ACTION_TO_EVENT = {
"opened": "opened_pull_request",
"reopened": "opened_pull_request",
"synchronize": "updated_pull_request",
"edited": "updated_pull_request",
"assigned": "assigned_or_unassigned_pull_request",
"unassigned": "assigned_or_unassigned_pull_request",
"closed": "closed_pull_request",
"review_requested": "pull_request_review_requested",
"review_request_removed": "pull_request_review_request_removed",
"ready_for_review": "pull_request_ready_for_review",
"locked": "locked_or_unlocked_pull_request",
"unlocked": "locked_or_unlocked_pull_request",
"auto_merge_enabled": "pull_request_auto_merge",
"auto_merge_disabled": "pull_request_auto_merge",
"milestoned": "pull_request_milestoned_or_demilestoned",
"demilestoned": "pull_request_milestoned_or_demilestoned",
"enqueued": "pull_request_enqueued_or_dequeued",
"dequeued": "pull_request_enqueued_or_dequeued",
"labeled": "pull_request_labeled_or_unlabeled",
"unlabeled": "pull_request_labeled_or_unlabeled",
"converted_to_draft": "pull_request_converted_to_draft",
}
ISSUE_ACTION_TO_EVENT = {
"labeled": "issue_labeled_or_unlabeled",
"unlabeled": "issue_labeled_or_unlabeled",
"milestoned": "issue_milestoned_or_demilestoned",
"demilestoned": "issue_milestoned_or_demilestoned",
"transferred": "issues_transferred",
}
def get_push_event_name(payload: WildValue, branches: str | None) -> str | None:
if is_merge_queue_push_event(payload):
return None
if not is_commit_push_event(payload):
return "push_tags"
if branches is not None:
branch = get_branch_name_from_ref(payload["ref"].tame(check_string))
if not is_branch_name_notifiable(branch, branches):
return None
return "push_commits"
def get_zulip_event_name(
header_event: str,
payload: WildValue,
branches: str | None,
) -> str | None:
action = payload.get("action", "").tame(check_string)
match header_event:
case "pull_request":
if action in IGNORED_PULL_REQUEST_ACTIONS:
return None # nocoverage
return PULL_REQUEST_ACTION_TO_EVENT.get(action)
case "issues":
if action == "opened" and payload.get("changes", {}).get("old_issue"):
return "issues_opened_via_transfer"
return ISSUE_ACTION_TO_EVENT.get(action, "issues")
case "pull_request_review":
return None if is_empty_pull_request_review_event(payload) else "pull_request_review"
case "push":
return get_push_event_name(payload, branches)
case "check_run":
status = payload["check_run"]["status"].tame(check_string)
return "check_run" if status == "completed" else None
case "team":
if action == "edited":
return "team"
if action in IGNORED_TEAM_ACTIONS:
return None
raise UnsupportedWebhookEventTypeError(f"unsupported team action {action}")
case _:
if header_event in IGNORED_EVENTS:
return None
if header_event in EVENT_FUNCTION_MAPPER:
return header_event
raise UnsupportedWebhookEventTypeError(f"{header_event}:{action or '???'}")