Add backup support for polls

Author: yash-signal

.github/workflows/ci.yml

@@ -234,7 +234,7 @@ jobs:
       uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
       with:
         repository: 'signalapp/Signal-Message-Backup-Tests'
-        ref: 'ae41153c5ac776b138b778b82fa593be23b3a14c'
+        ref: '455fbe5854bd3be5002f17ae929a898c0975adc4'
         path: 'backup-integration-tests'
 
     - run: xvfb-run --auto-servernum pnpm run test-electron

protos/Backups.proto

@@ -428,6 +428,7 @@ message ChatItem {
     GiftBadge giftBadge = 17;
     ViewOnceMessage viewOnceMessage = 18;
     DirectStoryReplyMessage directStoryReplyMessage = 19; // group story reply messages are not backed up
+    Poll poll = 20;
   }
 }
 
@@ -760,6 +761,7 @@ message Quote {
     NORMAL = 1;
     GIFT_BADGE = 2;
     VIEW_ONCE = 3;
+    POLL = 4;
   }
 
   message QuotedAttachment {
@@ -806,6 +808,31 @@ message Reaction {
   uint64 sortOrder = 4;
 }
 
+message Poll {
+
+  message PollOption {
+
+    message PollVote {
+      uint64 voterId = 1; // A direct reference to Recipient proto id. Must be self or contact.
+      uint32 voteCount = 2; // Tracks how many times you voted.
+    }
+
+    string option = 1; // Between 1-100 characters
+    repeated PollVote votes = 2;
+  }
+
+  string question = 1; // Between 1-100 characters
+  bool allowMultiple = 2;
+  repeated PollOption options = 3; // At least two
+  bool hasEnded = 4;
+  repeated Reaction reactions = 5;
+}
+
+message PollTerminateUpdate {
+  uint64 targetSentTimestamp = 1;
+  string question = 2; // Between 1-100 characters
+}
+
 message ChatUpdateMessage {
   // If unset, importers should ignore the update message without throwing an error.
   oneof update {
@@ -818,6 +845,7 @@ message ChatUpdateMessage {
     IndividualCall individualCall = 7;
     GroupCall groupCall = 8;
     LearnedProfileChatUpdate learnedProfileChange = 9;
+    PollTerminateUpdate pollTerminate = 10;
   }
 }
 

ts/model-types.d.ts

@@ -103,6 +103,7 @@ export type QuotedMessageType = {
   // from backup
   id: number | null;
   isGiftBadge?: boolean;
+  isPoll?: boolean;
   isViewOnce: boolean;
   referencedMessageNotFound: boolean;
   text?: string;

ts/services/backups/export.preload.ts

@@ -1499,6 +1499,67 @@ export class BackupExportStream extends Readable {
       });
 
       result.revisions = await this.#toChatItemRevisions(result, message);
+    } else if (message.poll) {
+      const { poll } = message;
+      const pollMessage = new Backups.Poll();
+
+      pollMessage.question = poll.question;
+      pollMessage.allowMultiple = poll.allowMultiple;
+      pollMessage.hasEnded = poll.terminatedAt != null;
+
+      pollMessage.options = poll.options.map((optionText, optionIndex) => {
+        const pollOption = new Backups.Poll.PollOption();
+        pollOption.option = optionText;
+
+        const votesForThisOption = new Map<string, number>();
+
+        if (poll.votes) {
+          for (const vote of poll.votes) {
+            // Skip votes that have not been sent
+            if (vote.sendStateByConversationId) {
+              continue;
+            }
+
+            // If we somehow have multiple votes from the same person
+            // (shouldn't happen, just in case) only keep the highest voteCount
+            const maybeExistingVoteFromThisConversation =
+              votesForThisOption.get(vote.fromConversationId);
+            if (
+              vote.optionIndexes.includes(optionIndex) &&
+              (!maybeExistingVoteFromThisConversation ||
+                vote.voteCount > maybeExistingVoteFromThisConversation)
+            ) {
+              votesForThisOption.set(vote.fromConversationId, vote.voteCount);
+            }
+          }
+        }
+
+        pollOption.votes = Array.from(votesForThisOption.entries()).map(
+          ([conversationId, voteCount]) => {
+            const pollVote = new Backups.Poll.PollOption.PollVote();
+
+            const voterConvo =
+              window.ConversationController.get(conversationId);
+            if (voterConvo) {
+              pollVote.voterId = this.#getOrPushPrivateRecipient(
+                voterConvo.attributes
+              );
+            }
+
+            pollVote.voteCount = voteCount;
+            return pollVote;
+          }
+        );
+
+        return pollOption;
+      });
+
+      const reactions = this.#getMessageReactions(message);
+      if (reactions != null) {
+        pollMessage.reactions = reactions;
+      }
+
+      result.poll = pollMessage;
     } else {
       result.standardMessage = await this.#toStandardMessage({
         message,
@@ -2451,6 +2512,8 @@ export class BackupExportStream extends Readable {
       quoteType = Backups.Quote.Type.GIFT_BADGE;
     } else if (quote.isViewOnce) {
       quoteType = Backups.Quote.Type.VIEW_ONCE;
+    } else if (quote.isPoll) {
+      quoteType = Backups.Quote.Type.POLL;
     } else {
       quoteType = Backups.Quote.Type.NORMAL;
       if (quote.text == null && quote.attachments.length === 0) {

ts/services/backups/import.preload.ts

@@ -180,6 +180,8 @@ type ChatItemParseResult = {
   additionalMessages: Array<Partial<MessageAttributesType>>;
 };
 
+const SKIP = 'SKIP' as const;
+
 function phoneToContactFormType(
   type: Backups.ContactAttachment.Phone.Type | null | undefined
 ): ContactFormType {
@@ -1564,6 +1566,63 @@ export class BackupImportStream extends Writable {
           storyAuthorAci
         ),
       };
+    } else if (item.poll) {
+      const { poll } = item;
+
+      const votesByVoter = new Map<
+        string,
+        {
+          fromConversationId: string;
+          optionIndexes: Array<number>;
+          voteCount: number;
+          timestamp: number;
+        }
+      >();
+
+      poll.options?.forEach((option, optionIndex) => {
+        option.votes?.forEach(vote => {
+          if (!vote.voterId) {
+            return;
+          }
+
+          const conversation = this.#recipientIdToConvo.get(
+            vote.voterId.toNumber()
+          );
+          if (!conversation) {
+            log.warn(`${logId}: Poll vote has unknown voterId ${vote.voterId}`);
+            return;
+          }
+
+          const conversationId = conversation.id;
+
+          let voterRecord = votesByVoter.get(conversationId);
+          if (!voterRecord) {
+            voterRecord = {
+              fromConversationId: conversationId,
+              optionIndexes: [],
+              voteCount: vote.voteCount ?? 1,
+              timestamp,
+            };
+            votesByVoter.set(conversationId, voterRecord);
+          }
+
+          voterRecord.optionIndexes.push(optionIndex);
+        });
+      });
+
+      const votes = Array.from(votesByVoter.values());
+
+      attributes = {
+        ...attributes,
+        poll: {
+          question: poll.question ?? '',
+          options: poll.options?.map(option => option.option ?? '') ?? [],
+          allowMultiple: poll.allowMultiple ?? false,
+          votes: votes.length > 0 ? votes : undefined,
+          terminatedAt: poll.hasEnded ? Number(item.dateSent) : undefined,
+        },
+        reactions: this.#fromReactions(poll.reactions),
+      };
     } else {
       const result = await this.#fromNonBubbleChatItem(item, {
         aboutMe,
@@ -1572,6 +1631,10 @@ export class BackupImportStream extends Writable {
         timestamp,
       });
 
+      if (result === SKIP) {
+        return;
+      }
+
       if (!result) {
         throw new Error(`${logId}: fromNonBubbleChat item returned nothing!`);
       }
@@ -2159,6 +2222,7 @@ export class BackupImportStream extends Writable {
       text: dropNull(quote.text?.body),
       bodyRanges: this.#fromBodyRanges(quote.text),
       isGiftBadge: quote.type === Backups.Quote.Type.GIFT_BADGE,
+      isPoll: quote.type === Backups.Quote.Type.POLL ? true : undefined,
       isViewOnce: quote.type === Backups.Quote.Type.VIEW_ONCE,
       attachments:
         quote.attachments?.map(quotedAttachment => {
@@ -2242,7 +2306,7 @@ export class BackupImportStream extends Writable {
       conversation: ConversationAttributesType;
       timestamp: number;
     }
-  ): Promise<ChatItemParseResult | undefined> {
+  ): Promise<ChatItemParseResult | undefined | typeof SKIP> {
     const { timestamp } = options;
     const logId = `fromChatItemToNonBubble(${timestamp})`;
 
@@ -2477,7 +2541,7 @@ export class BackupImportStream extends Writable {
       conversation: ConversationAttributesType;
       timestamp: number;
     }
-  ): Promise<ChatItemParseResult | undefined> {
+  ): Promise<ChatItemParseResult | undefined | typeof SKIP> {
     const { aboutMe, author, conversation } = options;
 
     if (updateMessage.groupChange) {
@@ -2733,6 +2797,11 @@ export class BackupImportStream extends Writable {
       };
     }
 
+    if (updateMessage.pollTerminate) {
+      log.info('Skipping pollTerminate update (not yet supported)');
+      return SKIP;
+    }
+
     return undefined;
   }