2016-08-17 17:26:37 +00:00
|
|
|
/*
|
2023-01-31 09:58:17 +00:00
|
|
|
Copyright 2016, 2019, 2023 The Matrix.org Foundation C.I.C.
|
2016-08-17 17:26:37 +00:00
|
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
you may not use this file except in compliance with the License.
|
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2021-06-29 12:11:58 +00:00
|
|
|
import { PushProcessor } from "matrix-js-sdk/src/pushprocessor";
|
2023-01-31 09:58:17 +00:00
|
|
|
import { NotificationCountType } from "matrix-js-sdk/src/models/room";
|
|
|
|
import { ConditionKind, PushRuleActionName, PushRuleKind, TweakName } from "matrix-js-sdk/src/@types/PushRules";
|
2021-09-27 12:32:04 +00:00
|
|
|
|
2023-01-31 09:58:17 +00:00
|
|
|
import type { IPushRule } from "matrix-js-sdk/src/@types/PushRules";
|
|
|
|
import type { Room } from "matrix-js-sdk/src/models/room";
|
|
|
|
import type { MatrixClient } from "matrix-js-sdk/src/matrix";
|
2021-10-22 22:23:32 +00:00
|
|
|
import { MatrixClientPeg } from "./MatrixClientPeg";
|
2023-01-31 09:58:17 +00:00
|
|
|
import { NotificationColor } from "./stores/notifications/NotificationColor";
|
|
|
|
import { getUnsentMessages } from "./components/structures/RoomStatusBar";
|
|
|
|
import { doesRoomHaveUnreadMessages, doesRoomOrThreadHaveUnreadMessages } from "./Unread";
|
2023-01-31 12:38:25 +00:00
|
|
|
import { EffectiveMembership, getEffectiveMembership } from "./utils/membership";
|
2023-02-03 12:00:33 +00:00
|
|
|
import SettingsStore from "./settings/SettingsStore";
|
2021-10-22 22:23:32 +00:00
|
|
|
|
2021-09-27 12:32:04 +00:00
|
|
|
export enum RoomNotifState {
|
|
|
|
AllMessagesLoud = "all_messages_loud",
|
|
|
|
AllMessages = "all_messages",
|
|
|
|
MentionsOnly = "mentions_only",
|
|
|
|
Mute = "mute",
|
|
|
|
}
|
2016-08-17 17:26:37 +00:00
|
|
|
|
2023-01-31 09:58:17 +00:00
|
|
|
export function getRoomNotifsState(client: MatrixClient, roomId: string): RoomNotifState | null {
|
2022-11-29 10:55:15 +00:00
|
|
|
if (client.isGuest()) return RoomNotifState.AllMessages;
|
2016-08-18 13:00:14 +00:00
|
|
|
|
2016-08-17 17:26:37 +00:00
|
|
|
// look through the override rules for a rule affecting this room:
|
|
|
|
// if one exists, it will take precedence.
|
|
|
|
const muteRule = findOverrideMuteRule(roomId);
|
2016-08-18 13:00:14 +00:00
|
|
|
if (muteRule) {
|
2021-09-27 12:32:04 +00:00
|
|
|
return RoomNotifState.Mute;
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// for everything else, look at the room rule.
|
2023-02-13 17:01:43 +00:00
|
|
|
let roomRule: IPushRule | undefined;
|
2018-02-06 17:50:53 +00:00
|
|
|
try {
|
2022-11-29 10:55:15 +00:00
|
|
|
roomRule = client.getRoomPushRule("global", roomId);
|
2018-02-06 17:50:53 +00:00
|
|
|
} catch (err) {
|
|
|
|
// Possible that the client doesn't have pushRules yet. If so, it
|
2022-03-04 09:39:16 +00:00
|
|
|
// hasn't started either, so indicate that this room is not notifying.
|
2018-02-06 17:50:53 +00:00
|
|
|
return null;
|
|
|
|
}
|
2016-08-17 17:26:37 +00:00
|
|
|
|
|
|
|
// XXX: We have to assume the default is to notify for all messages
|
|
|
|
// (in particular this will be 'wrong' for one to one rooms because
|
|
|
|
// they will notify loudly for all messages)
|
2022-03-04 09:39:16 +00:00
|
|
|
if (!roomRule?.enabled) return RoomNotifState.AllMessages;
|
2016-08-17 17:26:37 +00:00
|
|
|
|
|
|
|
// a mute at the room level will still allow mentions
|
|
|
|
// to notify
|
2021-09-27 12:32:04 +00:00
|
|
|
if (isMuteRule(roomRule)) return RoomNotifState.MentionsOnly;
|
2016-08-17 17:26:37 +00:00
|
|
|
|
|
|
|
const actionsObject = PushProcessor.actionListToActionsObject(roomRule.actions);
|
2021-09-27 12:32:04 +00:00
|
|
|
if (actionsObject.tweaks.sound) return RoomNotifState.AllMessagesLoud;
|
2016-08-17 17:26:37 +00:00
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2021-09-27 12:32:04 +00:00
|
|
|
export function setRoomNotifsState(roomId: string, newState: RoomNotifState): Promise<void> {
|
|
|
|
if (newState === RoomNotifState.Mute) {
|
2016-08-18 13:00:14 +00:00
|
|
|
return setRoomNotifsStateMuted(roomId);
|
|
|
|
} else {
|
|
|
|
return setRoomNotifsStateUnmuted(roomId, newState);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-24 06:50:21 +00:00
|
|
|
export function getUnreadNotificationCount(room: Room, type: NotificationCountType, threadId?: string): number {
|
|
|
|
let notificationCount = !!threadId
|
|
|
|
? room.getThreadUnreadNotificationCount(threadId, type)
|
|
|
|
: room.getUnreadNotificationCount(type);
|
2019-04-01 22:06:33 +00:00
|
|
|
|
|
|
|
// Check notification counts in the old room just in case there's some lost
|
|
|
|
// there. We only go one level down to avoid performance issues, and theory
|
|
|
|
// is that 1st generation rooms will have already been read by the 3rd generation.
|
2023-02-03 12:00:33 +00:00
|
|
|
const msc3946ProcessDynamicPredecessor = SettingsStore.getValue("feature_dynamic_room_predecessors");
|
|
|
|
const predecessor = room.findPredecessor(msc3946ProcessDynamicPredecessor);
|
2022-10-24 06:50:21 +00:00
|
|
|
// Exclude threadId, as the same thread can't continue over a room upgrade
|
2023-02-03 12:00:33 +00:00
|
|
|
if (!threadId && predecessor?.roomId) {
|
|
|
|
const oldRoomId = predecessor.roomId;
|
2019-04-01 22:06:33 +00:00
|
|
|
const oldRoom = MatrixClientPeg.get().getRoom(oldRoomId);
|
|
|
|
if (oldRoom) {
|
|
|
|
// We only ever care if there's highlights in the old room. No point in
|
|
|
|
// notifying the user for unread messages because they would have extreme
|
|
|
|
// difficulty changing their notification preferences away from "All Messages"
|
|
|
|
// and "Noisy".
|
2021-09-27 12:32:04 +00:00
|
|
|
notificationCount += oldRoom.getUnreadNotificationCount(NotificationCountType.Highlight);
|
2019-04-01 22:06:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return notificationCount;
|
|
|
|
}
|
|
|
|
|
2021-09-27 12:32:04 +00:00
|
|
|
function setRoomNotifsStateMuted(roomId: string): Promise<any> {
|
2016-08-17 17:26:37 +00:00
|
|
|
const cli = MatrixClientPeg.get();
|
2023-02-13 17:01:43 +00:00
|
|
|
const promises: Promise<unknown>[] = [];
|
2016-08-17 17:26:37 +00:00
|
|
|
|
2016-08-18 13:00:14 +00:00
|
|
|
// delete the room rule
|
|
|
|
const roomRule = cli.getRoomPushRule("global", roomId);
|
|
|
|
if (roomRule) {
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(cli.deletePushRule("global", PushRuleKind.RoomSpecific, roomRule.rule_id));
|
2016-08-18 13:00:14 +00:00
|
|
|
}
|
2016-08-17 17:26:37 +00:00
|
|
|
|
2016-08-18 14:21:46 +00:00
|
|
|
// add/replace an override rule to squelch everything in this room
|
|
|
|
// NB. We use the room ID as the name of this rule too, although this
|
|
|
|
// is an override rule, not a room rule: it still pertains to this room
|
|
|
|
// though, so using the room ID as the rule ID is logical and prevents
|
|
|
|
// duplicate copies of the rule.
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(
|
|
|
|
cli.addPushRule("global", PushRuleKind.Override, roomId, {
|
2016-08-18 13:00:14 +00:00
|
|
|
conditions: [
|
|
|
|
{
|
2022-05-13 19:13:21 +00:00
|
|
|
kind: ConditionKind.EventMatch,
|
2016-08-18 13:00:14 +00:00
|
|
|
key: "room_id",
|
|
|
|
pattern: roomId,
|
2017-07-01 13:28:12 +00:00
|
|
|
},
|
2016-08-18 13:00:14 +00:00
|
|
|
],
|
2022-05-13 19:13:21 +00:00
|
|
|
actions: [PushRuleActionName.DontNotify],
|
2016-08-18 13:00:14 +00:00
|
|
|
}),
|
|
|
|
);
|
|
|
|
|
2017-07-12 13:04:20 +00:00
|
|
|
return Promise.all(promises);
|
2016-08-18 13:00:14 +00:00
|
|
|
}
|
|
|
|
|
2021-09-27 12:32:04 +00:00
|
|
|
function setRoomNotifsStateUnmuted(roomId: string, newState: RoomNotifState): Promise<any> {
|
2016-08-18 13:00:14 +00:00
|
|
|
const cli = MatrixClientPeg.get();
|
2023-02-13 17:01:43 +00:00
|
|
|
const promises: Promise<unknown>[] = [];
|
2016-08-18 13:00:14 +00:00
|
|
|
|
|
|
|
const overrideMuteRule = findOverrideMuteRule(roomId);
|
|
|
|
if (overrideMuteRule) {
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(cli.deletePushRule("global", PushRuleKind.Override, overrideMuteRule.rule_id));
|
2016-08-18 13:00:14 +00:00
|
|
|
}
|
|
|
|
|
2021-09-27 12:32:04 +00:00
|
|
|
if (newState === RoomNotifState.AllMessages) {
|
2016-08-18 15:59:25 +00:00
|
|
|
const roomRule = cli.getRoomPushRule("global", roomId);
|
|
|
|
if (roomRule) {
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(cli.deletePushRule("global", PushRuleKind.RoomSpecific, roomRule.rule_id));
|
2016-08-18 15:59:25 +00:00
|
|
|
}
|
2021-09-27 12:32:04 +00:00
|
|
|
} else if (newState === RoomNotifState.MentionsOnly) {
|
|
|
|
promises.push(
|
|
|
|
cli.addPushRule("global", PushRuleKind.RoomSpecific, roomId, {
|
2022-05-13 19:13:21 +00:00
|
|
|
actions: [PushRuleActionName.DontNotify],
|
2016-08-17 17:26:37 +00:00
|
|
|
}),
|
|
|
|
);
|
2016-08-18 13:00:14 +00:00
|
|
|
// https://matrix.org/jira/browse/SPEC-400
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(cli.setPushRuleEnabled("global", PushRuleKind.RoomSpecific, roomId, true));
|
|
|
|
} else if (newState === RoomNotifState.AllMessagesLoud) {
|
|
|
|
promises.push(
|
|
|
|
cli.addPushRule("global", PushRuleKind.RoomSpecific, roomId, {
|
2016-08-18 13:00:14 +00:00
|
|
|
actions: [
|
2022-05-13 19:13:21 +00:00
|
|
|
PushRuleActionName.Notify,
|
2016-08-18 13:00:14 +00:00
|
|
|
{
|
2022-05-13 19:13:21 +00:00
|
|
|
set_tweak: TweakName.Sound,
|
2016-08-18 13:00:14 +00:00
|
|
|
value: "default",
|
2017-07-01 13:28:12 +00:00
|
|
|
},
|
|
|
|
],
|
2016-08-18 13:00:14 +00:00
|
|
|
}),
|
|
|
|
);
|
|
|
|
// https://matrix.org/jira/browse/SPEC-400
|
2021-09-27 12:32:04 +00:00
|
|
|
promises.push(cli.setPushRuleEnabled("global", PushRuleKind.RoomSpecific, roomId, true));
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 13:04:20 +00:00
|
|
|
return Promise.all(promises);
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
|
|
|
|
2023-01-31 09:58:17 +00:00
|
|
|
function findOverrideMuteRule(roomId: string): IPushRule | null {
|
2020-12-16 17:16:15 +00:00
|
|
|
const cli = MatrixClientPeg.get();
|
2021-11-19 17:35:11 +00:00
|
|
|
if (!cli?.pushRules?.global?.override) {
|
2018-02-06 17:50:53 +00:00
|
|
|
return null;
|
|
|
|
}
|
2021-11-19 17:35:11 +00:00
|
|
|
for (const rule of cli.pushRules.global.override) {
|
2022-03-04 09:39:16 +00:00
|
|
|
if (rule.enabled && isRuleForRoom(roomId, rule) && isMuteRule(rule)) {
|
|
|
|
return rule;
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2021-11-19 17:35:11 +00:00
|
|
|
function isRuleForRoom(roomId: string, rule: IPushRule): boolean {
|
2022-03-04 09:39:16 +00:00
|
|
|
if (rule.conditions?.length !== 1) {
|
2016-08-17 17:26:37 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
const cond = rule.conditions[0];
|
2021-11-19 17:35:11 +00:00
|
|
|
return cond.kind === ConditionKind.EventMatch && cond.key === "room_id" && cond.pattern === roomId;
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
|
|
|
|
2021-11-19 17:35:11 +00:00
|
|
|
function isMuteRule(rule: IPushRule): boolean {
|
|
|
|
return rule.actions.length === 1 && rule.actions[0] === PushRuleActionName.DontNotify;
|
2016-08-17 17:26:37 +00:00
|
|
|
}
|
2023-01-31 09:58:17 +00:00
|
|
|
|
|
|
|
export function determineUnreadState(
|
2023-01-31 12:38:25 +00:00
|
|
|
room?: Room,
|
2023-01-31 09:58:17 +00:00
|
|
|
threadId?: string,
|
|
|
|
): { color: NotificationColor; symbol: string | null; count: number } {
|
2023-01-31 12:38:25 +00:00
|
|
|
if (!room) {
|
|
|
|
return { symbol: null, count: 0, color: NotificationColor.None };
|
|
|
|
}
|
|
|
|
|
2023-01-31 09:58:17 +00:00
|
|
|
if (getUnsentMessages(room, threadId).length > 0) {
|
|
|
|
return { symbol: "!", count: 1, color: NotificationColor.Unsent };
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getEffectiveMembership(room.getMyMembership()) === EffectiveMembership.Invite) {
|
|
|
|
return { symbol: "!", count: 1, color: NotificationColor.Red };
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getRoomNotifsState(room.client, room.roomId) === RoomNotifState.Mute) {
|
|
|
|
return { symbol: null, count: 0, color: NotificationColor.None };
|
|
|
|
}
|
|
|
|
|
|
|
|
const redNotifs = getUnreadNotificationCount(room, NotificationCountType.Highlight, threadId);
|
|
|
|
const greyNotifs = getUnreadNotificationCount(room, NotificationCountType.Total, threadId);
|
|
|
|
|
|
|
|
const trueCount = greyNotifs || redNotifs;
|
|
|
|
if (redNotifs > 0) {
|
|
|
|
return { symbol: null, count: trueCount, color: NotificationColor.Red };
|
|
|
|
}
|
|
|
|
|
|
|
|
if (greyNotifs > 0) {
|
|
|
|
return { symbol: null, count: trueCount, color: NotificationColor.Grey };
|
|
|
|
}
|
|
|
|
|
|
|
|
// We don't have any notified messages, but we might have unread messages. Let's
|
|
|
|
// find out.
|
|
|
|
let hasUnread = false;
|
|
|
|
if (threadId) hasUnread = doesRoomOrThreadHaveUnreadMessages(room.getThread(threadId)!);
|
|
|
|
else hasUnread = doesRoomHaveUnreadMessages(room);
|
|
|
|
|
|
|
|
return {
|
|
|
|
symbol: null,
|
|
|
|
count: trueCount,
|
|
|
|
color: hasUnread ? NotificationColor.Bold : NotificationColor.None,
|
|
|
|
};
|
|
|
|
}
|