Poll notifications and read syncs

Co-authored-by: yash-signal <[email protected]>

Author: automated-signal

_locales/en/messages.json

@@ -1487,11 +1487,11 @@
     "description": "Accessibility label for checkmark indicating user voted for this poll option"
   },
   "icu:PollTerminate--you": {
-    "messageformat": "You ended the poll: \"{poll}\"",
+    "messageformat": "You ended the poll: {poll}",
     "description": "Chat event shown when you end a poll"
   },
   "icu:PollTerminate--other": {
-    "messageformat": "{name} ended the poll: \"{poll}\"",
+    "messageformat": "{name} ended the poll: {poll}",
     "description": "Chat event shown when someone else ends a poll"
   },
   "icu:PollTerminate__view-poll": {
@@ -2636,6 +2636,10 @@
   "icu:notificationReactionMessage": {
     "messageformat": "{sender} reacted {emoji} to: {message}"
   },
+  "icu:notificationPollVoteMessage": {
+    "messageformat": "{sender} voted in the poll \"{pollQuestion}\"",
+    "description": "Notification text when someone votes in your poll"
+  },
   "icu:sendFailed": {
     "messageformat": "Send failed",
     "description": "Shown on outgoing message if it fails to send"

ts/messageModifiers/Polls.preload.ts

@@ -21,6 +21,8 @@ import { isMe } from '../util/whatTypeOfConversation.dom.js';
 
 import { strictAssert } from '../util/assert.std.js';
 import { getMessageIdForLogging } from '../util/idForLogging.preload.js';
+import { drop } from '../util/drop.std.js';
+import { maybeNotify } from '../messages/maybeNotify.preload.js';
 
 const log = createLogger('Polls');
 
@@ -369,10 +371,11 @@ export async function handlePollVote(
     return;
   }
 
-  const conversation = window.ConversationController.get(
+  const conversationContainingThisPoll = window.ConversationController.get(
     message.attributes.conversationId
   );
-  if (!conversation) {
+  if (!conversationContainingThisPoll) {
+    log.warn('handlePollVote: cannot find conversation containing this poll');
     return;
   }
 
@@ -394,7 +397,7 @@ export async function handlePollVote(
     timestamp: vote.timestamp,
     sendStateByConversationId: isFromThisDevice
       ? Object.fromEntries(
-          Array.from(conversation.getMemberConversationIds())
+          Array.from(conversationContainingThisPoll.getMemberConversationIds())
             .filter(id => id !== ourConversationId)
             .map(id => [
               id,
@@ -456,21 +459,39 @@ export async function handlePollVote(
     }
   }
 
+  // Set hasUnreadPollVotes flag if someone else voted on our poll
+  const shouldMarkAsUnread =
+    isOutgoing(message.attributes) && isFromSomeoneElse;
+
   message.set({
     poll: {
       ...poll,
       votes: updatedVotes,
     },
+    ...(shouldMarkAsUnread ? { hasUnreadPollVotes: true } : {}),
   });
 
   log.info(
     'handlePollVote:',
     `Done processing vote for poll ${getMessageIdForLogging(message.attributes)}.`
   );
 
+  // Notify poll author when someone else votes
+  if (shouldMarkAsUnread) {
+    drop(
+      maybeNotify({
+        pollVote: vote,
+        targetMessage: message.attributes,
+        conversation: conversationContainingThisPoll,
+      })
+    );
+  }
+
   if (shouldPersist) {
     await window.MessageCache.saveMessage(message.attributes);
-    window.reduxActions.conversations.markOpenConversationRead(conversation.id);
+    window.reduxActions.conversations.markOpenConversationRead(
+      conversationContainingThisPoll.id
+    );
   }
 }
 
@@ -507,6 +528,14 @@ export async function handlePollTerminate(
     return;
   }
 
+  const isFromThisDevice = terminate.source === PollSource.FromThisDevice;
+  const isFromSync = terminate.source === PollSource.FromSync;
+  const isFromSomeoneElse = terminate.source === PollSource.FromSomeoneElse;
+  strictAssert(
+    isFromThisDevice || isFromSync || isFromSomeoneElse,
+    'Terminate can only be from this device, from sync, or from someone else'
+  );
+
   // Verify the terminator is the poll creator
   const author = getAuthor(attributes);
   const terminatorConversation = window.ConversationController.get(
@@ -524,8 +553,6 @@ export async function handlePollTerminate(
     return;
   }
 
-  const isFromThisDevice = terminate.source === PollSource.FromThisDevice;
-
   message.set({
     poll: {
       ...poll,

ts/messageModifiers/ReadSyncs.preload.ts

@@ -20,6 +20,8 @@ import { DataReader, DataWriter } from '../sql/Client.preload.js';
 import { markRead } from '../services/MessageUpdater.preload.js';
 import { MessageModel } from '../models/messages.preload.js';
 import { itemStorage } from '../textsecure/Storage.preload.js';
+import { getMessageById } from '../messages/getMessageById.preload.js';
+import { getSourceServiceId } from '../messages/sources.preload.js';
 
 const log = createLogger('ReadSyncs');
 
@@ -52,7 +54,7 @@ async function remove(sync: ReadSyncAttributesType): Promise<void> {
 
 async function maybeItIsAReactionReadSync(
   sync: ReadSyncAttributesType
-): Promise<void> {
+): Promise<boolean> {
   const { readSync } = sync;
   const logId = `ReadSyncs.onSync(timestamp=${readSync.timestamp})`;
 
@@ -71,7 +73,7 @@ async function maybeItIsAReactionReadSync(
       readSync.sender,
       readSync.senderAci
     );
-    return;
+    return false;
   }
 
   log.info(
@@ -82,14 +84,47 @@ async function maybeItIsAReactionReadSync(
     readSync.senderAci
   );
 
-  await remove(sync);
-
   notificationService.removeBy({
     conversationId: readReaction.conversationId,
     emoji: readReaction.emoji,
     targetAuthorAci: readReaction.targetAuthorAci,
     targetTimestamp: readReaction.targetTimestamp,
   });
+
+  return true;
+}
+
+async function maybeItIsAPollVoteReadSync(
+  sync: ReadSyncAttributesType
+): Promise<boolean> {
+  const { readSync } = sync;
+  const logId = `ReadSyncs.onSync(timestamp=${readSync.timestamp})`;
+
+  const pollMessage = await DataWriter.markPollVoteAsRead(readSync.timestamp);
+
+  if (!pollMessage) {
+    log.info(`${logId} poll vote read sync not found`);
+    return false;
+  }
+
+  const pollMessageModel = await getMessageById(pollMessage.id);
+  if (!pollMessageModel) {
+    log.warn(
+      `${logId} found message for poll, but could not get the message model`
+    );
+    return false;
+  }
+  pollMessageModel.set({ hasUnreadPollVotes: false });
+  drop(queueUpdateMessage(pollMessageModel.attributes));
+
+  notificationService.removeBy({
+    conversationId: pollMessage.conversationId,
+    targetAuthorAci: getSourceServiceId(pollMessageModel.attributes),
+    targetTimestamp: pollMessage.sent_at,
+    onlyRemoveAssociatedPollVotes: true,
+  });
+
+  return true;
 }
 
 export async function forMessage(
@@ -145,7 +180,13 @@ export async function onSync(sync: ReadSyncAttributesType): Promise<void> {
     });
 
     if (!found) {
-      await maybeItIsAReactionReadSync(sync);
+      const foundReaction = await maybeItIsAReactionReadSync(sync);
+
+      const foundPollVote = await maybeItIsAPollVoteReadSync(sync);
+
+      if (foundReaction || foundPollVote) {
+        await remove(sync);
+      }
       return;
     }
 

ts/messages/maybeNotify.preload.ts

@@ -3,7 +3,7 @@
 
 import { createLogger } from '../logging/log.std.js';
 
-import { isIncoming, isOutgoing } from './helpers.std.js';
+import { isOutgoing } from './helpers.std.js';
 import { getAuthor } from './sources.preload.js';
 
 import type { ConversationModel } from '../models/conversations.preload.js';
@@ -17,6 +17,10 @@ import { notificationService } from '../services/notifications.preload.js';
 import { getNotificationTextForMessage } from '../util/getNotificationTextForMessage.preload.js';
 import type { MessageAttributesType } from '../model-types.d.ts';
 import type { ReactionAttributesType } from '../messageModifiers/Reactions.preload.js';
+import {
+  type PollVoteAttributesType,
+  PollSource,
+} from '../messageModifiers/Polls.preload.js';
 import { shouldStoryReplyNotifyUser } from '../util/shouldStoryReplyNotifyUser.preload.js';
 import { ReactionSource } from '../reactions/ReactionSource.std.js';
 
@@ -29,24 +33,53 @@ type MaybeNotifyArgs = {
       reaction: Readonly<ReactionAttributesType>;
       targetMessage: Readonly<MessageAttributesType>;
     }
-  | { message: Readonly<MessageAttributesType>; reaction?: never }
+  | {
+      pollVote: Readonly<PollVoteAttributesType>;
+      targetMessage: Readonly<MessageAttributesType>;
+    }
+  | {
+      message: Readonly<MessageAttributesType>;
+      reaction?: never;
+      pollVote?: never;
+    }
 );
 
+function isMention(args: MaybeNotifyArgs): boolean {
+  if ('reaction' in args || 'pollVote' in args) {
+    return false;
+  }
+  return Boolean(args.message.mentionsMe);
+}
+
 export async function maybeNotify(args: MaybeNotifyArgs): Promise<void> {
   if (!notificationService.isEnabled) {
     return;
   }
 
   const { i18n } = window.SignalContext;
 
-  const { conversation, reaction } = args;
+  const { conversation } = args;
+  const reaction = 'reaction' in args ? args.reaction : undefined;
+  const pollVote = 'pollVote' in args ? args.pollVote : undefined;
 
   let warrantsNotification: boolean;
-  if (reaction) {
-    warrantsNotification = doesReactionWarrantNotification(args);
+  if ('reaction' in args && 'targetMessage' in args) {
+    warrantsNotification = doesReactionWarrantNotification({
+      reaction: args.reaction,
+      targetMessage: args.targetMessage,
+    });
+  } else if ('pollVote' in args && 'targetMessage' in args) {
+    warrantsNotification = doesPollVoteWarrantNotification({
+      pollVote: args.pollVote,
+      targetMessage: args.targetMessage,
+    });
   } else {
-    warrantsNotification = await doesMessageWarrantNotification(args);
+    warrantsNotification = await doesMessageWarrantNotification({
+      message: args.message,
+      conversation,
+    });
   }
+
   if (!warrantsNotification) {
     return;
   }
@@ -56,29 +89,34 @@ export async function maybeNotify(args: MaybeNotifyArgs): Promise<void> {
   }
 
   const activeProfile = getActiveProfile(window.reduxStore.getState());
+
   if (
     !shouldNotifyDuringNotificationProfile({
       activeProfile,
       conversationId: conversation.id,
       isCall: false,
-      isMention: args.reaction ? false : Boolean(args.message.mentionsMe),
+      isMention: isMention(args),
     })
   ) {
     log.info('Would notify for message, but notification profile prevented it');
     return;
   }
 
   const conversationId = conversation.get('id');
-  const messageForNotification = args.reaction
-    ? args.targetMessage
-    : args.message;
+  const messageForNotification =
+    'targetMessage' in args ? args.targetMessage : args.message;
   const isMessageInDirectConversation = isDirectConversation(
     conversation.attributes
   );
 
-  const sender = reaction
-    ? window.ConversationController.get(reaction.fromId)
-    : getAuthor(args.message);
+  let sender: ConversationModel | undefined;
+  if (reaction) {
+    sender = window.ConversationController.get(reaction.fromId);
+  } else if (pollVote) {
+    sender = window.ConversationController.get(pollVote.fromConversationId);
+  } else if ('message' in args) {
+    sender = getAuthor(args.message);
+  }
   const senderName = sender ? sender.getTitle() : i18n('icu:unknownContact');
   const senderTitle = isMessageInDirectConversation
     ? senderName
@@ -110,6 +148,13 @@ export async function maybeNotify(args: MaybeNotifyArgs): Promise<void> {
           targetTimestamp: reaction.targetTimestamp,
         }
       : undefined,
+    pollVote: pollVote
+      ? {
+          voterConversationId: pollVote.fromConversationId,
+          targetAuthorAci: pollVote.targetAuthorAci,
+          targetTimestamp: pollVote.targetTimestamp,
+        }
+      : undefined,
     sentAt: messageForNotification.timestamp,
     type: reaction ? NotificationType.Reaction : NotificationType.Message,
   });
@@ -128,14 +173,26 @@ function doesReactionWarrantNotification({
   );
 }
 
+function doesPollVoteWarrantNotification({
+  pollVote,
+  targetMessage,
+}: {
+  targetMessage: MessageAttributesType;
+  pollVote: PollVoteAttributesType;
+}): boolean {
+  return (
+    pollVote.source === PollSource.FromSomeoneElse && isOutgoing(targetMessage)
+  );
+}
+
 async function doesMessageWarrantNotification({
   message,
   conversation,
 }: {
   message: MessageAttributesType;
   conversation: ConversationModel;
 }): Promise<boolean> {
-  if (!isIncoming(message)) {
+  if (!(message.type === 'incoming' || message.type === 'poll-terminate')) {
     return false;
   }
 
@@ -154,19 +211,15 @@ async function doesMessageWarrantNotification({
 }
 
 function isAllowedByConversation(args: MaybeNotifyArgs): boolean {
-  const { conversation, reaction } = args;
+  const { conversation } = args;
 
   if (!conversation.isMuted()) {
     return true;
   }
 
-  if (reaction) {
-    return false;
-  }
-
   if (conversation.get('dontNotifyForMentionsIfMuted')) {
     return false;
   }
 
-  return args.message.mentionsMe === true;
+  return isMention(args);
 }