[web] Disable thick thread entries from showing up in the history modal as history entries
ClosedPublic
Actions

Authored by will on Sep 16 2024, 1:20 PM.

Details

Reviewers

ashoat
tomek
marcin

Commits

rCOMM6348d732c201: [web] Disable thick thread entries from showing up in the history modal as…

Summary

This disables thick thread entries from showing up in the history modal

Depends on D13350

Test Plan

Tested on local webapp. Keyserver history entries still showed up fine but thick thread entries did not

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Sep 16 2024, 1:20 PM

ashoat published this revision for review.Sep 16 2024, 1:23 PM

ashoat added inline comments.

web/modals/history/history-modal.react.js
116–117 ↗	(On Diff #44235)	Shorthand

Before landing, can you create a follow-up task to create a flag that can gate both this and D13349?

This revision is now accepted and ready to land.Sep 16 2024, 1:23 PM

Harbormaster completed remote builds in B31647: Diff 44235.Sep 16 2024, 1:37 PM

final rebase

Harbormaster completed remote builds in B31655: Diff 44243.Sep 16 2024, 2:25 PM

Closed by commit rCOMM6348d732c201: [web] Disable thick thread entries from showing up in the history modal as… (authored by will). · Explain WhySep 16 2024, 2:27 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM6348d732c201: [web] Disable thick thread entries from showing up in the history modal as….

@will created a follow-up task, but didn't document it here. Here it is: https://linear.app/comm/issue/ENG-9302/create-a-flag-for-enabling-history-on-thick-threaded-entries

Revision Contents
Changeset List

Path

Size

web/

modals/

history/

history-modal.react.js

10 lines

Diff 44257

View Options

web/modals/history/history-modal.react.js

This file was added.

				// @flow

				import invariant from 'invariant';
				import t, { type TInterface } from 'tcomb';

				import {
				type CommonNativeNotifInputData,
				commonNativeNotifInputDataValidator,
				} from './android-notif-creators.js';
				import {
				prepareEncryptedAPNsVisualNotifications,
				prepareEncryptedAPNsSilentNotifications,
				} from './crypto.js';
				import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
				import {
				hasMinCodeVersion,
				FUTURE_CODE_VERSION,
				} from '../shared/version-utils.js';
				import type { PlatformDetails } from '../types/device-types.js';
				import { messageTypes } from '../types/message-types-enum.js';
				import {
				type NotificationTargetDevice,
				type EncryptedNotifUtilsAPI,
				type TargetedAPNsNotification,
				type APNsVisualNotification,
				type APNsNotificationHeaders,
				type SenderDeviceDescriptor,
				} from '../types/notif-types.js';
				import { tShape } from '../utils/validation-utils.js';

				export const apnMaxNotificationPayloadByteSize = 4096;

				export type APNsNotifInputData = {
				...CommonNativeNotifInputData,
				+badgeOnly: boolean,
				+uniqueID: string,
				};

				export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
				tShape<APNsNotifInputData>({
				...commonNativeNotifInputDataValidator.meta.props,
				badgeOnly: t.Boolean,
				uniqueID: t.String,
				});

				async function createAPNsVisualNotification(
				encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
				inputData: APNsNotifInputData,
				devices: $ReadOnlyArray<NotificationTargetDevice>,
				): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
				const {
				senderDeviceDescriptor,
				notifTexts,
				newRawMessageInfos,
				threadID,
				collapseKey,
				badgeOnly,
				unreadCount,
				platformDetails,
				uniqueID,
				} = inputData;

				const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
				platformDetails,
				{ native: 222 },
				);

				const isNonCollapsibleTextNotification =
				newRawMessageInfos.every(
				newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
				) && !collapseKey;

				const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
				native: 267,
				});

				const canDecryptIOSNotif =
				platformDetails.platform === 'ios' &&
				(canDecryptAllIOSNotifs \|\|
				(isNonCollapsibleTextNotification &&
				canDecryptNonCollapsibleTextIOSNotifs));

				const canDecryptMacOSNotifs =
				platformDetails.platform === 'macos' &&
				hasMinCodeVersion(platformDetails, {
				web: 47,
				majorDesktop: 9,
				});

				let apsDictionary = {
				'thread-id': threadID,
				};
				if (unreadCount !== undefined && unreadCount !== null) {
				apsDictionary = {
				...apsDictionary,
				badge: unreadCount,
				};
				}

				const { merged, ...rest } = notifTexts;
				// We don't include alert's body on macos because we
				// handle displaying the notification ourselves and
				// we don't want macOS to display it automatically.
				if (!badgeOnly && platformDetails.platform !== 'macos') {
				apsDictionary = {
				...apsDictionary,
				alert: merged,
				sound: 'default',
				};
				}

				if (hasMinCodeVersion(platformDetails, { native: 198 })) {
				apsDictionary = {
				...apsDictionary,
				'mutable-content': 1,
				};
				}

				let notificationPayload = {
				...rest,
				id: uniqueID,
				threadID,
				};

				let notificationHeaders: APNsNotificationHeaders = {
				'apns-topic': getAPNsNotificationTopic(platformDetails),
				'apns-id': uniqueID,
				'apns-push-type': 'alert',
				};

				if (collapseKey && (canDecryptAllIOSNotifs \|\| canDecryptMacOSNotifs)) {
				notificationPayload = {
				...notificationPayload,
				collapseID: collapseKey,
				};
				} else if (collapseKey) {
				notificationHeaders = {
				...notificationHeaders,
				'apns-collapse-id': collapseKey,
				};
				}

				const notification = {
				...notificationPayload,
				headers: notificationHeaders,
				aps: apsDictionary,
				};

				const messageInfos = JSON.stringify(newRawMessageInfos);
				const copyWithMessageInfos = {
				...notification,
				messageInfos,
				};

				const notificationSizeValidator = (notif: APNsVisualNotification) => {
				const { headers, ...notifSansHeaders } = notif;
				return (
				encryptedNotifUtilsAPI.getNotifByteSize(
				JSON.stringify(notifSansHeaders),
				) <= apnMaxNotificationPayloadByteSize
				);
				};

				const serializeAPNsNotif = (notif: APNsVisualNotification) => {
				const { headers, ...notifSansHeaders } = notif;
				return JSON.stringify(notifSansHeaders);
				};

				const shouldBeEncrypted = canDecryptIOSNotif \|\| canDecryptMacOSNotifs;
				if (!shouldBeEncrypted) {
				const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
				? copyWithMessageInfos
				: notification;
				return devices.map(({ deliveryID }) => ({
				notification: notificationToSend,
				deliveryID,
				}));
				}

				// The `messageInfos` field in notification payload is
				// not used on MacOS so we can return early.
				if (platformDetails.platform === 'macos') {
				const macOSNotifsWithoutMessageInfos =
				await prepareEncryptedAPNsVisualNotifications(
				encryptedNotifUtilsAPI,
				senderDeviceDescriptor,
				devices,
				notification,
				platformDetails.codeVersion,
				);
				return macOSNotifsWithoutMessageInfos.map(
				({ notification: notif, deliveryID }) => ({
				notification: notif,
				deliveryID,
				}),
				);
				}

				const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
				encryptedNotifUtilsAPI,
				senderDeviceDescriptor,
				devices,
				copyWithMessageInfos,
				platformDetails.codeVersion,
				notificationSizeValidator,
				);

				const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
				.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
				.map(({ cryptoID, deliveryID }) => ({
				cryptoID,
				deliveryID,
				}));

				if (devicesWithExcessiveSizeNoHolders.length === 0) {
				return notifsWithMessageInfos.map(
				({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}) => ({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}),
				);
				}

				const canQueryBlobService = hasMinCodeVersion(platformDetails, {
				native: 331,
				});

				let blobHash, blobHolders, encryptionKey, blobUploadError;
				if (canQueryBlobService) {
				({ blobHash, blobHolders, encryptionKey, blobUploadError } =
				await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
				serializeAPNsNotif(copyWithMessageInfos),
				devicesWithExcessiveSizeNoHolders.length,
				));
				}

				if (blobUploadError) {
				console.warn(
				`Failed to upload payload of notification: ${uniqueID} ` +
				`due to error: ${blobUploadError}`,
				);
				}

				let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
				let notificationWithBlobMetadata = notification;
				if (
				blobHash &&
				encryptionKey &&
				blobHolders &&
				blobHolders.length === devicesWithExcessiveSize.length
				) {
				notificationWithBlobMetadata = {
				...notification,
				blobHash,
				encryptionKey,
				};
				devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
				...devicesWithExcessiveSize[idx],
				blobHolder: holder,
				}));
				}

				const notifsWithoutMessageInfos =
				await prepareEncryptedAPNsVisualNotifications(
				encryptedNotifUtilsAPI,
				senderDeviceDescriptor,
				devicesWithExcessiveSize,
				notificationWithBlobMetadata,
				platformDetails.codeVersion,
				);

				const targetedNotifsWithMessageInfos = notifsWithMessageInfos
				.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
				.map(
				({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}) => ({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}),
				);

				const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
				({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}) => ({
				notification: notif,
				deliveryID,
				encryptedPayloadHash,
				encryptionOrder,
				}),
				);

				return [
				...targetedNotifsWithMessageInfos,
				...targetedNotifsWithoutMessageInfos,
				];
				}

				type APNsNotificationRescindInputData = {
				+senderDeviceDescriptor: SenderDeviceDescriptor,
				+rescindID?: string,
				+badge?: number,
				+threadID: string,
				+platformDetails: PlatformDetails,
				};

				async function createAPNsNotificationRescind(
				encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
				inputData: APNsNotificationRescindInputData,
				devices: $ReadOnlyArray<NotificationTargetDevice>,
				): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
				const {
				badge,
				rescindID,
				threadID,
				platformDetails,
				senderDeviceDescriptor,
				} = inputData;

				invariant(
				(rescindID && badge !== null && badge !== undefined) \|\|
				hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
				'thick thread rescind not support for this client version',
				);

				const apnsTopic = getAPNsNotificationTopic(platformDetails);
				let notification;

				if (
				rescindID &&
				badge !== null &&
				badge !== undefined &&
				hasMinCodeVersion(platformDetails, { native: 198 })
				) {
				notification = {
				headers: {
				'apns-topic': apnsTopic,
				'apns-push-type': 'alert',
				},
				aps: {
				'mutable-content': 1,
				'badge': badge,
				},
				threadID,
				notificationId: rescindID,
				backgroundNotifType: 'CLEAR',
				setUnreadStatus: true,
				};
				} else if (rescindID && badge !== null && badge !== undefined) {
				notification = {
				headers: {
				'apns-topic': apnsTopic,
				'apns-push-type': 'background',
				'apns-priority': 5,
				},
				aps: {
				'mutable-content': 1,
				'badge': badge,
				},
				threadID,
				notificationId: rescindID,
				backgroundNotifType: 'CLEAR',
				setUnreadStatus: true,
				};
				} else {
				notification = {
				headers: {
				'apns-topic': apnsTopic,
				'apns-push-type': 'alert',
				},
				aps: {
				'mutable-content': 1,
				},
				threadID,
				backgroundNotifType: 'CLEAR',
				setUnreadStatus: true,
				};
				}

				const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
				if (!shouldBeEncrypted) {
				return devices.map(({ deliveryID }) => ({
				notification,
				deliveryID,
				}));
				}

				const notifications = await prepareEncryptedAPNsSilentNotifications(
				encryptedNotifUtilsAPI,
				senderDeviceDescriptor,
				devices,
				notification,
				platformDetails.codeVersion,
				);

				return notifications.map(({ deliveryID, notification: notif }) => ({
				deliveryID,
				notification: notif,
				}));
				}

				type APNsBadgeOnlyNotificationInputData = {
				+senderDeviceDescriptor: SenderDeviceDescriptor,
				+badge?: number,
				+threadID?: string,
				+platformDetails: PlatformDetails,
				};

				async function createAPNsBadgeOnlyNotification(
				encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
				inputData: APNsBadgeOnlyNotificationInputData,
				devices: $ReadOnlyArray<NotificationTargetDevice>,
				): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
				const { senderDeviceDescriptor, platformDetails, threadID, badge } =
				inputData;
				invariant(
				(!threadID && badge !== undefined && badge !== null) \|\|
				hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
				'thick thread badge updates not support for this client version',
				);

				const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
				native: 222,
				web: 47,
				majorDesktop: 9,
				});

				const headers: APNsNotificationHeaders = {
				'apns-topic': getAPNsNotificationTopic(platformDetails),
				'apns-push-type': 'alert',
				};

				let notification;
				if (shouldBeEncrypted && threadID) {
				notification = {
				headers,
				threadID,
				aps: {
				'mutable-content': 1,
				},
				};
				} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
				notification = {
				headers,
				aps: {
				'badge': badge,
				'mutable-content': 1,
				},
				};
				} else {
				invariant(
				badge !== null && badge !== undefined,
				'badge update must contain either badge count or threadID',
				);
				notification = {
				headers,
				aps: {
				badge,
				},
				};
				}

				if (!shouldBeEncrypted) {
				return devices.map(({ deliveryID }) => ({
				deliveryID,
				notification,
				}));
				}

				const notifications = await prepareEncryptedAPNsSilentNotifications(
				encryptedNotifUtilsAPI,
				senderDeviceDescriptor,
				devices,
				notification,
				platformDetails.codeVersion,
				);

				return notifications.map(({ deliveryID, notification: notif }) => ({
				deliveryID,
				notification: notif,
				}));
				}

				export {
				createAPNsBadgeOnlyNotification,
				createAPNsNotificationRescind,
				createAPNsVisualNotification,
				};

[web] Disable thick thread entries from showing up in the history modal as history entriesClosedPublicActions