Zulip server and web application. Open-source team chat that helps teams stay productive and focused.
import {$} from "jquery";
import * as alert_words from "./alert_words.ts";
import * as blueslip from "./blueslip.ts";
import * as desktop_notifications from "./desktop_notifications.ts";
import {$t} from "./i18n.ts";
import * as message_parser from "./message_parser.ts";
import type {Message} from "./message_store.ts";
import * as message_view from "./message_view.ts";
import * as people from "./people.ts";
import * as spoilers from "./spoilers.ts";
import * as stream_data from "./stream_data.ts";
import * as sub_store from "./sub_store.ts";
import * as ui_util from "./ui_util.ts";
import {user_settings} from "./user_settings.ts";
import * as user_topics from "./user_topics.ts";
import * as util from "./util.ts";
type TestNotificationMessage = {
id: number;
type: "test-notification";
sender_email: string;
sender_full_name: string;
display_reply_to: string;
content: string;
unread: boolean;
notification_sent?: boolean;
// Needed for functions that handle Message
is_me_message?: undefined;
sent_by_me?: undefined;
mentioned_me_directly?: undefined;
};
function small_avatar_url_for_test_notification(message: TestNotificationMessage): string {
// this is a heavily simplified version of people.small_avatar_url
return people.gravatar_url_for_email(message.sender_email);
}
function get_notification_content(message: Message | TestNotificationMessage): string {
let content;
// Convert the content to plain text, replacing emoji with their alt text
const $content = $("<div>").html(message.content);
ui_util.convert_unicode_eligible_emoji_to_unicode($content);
ui_util.change_katex_to_raw_latex($content);
ui_util.potentially_collapse_quotes($content);
spoilers.hide_spoilers_in_notification($content);
if (
$content.text().trim() === "" &&
(message_parser.message_has_image(message.content) ||
message_parser.message_has_attachment(message.content))
) {
content = $t({defaultMessage: "(attached file)"});
} else {
content = $content.text();
}
if (message.is_me_message) {
content = message.sender_full_name + content.slice(3);
}
if (
(message.type === "private" || message.type === "test-notification") &&
!user_settings.pm_content_in_desktop_notifications
) {
content = $t(
{defaultMessage: "New direct message from {sender_full_name}"},
{sender_full_name: message.sender_full_name},
);
}
return content;
}
function debug_notification_source_value(message: Message | TestNotificationMessage): void {
let notification_source;
if (message.type === "private" || message.type === "test-notification") {
notification_source = "pm";
} else if (message.mentioned) {
notification_source = "mention";
} else if (message.alerted) {
notification_source = "alert";
} else {
notification_source = "stream";
}
blueslip.debug("Desktop notification from source " + notification_source);
}
function get_notification_key(message: Message | TestNotificationMessage): string {
if (message.type === "test-notification") {
return `test:${message.display_reply_to}`;
}
if (message.type === "private") {
return `dm:${message.to_user_ids}`;
}
return `channel:${message.sender_id}:${message.stream_id}:${message.topic}`;
}
function remove_sender_from_list_of_recipients(message: Message): string {
return `, ${message.display_reply_to}, `
.replace(`, ${message.sender_full_name}, `, ", ")
.slice(", ".length, -", ".length);
}
function get_notification_title(
message: Message | TestNotificationMessage,
msg_count: number,
): string {
let title_prefix = message.sender_full_name;
let title_suffix = "";
if (msg_count > 1) {
title_prefix = $t(
{defaultMessage: "{msg_count} messages from {sender_name}"},
{msg_count, sender_name: message.sender_full_name},
);
}
switch (message.type) {
case "private":
if (message.display_recipient.length > 2) {
const other_recipients = remove_sender_from_list_of_recipients(message);
// Same as compose_ui.compute_placeholder_text.
const other_recipients_translated = util.format_array_as_list(
other_recipients.split(", "),
"long",
"conjunction",
);
// Character limit taken from https://www.pushengage.com/push-notification-character-limits
// We use a higher character limit so that the 3rd sender can at least be partially visible so that
// the user can distinguish the group DM.
// If the message has too many recipients to list them all...
if (title_prefix.length + other_recipients_translated.length > 50) {
// Then count how many people are in the conversation and summarize
title_suffix = $t(
{defaultMessage: "(to you and {participants_count} more)"},
{participants_count: message.display_recipient.length - 2},
);
} else {
title_suffix = $t(
{defaultMessage: "(to you and {other_participant_names})"},
{other_participant_names: other_recipients_translated},
);
}
} else {
title_suffix = $t({defaultMessage: "(to you)"});
}
return title_prefix + " " + title_suffix;
case "stream": {
const stream_name = stream_data.get_stream_name_from_id(message.stream_id);
const topic_display_name = util.get_final_topic_display_name(message.topic);
title_suffix = " (#" + stream_name + " > " + topic_display_name + ")";
break;
}
}
return title_prefix + title_suffix;
}
export function process_notification(message: Message | TestNotificationMessage): void {
const content = get_notification_content(message);
const key = get_notification_key(message);
let msg_count = 1;
debug_notification_source_value(message);
const notice_memory = desktop_notifications.notice_memory.get(key);
if (notice_memory) {
msg_count = notice_memory.data.msg_count + 1;
}
const title = get_notification_title(message, msg_count);
const icon_url =
message.type === "test-notification"
? small_avatar_url_for_test_notification(message)
: people.small_avatar_url(message);
const notification_options = {
icon: icon_url,
body: content,
tag: message.id.toString(),
};
function on_click(): void {
if (message.type !== "test-notification") {
// Narrowing to message's near view helps to handle the case
// where a user clicked the notification, but before narrowing
// the message deletion got processed.
message_view.narrow_to_message_near(message, "notification");
}
}
desktop_notifications.create_notification({
notification_options,
key,
title,
data: {type: "message", message_id: message.id, msg_count},
on_click,
});
}
export function message_is_notifiable(message: Message | TestNotificationMessage): boolean {
// Independent of the user's notification settings, are there
// properties of the message that unconditionally mean we
// shouldn't notify about it.
//
// NOTE: The muted channel block below checks
// wildcard_mentions_notify setting for maintainability, keeping the
// muting override logic in one place rather than duplicating it
// across should_send_*_notification. This should not be taken
// as precedent for adding other notification settings here.
if (message.sent_by_me) {
return false;
}
// If a message is edited multiple times, we want to err on the side of
// not spamming notifications.
if (message.notification_sent) {
return false;
}
// @-<username> mentions take precedence over muted-ness. Note
// that @all mentions are still suppressed by muting unless the
// channel-specific wildcard_mentions_notify setting is enabled.
if (message.mentioned_me_directly) {
return true;
}
// Messages to followed topics take precedence over muted-ness.
if (
message.type === "stream" &&
user_topics.is_topic_followed(message.stream_id, message.topic)
) {
return true;
}
if (message.type === "stream" && user_topics.is_topic_muted(message.stream_id, message.topic)) {
return false;
}
// Messages to unmuted topics in muted streams may generate desktop notifications.
if (
message.type === "stream" &&
stream_data.is_muted(message.stream_id) &&
!user_topics.is_topic_unmuted(message.stream_id, message.topic)
) {
// Now, only way a message can notify is if it's a wildcard mention
// with channel-specific wildcard_mentions_notify=true.
const sub = sub_store.get(message.stream_id);
if (!(message.mentioned && sub?.wildcard_mentions_notify === true)) {
return false;
}
}
// Everything else is on the table; next filter based on notification
// settings.
return true;
}
export function should_send_desktop_notification(
message: Message | TestNotificationMessage,
): boolean {
// Always notify for testing notifications.
if (message.type === "test-notification") {
return true;
}
// For streams, send if desktop notifications are enabled for all
// message on this stream.
if (
message.type === "stream" &&
stream_data.receives_notifications(message.stream_id, "desktop_notifications")
) {
return true;
}
// enable_followed_topic_desktop_notifications determines whether we pop up
// a notification for messages in followed topics.
if (
message.type === "stream" &&
user_topics.is_topic_followed(message.stream_id, message.topic) &&
user_settings.enable_followed_topic_desktop_notifications
) {
return true;
}
// enable_desktop_notifications determines whether we pop up a
// notification for direct messages, mentions, and/or alerts.
if (!user_settings.enable_desktop_notifications) {
return false;
}
// And then we need to check if the message is a direct message,
// mention, wildcard mention with wildcard_mentions_notify, or alert.
if (message.type === "private") {
return true;
}
if (alert_words.notifies(message) || message.mentioned_me_directly) {
return true;
}
// The following blocks for 'wildcard mentions' and 'Followed topic wildcard mentions'
// should be placed below (as they are right now) the 'user_settings.enable_desktop_notifications'
// block because the global, stream-specific, and followed topic wildcard mention
// settings are wrappers around the personal-mention setting.
// wildcard mentions
if (
message.mentioned &&
stream_data.receives_notifications(message.stream_id, "wildcard_mentions_notify")
) {
return true;
}
// Followed topic wildcard mentions
if (
message.mentioned &&
user_topics.is_topic_followed(message.stream_id, message.topic) &&
user_settings.enable_followed_topic_wildcard_mentions_notify
) {
return true;
}
return false;
}
export function should_send_audible_notification(
message: Message | TestNotificationMessage,
): boolean {
// If `None` is selected as the notification sound, never send
// audible notifications regardless of other configuration.
if (user_settings.notification_sound === "none") {
return false;
}
// For streams, ding if sounds are enabled for all messages on
// this stream.
if (
message.type === "stream" &&
stream_data.receives_notifications(message.stream_id, "audible_notifications")
) {
return true;
}
// enable_followed_topic_audible_notifications determines whether we ding
// for messages in followed topics.
if (
message.type === "stream" &&
user_topics.is_topic_followed(message.stream_id, message.topic) &&
user_settings.enable_followed_topic_audible_notifications
) {
return true;
}
// enable_sounds determines whether we ding for direct messages,
// mentions, and/or alerts.
if (!user_settings.enable_sounds) {
return false;
}
// And then we need to check if the message is a direct message,
// mention, wildcard mention with wildcard_mentions_notify, or alert.
if (message.type === "private" || message.type === "test-notification") {
return true;
}
if (alert_words.notifies(message) || message.mentioned_me_directly) {
return true;
}
// The following blocks for 'wildcard mentions' and 'Followed topic wildcard mentions'
// should be placed below (as they are right now) the 'user_settings.enable_sounds'
// block because the global, stream-specific, and followed topic wildcard mention
// settings are wrappers around the personal-mention setting.
// wildcard mentions
if (
message.mentioned &&
stream_data.receives_notifications(message.stream_id, "wildcard_mentions_notify")
) {
return true;
}
// Followed topic wildcard mentions
if (
message.mentioned &&
user_topics.is_topic_followed(message.stream_id, message.topic) &&
user_settings.enable_followed_topic_wildcard_mentions_notify
) {
return true;
}
return false;
}
export function received_messages(messages: (Message | TestNotificationMessage)[]): void {
for (const message of messages) {
if (!message_is_notifiable(message)) {
continue;
}
if (!message.unread) {
// The message is already read; Zulip is currently in focus.
continue;
}
message.notification_sent = true;
if (should_send_desktop_notification(message)) {
process_notification(message);
}
if (should_send_audible_notification(message)) {
void ui_util.play_audio(util.the($("#user-notification-sound-audio")));
}
}
}
export function send_test_notification(content: string): void {
received_messages([
{
id: Math.random(),
type: "test-notification",
sender_email: "[email protected]",
sender_full_name: "Notification Bot",
display_reply_to: "Notification Bot",
content,
unread: true,
},
]);
}