[web] disable history button on web on clicking entry
ClosedPublic
Actions

Authored by will on Sep 16 2024, 1:34 AM.

Details

Reviewers

tomek
ashoat
marcin

Commits

rCOMM7b68beb6c9d3: [web] disable history button on web on clicking entry

Summary

This disables the history button when clicking a given entry if thick threaded on web. Disabling the history button for a day box will be introduced in a separate diff

Depends on D13348

Test Plan

Checked on local web app. history button no longer appears

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Sep 16 2024, 1:34 AM

will added a child revision: D13350: [native][web] use tunnelbroker for online status of thick threaded entries instead of keyserver.

Harbormaster completed remote builds in B31631: Diff 44203.Sep 16 2024, 2:14 AM

will requested review of this revision.Sep 16 2024, 2:14 AM

Let's document this somewhere. Also, it might be a good idea to introduce a single flag for it.

This revision is now accepted and ready to land.Sep 16 2024, 5:50 AM

Where would we document? Maybe @tomek was thinking of something like a function function isCalendarEntryHistoryEnabled(threadType: ThreadType): boolean

ashoat mentioned this in D13354: [web] Disable thick thread entries from showing up in the history modal as history entries.Sep 16 2024, 1:23 PM

Closed by commit rCOMM7b68beb6c9d3: [web] disable history button on web on clicking entry (authored by will). · Explain WhySep 16 2024, 2:27 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM7b68beb6c9d3: [web] disable history button on web on clicking entry.

In D13349#376126, @ashoat wrote:

Where would we document? Maybe @tomek was thinking of something like a function function isCalendarEntryHistoryEnabled(threadType: ThreadType): boolean

Ah, I should've added more details. I was thinking about creating a task that tracks introducing the history of thick thread entries and removing a flag (or a function).

Revision Contents
Changeset List

Path

Size

web/

calendar/

entry.react.js

5 lines

Diff 44255

View Options

web/calendar/entry.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 history button on web on clicking entryClosedPublicActions