mirror of
https://github.com/element-hq/element-web
synced 2024-11-28 20:38:55 +03:00
654 lines
29 KiB
TypeScript
654 lines
29 KiB
TypeScript
/*
|
|
Copyright 2015, 2016 OpenMarket Ltd
|
|
|
|
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.
|
|
*/
|
|
import React from 'react';
|
|
import { _t } from './languageHandler';
|
|
import * as Roles from './Roles';
|
|
import { isValid3pidInvite } from "./RoomInvite";
|
|
import SettingsStore from "./settings/SettingsStore";
|
|
import { ALL_RULE_TYPES, ROOM_RULE_TYPES, SERVER_RULE_TYPES, USER_RULE_TYPES } from "./mjolnir/BanList";
|
|
import { WIDGET_LAYOUT_EVENT_TYPE } from "./stores/widgets/WidgetLayoutStore";
|
|
import { RightPanelPhases } from './stores/RightPanelStorePhases';
|
|
import { Action } from './dispatcher/actions';
|
|
import defaultDispatcher from './dispatcher/dispatcher';
|
|
import { SetRightPanelPhasePayload } from './dispatcher/payloads/SetRightPanelPhasePayload';
|
|
import { MatrixEvent } from "matrix-js-sdk/src/models/event";
|
|
import { MatrixClientPeg } from "./MatrixClientPeg";
|
|
|
|
// These functions are frequently used just to check whether an event has
|
|
// any text to display at all. For this reason they return deferred values
|
|
// to avoid the expense of looking up translations when they're not needed.
|
|
|
|
function textForCallInviteEvent(event: MatrixEvent): () => string | null {
|
|
const getSenderName = () => event.sender ? event.sender.name : _t('Someone');
|
|
// FIXME: Find a better way to determine this from the event?
|
|
let isVoice = true;
|
|
if (event.getContent().offer && event.getContent().offer.sdp &&
|
|
event.getContent().offer.sdp.indexOf('m=video') !== -1) {
|
|
isVoice = false;
|
|
}
|
|
const isSupported = MatrixClientPeg.get().supportsVoip();
|
|
|
|
// This ladder could be reduced down to a couple string variables, however other languages
|
|
// can have a hard time translating those strings. In an effort to make translations easier
|
|
// and more accurate, we break out the string-based variables to a couple booleans.
|
|
if (isVoice && isSupported) {
|
|
return () => _t("%(senderName)s placed a voice call.", {
|
|
senderName: getSenderName(),
|
|
});
|
|
} else if (isVoice && !isSupported) {
|
|
return () => _t("%(senderName)s placed a voice call. (not supported by this browser)", {
|
|
senderName: getSenderName(),
|
|
});
|
|
} else if (!isVoice && isSupported) {
|
|
return () => _t("%(senderName)s placed a video call.", {
|
|
senderName: getSenderName(),
|
|
});
|
|
} else if (!isVoice && !isSupported) {
|
|
return () => _t("%(senderName)s placed a video call. (not supported by this browser)", {
|
|
senderName: getSenderName(),
|
|
});
|
|
}
|
|
}
|
|
|
|
function textForMemberEvent(ev: MatrixEvent, allowJSX: boolean, showHiddenEvents?: boolean): () => string | null {
|
|
// XXX: SYJS-16 "sender is sometimes null for join messages"
|
|
const senderName = ev.sender ? ev.sender.name : ev.getSender();
|
|
const targetName = ev.target ? ev.target.name : ev.getStateKey();
|
|
const prevContent = ev.getPrevContent();
|
|
const content = ev.getContent();
|
|
const reason = content.reason;
|
|
|
|
switch (content.membership) {
|
|
case 'invite': {
|
|
const threePidContent = content.third_party_invite;
|
|
if (threePidContent) {
|
|
if (threePidContent.display_name) {
|
|
return () => _t('%(targetName)s accepted the invitation for %(displayName)s', {
|
|
targetName,
|
|
displayName: threePidContent.display_name,
|
|
});
|
|
} else {
|
|
return () => _t('%(targetName)s accepted an invitation', { targetName });
|
|
}
|
|
} else {
|
|
return () => _t('%(senderName)s invited %(targetName)s', { senderName, targetName });
|
|
}
|
|
}
|
|
case 'ban':
|
|
return () => reason
|
|
? _t('%(senderName)s banned %(targetName)s: %(reason)s', { senderName, targetName, reason })
|
|
: _t('%(senderName)s banned %(targetName)s', { senderName, targetName });
|
|
case 'join':
|
|
if (prevContent && prevContent.membership === 'join') {
|
|
if (prevContent.displayname && content.displayname && prevContent.displayname !== content.displayname) {
|
|
return () => _t('%(oldDisplayName)s changed their display name to %(displayName)s', {
|
|
oldDisplayName: prevContent.displayname,
|
|
displayName: content.displayname,
|
|
});
|
|
} else if (!prevContent.displayname && content.displayname) {
|
|
return () => _t('%(senderName)s set their display name to %(displayName)s', {
|
|
senderName: ev.getSender(),
|
|
displayName: content.displayname,
|
|
});
|
|
} else if (prevContent.displayname && !content.displayname) {
|
|
return () => _t('%(senderName)s removed their display name (%(oldDisplayName)s)', {
|
|
senderName,
|
|
oldDisplayName: prevContent.displayname,
|
|
});
|
|
} else if (prevContent.avatar_url && !content.avatar_url) {
|
|
return () => _t('%(senderName)s removed their profile picture', { senderName });
|
|
} else if (prevContent.avatar_url && content.avatar_url &&
|
|
prevContent.avatar_url !== content.avatar_url) {
|
|
return () => _t('%(senderName)s changed their profile picture', { senderName });
|
|
} else if (!prevContent.avatar_url && content.avatar_url) {
|
|
return () => _t('%(senderName)s set a profile picture', { senderName });
|
|
} else if (showHiddenEvents ?? SettingsStore.getValue("showHiddenEventsInTimeline")) {
|
|
// This is a null rejoin, it will only be visible if using 'show hidden events' (labs)
|
|
return () => _t("%(senderName)s made no change", { senderName });
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!ev.target) console.warn("Join message has no target! -- " + ev.getContent().state_key);
|
|
return () => _t('%(targetName)s joined the room', { targetName });
|
|
}
|
|
case 'leave':
|
|
if (ev.getSender() === ev.getStateKey()) {
|
|
if (prevContent.membership === "invite") {
|
|
return () => _t('%(targetName)s rejected the invitation', { targetName });
|
|
} else {
|
|
return () => reason
|
|
? _t('%(targetName)s left the room: %(reason)s', { targetName, reason })
|
|
: _t('%(targetName)s left the room', { targetName });
|
|
}
|
|
} else if (prevContent.membership === "ban") {
|
|
return () => _t('%(senderName)s unbanned %(targetName)s', { senderName, targetName });
|
|
} else if (prevContent.membership === "invite") {
|
|
return () => reason
|
|
? _t('%(senderName)s withdrew %(targetName)s\'s invitation: %(reason)s', {
|
|
senderName,
|
|
targetName,
|
|
reason,
|
|
})
|
|
: _t('%(senderName)s withdrew %(targetName)s\'s invitation', { senderName, targetName });
|
|
} else if (prevContent.membership === "join") {
|
|
return () => reason
|
|
? _t('%(senderName)s kicked %(targetName)s: %(reason)s', {
|
|
senderName,
|
|
targetName,
|
|
reason,
|
|
})
|
|
: _t('%(senderName)s kicked %(targetName)s', { senderName, targetName });
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
function textForTopicEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
return () => _t('%(senderDisplayName)s changed the topic to "%(topic)s".', {
|
|
senderDisplayName,
|
|
topic: ev.getContent().topic,
|
|
});
|
|
}
|
|
|
|
function textForRoomNameEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
|
|
if (!ev.getContent().name || ev.getContent().name.trim().length === 0) {
|
|
return () => _t('%(senderDisplayName)s removed the room name.', { senderDisplayName });
|
|
}
|
|
if (ev.getPrevContent().name) {
|
|
return () => _t('%(senderDisplayName)s changed the room name from %(oldRoomName)s to %(newRoomName)s.', {
|
|
senderDisplayName,
|
|
oldRoomName: ev.getPrevContent().name,
|
|
newRoomName: ev.getContent().name,
|
|
});
|
|
}
|
|
return () => _t('%(senderDisplayName)s changed the room name to %(roomName)s.', {
|
|
senderDisplayName,
|
|
roomName: ev.getContent().name,
|
|
});
|
|
}
|
|
|
|
function textForTombstoneEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
return () => _t('%(senderDisplayName)s upgraded this room.', { senderDisplayName });
|
|
}
|
|
|
|
function textForJoinRulesEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
switch (ev.getContent().join_rule) {
|
|
case "public":
|
|
return () => _t('%(senderDisplayName)s made the room public to whoever knows the link.', {
|
|
senderDisplayName,
|
|
});
|
|
case "invite":
|
|
return () => _t('%(senderDisplayName)s made the room invite only.', {
|
|
senderDisplayName,
|
|
});
|
|
default:
|
|
// The spec supports "knock" and "private", however nothing implements these.
|
|
return () => _t('%(senderDisplayName)s changed the join rule to %(rule)s', {
|
|
senderDisplayName,
|
|
rule: ev.getContent().join_rule,
|
|
});
|
|
}
|
|
}
|
|
|
|
function textForGuestAccessEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
switch (ev.getContent().guest_access) {
|
|
case "can_join":
|
|
return () => _t('%(senderDisplayName)s has allowed guests to join the room.', { senderDisplayName });
|
|
case "forbidden":
|
|
return () => _t('%(senderDisplayName)s has prevented guests from joining the room.', { senderDisplayName });
|
|
default:
|
|
// There's no other options we can expect, however just for safety's sake we'll do this.
|
|
return () => _t('%(senderDisplayName)s changed guest access to %(rule)s', {
|
|
senderDisplayName,
|
|
rule: ev.getContent().guest_access,
|
|
});
|
|
}
|
|
}
|
|
|
|
function textForRelatedGroupsEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
const groups = ev.getContent().groups || [];
|
|
const prevGroups = ev.getPrevContent().groups || [];
|
|
const added = groups.filter((g) => !prevGroups.includes(g));
|
|
const removed = prevGroups.filter((g) => !groups.includes(g));
|
|
|
|
if (added.length && !removed.length) {
|
|
return () => _t('%(senderDisplayName)s enabled flair for %(groups)s in this room.', {
|
|
senderDisplayName,
|
|
groups: added.join(', '),
|
|
});
|
|
} else if (!added.length && removed.length) {
|
|
return () => _t('%(senderDisplayName)s disabled flair for %(groups)s in this room.', {
|
|
senderDisplayName,
|
|
groups: removed.join(', '),
|
|
});
|
|
} else if (added.length && removed.length) {
|
|
return () => _t('%(senderDisplayName)s enabled flair for %(newGroups)s and disabled flair for ' +
|
|
'%(oldGroups)s in this room.', {
|
|
senderDisplayName,
|
|
newGroups: added.join(', '),
|
|
oldGroups: removed.join(', '),
|
|
});
|
|
} else {
|
|
// Don't bother rendering this change (because there were no changes)
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function textForServerACLEvent(ev: MatrixEvent): () => string | null {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
const prevContent = ev.getPrevContent();
|
|
const current = ev.getContent();
|
|
const prev = {
|
|
deny: Array.isArray(prevContent.deny) ? prevContent.deny : [],
|
|
allow: Array.isArray(prevContent.allow) ? prevContent.allow : [],
|
|
allow_ip_literals: !(prevContent.allow_ip_literals === false),
|
|
};
|
|
|
|
let getText = null;
|
|
if (prev.deny.length === 0 && prev.allow.length === 0) {
|
|
getText = () => _t("%(senderDisplayName)s set the server ACLs for this room.", { senderDisplayName });
|
|
} else {
|
|
getText = () => _t("%(senderDisplayName)s changed the server ACLs for this room.", { senderDisplayName });
|
|
}
|
|
|
|
if (!Array.isArray(current.allow)) {
|
|
current.allow = [];
|
|
}
|
|
|
|
// If we know for sure everyone is banned, mark the room as obliterated
|
|
if (current.allow.length === 0) {
|
|
return () => getText() + " " +
|
|
_t("🎉 All servers are banned from participating! This room can no longer be used.");
|
|
}
|
|
|
|
return getText;
|
|
}
|
|
|
|
function textForMessageEvent(ev: MatrixEvent): () => string | null {
|
|
return () => {
|
|
const senderDisplayName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
let message = senderDisplayName + ': ' + ev.getContent().body;
|
|
if (ev.getContent().msgtype === "m.emote") {
|
|
message = "* " + senderDisplayName + " " + message;
|
|
} else if (ev.getContent().msgtype === "m.image") {
|
|
message = _t('%(senderDisplayName)s sent an image.', { senderDisplayName });
|
|
}
|
|
return message;
|
|
};
|
|
}
|
|
|
|
function textForCanonicalAliasEvent(ev: MatrixEvent): () => string | null {
|
|
const senderName = ev.sender && ev.sender.name ? ev.sender.name : ev.getSender();
|
|
const oldAlias = ev.getPrevContent().alias;
|
|
const oldAltAliases = ev.getPrevContent().alt_aliases || [];
|
|
const newAlias = ev.getContent().alias;
|
|
const newAltAliases = ev.getContent().alt_aliases || [];
|
|
const removedAltAliases = oldAltAliases.filter(alias => !newAltAliases.includes(alias));
|
|
const addedAltAliases = newAltAliases.filter(alias => !oldAltAliases.includes(alias));
|
|
|
|
if (!removedAltAliases.length && !addedAltAliases.length) {
|
|
if (newAlias) {
|
|
return () => _t('%(senderName)s set the main address for this room to %(address)s.', {
|
|
senderName: senderName,
|
|
address: ev.getContent().alias,
|
|
});
|
|
} else if (oldAlias) {
|
|
return () => _t('%(senderName)s removed the main address for this room.', {
|
|
senderName: senderName,
|
|
});
|
|
}
|
|
} else if (newAlias === oldAlias) {
|
|
if (addedAltAliases.length && !removedAltAliases.length) {
|
|
return () => _t('%(senderName)s added the alternative addresses %(addresses)s for this room.', {
|
|
senderName: senderName,
|
|
addresses: addedAltAliases.join(", "),
|
|
count: addedAltAliases.length,
|
|
});
|
|
} if (removedAltAliases.length && !addedAltAliases.length) {
|
|
return () => _t('%(senderName)s removed the alternative addresses %(addresses)s for this room.', {
|
|
senderName: senderName,
|
|
addresses: removedAltAliases.join(", "),
|
|
count: removedAltAliases.length,
|
|
});
|
|
} if (removedAltAliases.length && addedAltAliases.length) {
|
|
return () => _t('%(senderName)s changed the alternative addresses for this room.', {
|
|
senderName: senderName,
|
|
});
|
|
}
|
|
} else {
|
|
// both alias and alt_aliases where modified
|
|
return () => _t('%(senderName)s changed the main and alternative addresses for this room.', {
|
|
senderName: senderName,
|
|
});
|
|
}
|
|
// in case there is no difference between the two events,
|
|
// say something as we can't simply hide the tile from here
|
|
return () => _t('%(senderName)s changed the addresses for this room.', {
|
|
senderName: senderName,
|
|
});
|
|
}
|
|
|
|
function textForThreePidInviteEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.sender ? event.sender.name : event.getSender();
|
|
|
|
if (!isValid3pidInvite(event)) {
|
|
return () => _t('%(senderName)s revoked the invitation for %(targetDisplayName)s to join the room.', {
|
|
senderName,
|
|
targetDisplayName: event.getPrevContent().display_name || _t("Someone"),
|
|
});
|
|
}
|
|
|
|
return () => _t('%(senderName)s sent an invitation to %(targetDisplayName)s to join the room.', {
|
|
senderName,
|
|
targetDisplayName: event.getContent().display_name,
|
|
});
|
|
}
|
|
|
|
function textForHistoryVisibilityEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.sender ? event.sender.name : event.getSender();
|
|
switch (event.getContent().history_visibility) {
|
|
case 'invited':
|
|
return () => _t('%(senderName)s made future room history visible to all room members, '
|
|
+ 'from the point they are invited.', { senderName });
|
|
case 'joined':
|
|
return () => _t('%(senderName)s made future room history visible to all room members, '
|
|
+ 'from the point they joined.', { senderName });
|
|
case 'shared':
|
|
return () => _t('%(senderName)s made future room history visible to all room members.', { senderName });
|
|
case 'world_readable':
|
|
return () => _t('%(senderName)s made future room history visible to anyone.', { senderName });
|
|
default:
|
|
return () => _t('%(senderName)s made future room history visible to unknown (%(visibility)s).', {
|
|
senderName,
|
|
visibility: event.getContent().history_visibility,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Currently will only display a change if a user's power level is changed
|
|
function textForPowerEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.sender ? event.sender.name : event.getSender();
|
|
if (!event.getPrevContent() || !event.getPrevContent().users ||
|
|
!event.getContent() || !event.getContent().users) {
|
|
return null;
|
|
}
|
|
const previousUserDefault = event.getPrevContent().users_default || 0;
|
|
const currentUserDefault = event.getContent().users_default || 0;
|
|
// Construct set of userIds
|
|
const users = [];
|
|
Object.keys(event.getContent().users).forEach(
|
|
(userId) => {
|
|
if (users.indexOf(userId) === -1) users.push(userId);
|
|
},
|
|
);
|
|
Object.keys(event.getPrevContent().users).forEach(
|
|
(userId) => {
|
|
if (users.indexOf(userId) === -1) users.push(userId);
|
|
},
|
|
);
|
|
const diffs = [];
|
|
users.forEach((userId) => {
|
|
// Previous power level
|
|
let from = event.getPrevContent().users[userId];
|
|
if (!Number.isInteger(from)) {
|
|
from = previousUserDefault;
|
|
}
|
|
// Current power level
|
|
let to = event.getContent().users[userId];
|
|
if (!Number.isInteger(to)) {
|
|
to = currentUserDefault;
|
|
}
|
|
if (from === previousUserDefault && to === currentUserDefault) { return; }
|
|
if (to !== from) {
|
|
diffs.push({ userId, from, to });
|
|
}
|
|
});
|
|
if (!diffs.length) {
|
|
return null;
|
|
}
|
|
// XXX: This is also surely broken for i18n
|
|
return () => _t('%(senderName)s changed the power level of %(powerLevelDiffText)s.', {
|
|
senderName,
|
|
powerLevelDiffText: diffs.map(diff =>
|
|
_t('%(userId)s from %(fromPowerLevel)s to %(toPowerLevel)s', {
|
|
userId: diff.userId,
|
|
fromPowerLevel: Roles.textualPowerLevel(diff.from, previousUserDefault),
|
|
toPowerLevel: Roles.textualPowerLevel(diff.to, currentUserDefault),
|
|
}),
|
|
).join(", "),
|
|
});
|
|
}
|
|
|
|
const onPinnedMessagesClick = (): void => {
|
|
defaultDispatcher.dispatch<SetRightPanelPhasePayload>({
|
|
action: Action.SetRightPanelPhase,
|
|
phase: RightPanelPhases.PinnedMessages,
|
|
allowClose: false,
|
|
});
|
|
};
|
|
|
|
function textForPinnedEvent(event: MatrixEvent, allowJSX: boolean): () => string | JSX.Element | null {
|
|
if (!SettingsStore.getValue("feature_pinning")) return null;
|
|
const senderName = event.sender ? event.sender.name : event.getSender();
|
|
|
|
if (allowJSX) {
|
|
return () => (
|
|
<span>
|
|
{
|
|
_t(
|
|
"%(senderName)s changed the <a>pinned messages</a> for the room.",
|
|
{ senderName },
|
|
{ "a": (sub) => <a onClick={onPinnedMessagesClick}> { sub } </a> },
|
|
)
|
|
}
|
|
</span>
|
|
);
|
|
}
|
|
|
|
return () => _t("%(senderName)s changed the pinned messages for the room.", { senderName });
|
|
}
|
|
|
|
function textForWidgetEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.getSender();
|
|
const { name: prevName, type: prevType, url: prevUrl } = event.getPrevContent();
|
|
const { name, type, url } = event.getContent() || {};
|
|
|
|
let widgetName = name || prevName || type || prevType || '';
|
|
// Apply sentence case to widget name
|
|
if (widgetName && widgetName.length > 0) {
|
|
widgetName = widgetName[0].toUpperCase() + widgetName.slice(1);
|
|
}
|
|
|
|
// If the widget was removed, its content should be {}, but this is sufficiently
|
|
// equivalent to that condition.
|
|
if (url) {
|
|
if (prevUrl) {
|
|
return () => _t('%(widgetName)s widget modified by %(senderName)s', {
|
|
widgetName, senderName,
|
|
});
|
|
} else {
|
|
return () => _t('%(widgetName)s widget added by %(senderName)s', {
|
|
widgetName, senderName,
|
|
});
|
|
}
|
|
} else {
|
|
return () => _t('%(widgetName)s widget removed by %(senderName)s', {
|
|
widgetName, senderName,
|
|
});
|
|
}
|
|
}
|
|
|
|
function textForWidgetLayoutEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.sender?.name || event.getSender();
|
|
return () => _t("%(senderName)s has updated the widget layout", { senderName });
|
|
}
|
|
|
|
function textForMjolnirEvent(event: MatrixEvent): () => string | null {
|
|
const senderName = event.getSender();
|
|
const { entity: prevEntity } = event.getPrevContent();
|
|
const { entity, recommendation, reason } = event.getContent();
|
|
|
|
// Rule removed
|
|
if (!entity) {
|
|
if (USER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s removed the rule banning users matching %(glob)s",
|
|
{ senderName, glob: prevEntity });
|
|
} else if (ROOM_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s removed the rule banning rooms matching %(glob)s",
|
|
{ senderName, glob: prevEntity });
|
|
} else if (SERVER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s removed the rule banning servers matching %(glob)s",
|
|
{ senderName, glob: prevEntity });
|
|
}
|
|
|
|
// Unknown type. We'll say something, but we shouldn't end up here.
|
|
return () => _t("%(senderName)s removed a ban rule matching %(glob)s", { senderName, glob: prevEntity });
|
|
}
|
|
|
|
// Invalid rule
|
|
if (!recommendation || !reason) return () => _t(`%(senderName)s updated an invalid ban rule`, { senderName });
|
|
|
|
// Rule updated
|
|
if (entity === prevEntity) {
|
|
if (USER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s updated the rule banning users matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
} else if (ROOM_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s updated the rule banning rooms matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
} else if (SERVER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s updated the rule banning servers matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
}
|
|
|
|
// Unknown type. We'll say something but we shouldn't end up here.
|
|
return () => _t("%(senderName)s updated a ban rule matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
}
|
|
|
|
// New rule
|
|
if (!prevEntity) {
|
|
if (USER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s created a rule banning users matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
} else if (ROOM_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s created a rule banning rooms matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
} else if (SERVER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t("%(senderName)s created a rule banning servers matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
}
|
|
|
|
// Unknown type. We'll say something but we shouldn't end up here.
|
|
return () => _t("%(senderName)s created a ban rule matching %(glob)s for %(reason)s",
|
|
{ senderName, glob: entity, reason });
|
|
}
|
|
|
|
// else the entity !== prevEntity - count as a removal & add
|
|
if (USER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t(
|
|
"%(senderName)s changed a rule that was banning users matching %(oldGlob)s to matching " +
|
|
"%(newGlob)s for %(reason)s",
|
|
{ senderName, oldGlob: prevEntity, newGlob: entity, reason },
|
|
);
|
|
} else if (ROOM_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t(
|
|
"%(senderName)s changed a rule that was banning rooms matching %(oldGlob)s to matching " +
|
|
"%(newGlob)s for %(reason)s",
|
|
{ senderName, oldGlob: prevEntity, newGlob: entity, reason },
|
|
);
|
|
} else if (SERVER_RULE_TYPES.includes(event.getType())) {
|
|
return () => _t(
|
|
"%(senderName)s changed a rule that was banning servers matching %(oldGlob)s to matching " +
|
|
"%(newGlob)s for %(reason)s",
|
|
{ senderName, oldGlob: prevEntity, newGlob: entity, reason },
|
|
);
|
|
}
|
|
|
|
// Unknown type. We'll say something but we shouldn't end up here.
|
|
return () => _t("%(senderName)s updated a ban rule that was matching %(oldGlob)s to matching %(newGlob)s " +
|
|
"for %(reason)s", { senderName, oldGlob: prevEntity, newGlob: entity, reason });
|
|
}
|
|
|
|
interface IHandlers {
|
|
[type: string]:
|
|
(ev: MatrixEvent, allowJSX: boolean, showHiddenEvents?: boolean) =>
|
|
(() => string | JSX.Element | null);
|
|
}
|
|
|
|
const handlers: IHandlers = {
|
|
'm.room.message': textForMessageEvent,
|
|
'm.call.invite': textForCallInviteEvent,
|
|
};
|
|
|
|
const stateHandlers: IHandlers = {
|
|
'm.room.canonical_alias': textForCanonicalAliasEvent,
|
|
'm.room.name': textForRoomNameEvent,
|
|
'm.room.topic': textForTopicEvent,
|
|
'm.room.member': textForMemberEvent,
|
|
'm.room.third_party_invite': textForThreePidInviteEvent,
|
|
'm.room.history_visibility': textForHistoryVisibilityEvent,
|
|
'm.room.power_levels': textForPowerEvent,
|
|
'm.room.pinned_events': textForPinnedEvent,
|
|
'm.room.server_acl': textForServerACLEvent,
|
|
'm.room.tombstone': textForTombstoneEvent,
|
|
'm.room.join_rules': textForJoinRulesEvent,
|
|
'm.room.guest_access': textForGuestAccessEvent,
|
|
'm.room.related_groups': textForRelatedGroupsEvent,
|
|
|
|
// TODO: Enable support for m.widget event type (https://github.com/vector-im/element-web/issues/13111)
|
|
'im.vector.modular.widgets': textForWidgetEvent,
|
|
[WIDGET_LAYOUT_EVENT_TYPE]: textForWidgetLayoutEvent,
|
|
};
|
|
|
|
// Add all the Mjolnir stuff to the renderer
|
|
for (const evType of ALL_RULE_TYPES) {
|
|
stateHandlers[evType] = textForMjolnirEvent;
|
|
}
|
|
|
|
/**
|
|
* Determines whether the given event has text to display.
|
|
* @param ev The event
|
|
* @param showHiddenEvents An optional cached setting value for showHiddenEventsInTimeline
|
|
* to avoid hitting the settings store
|
|
*/
|
|
export function hasText(ev: MatrixEvent, showHiddenEvents?: boolean): boolean {
|
|
const handler = (ev.isState() ? stateHandlers : handlers)[ev.getType()];
|
|
return Boolean(handler?.(ev, false, showHiddenEvents));
|
|
}
|
|
|
|
/**
|
|
* Gets the textual content of the given event.
|
|
* @param ev The event
|
|
* @param allowJSX Whether to output rich JSX content
|
|
* @param showHiddenEvents An optional cached setting value for showHiddenEventsInTimeline
|
|
* to avoid hitting the settings store
|
|
*/
|
|
export function textForEvent(ev: MatrixEvent): string;
|
|
export function textForEvent(ev: MatrixEvent, allowJSX: true, showHiddenEvents?: boolean): string | JSX.Element;
|
|
export function textForEvent(ev: MatrixEvent, allowJSX = false, showHiddenEvents?: boolean): string | JSX.Element {
|
|
const handler = (ev.isState() ? stateHandlers : handlers)[ev.getType()];
|
|
return handler?.(ev, allowJSX, showHiddenEvents)?.() || '';
|
|
}
|