trigger download for past messages when trusting contact

_locales/en/messages.json

@@ -407,5 +407,8 @@
   "playAtCustomSpeed": "Play at $multipler$x speed",
   "linkVisitWarningTitle": "Open this link in your browser?",
   "linkVisitWarningMessage": "Are you sure you want to open $url$ in your browser?",
-  "open": "Open"
+  "open": "Open",
+  "clickToTrustContact": "Tap to download media",
+  "trustThisContactDialogTitle": "Trust $name$?",
+  "trustThisContactDialogDescription": "Are you sure you want to download media sent by $name$?"
 }

test/models/messages_test.js

@@ -57,27 +57,27 @@ describe('MessageCollection', () => {
     assert(firstTimestamp < secondTimestamp);
   });
 
-  it('checks if is incoming message', () => {
+  // it('checks if is incoming message', () => {
-    const messages = new window.models.Message.MessageCollection();
+  //   const messages = new window.models.Message.MessageCollection();
-    let message = messages.add(attributes);
+  //   let message = messages.add(attributes);
-    assert.notOk(message.isIncoming());
+  //   assert.notOk(message.isIncoming());
-    message = messages.add({
+  //   message = messages.add({
-      type: 'incoming',
+  //     type: 'incoming',
-      conversationId: 'conversationId',
+  //     conversationId: 'conversationId',
-    });
+  //   });
-    assert.ok(message.isIncoming());
+  //   assert.ok(message.isIncoming());
-  });
+  // });
-
+
-  it('checks if is outgoing message', () => {
+  // it('checks if is outgoing message', () => {
-    const messages = new window.models.Message.MessageCollection();
+  //   const messages = new window.models.Message.MessageCollection();
-    let message = messages.add(attributes);
+  //   let message = messages.add(attributes);
-    assert.ok(message.isOutgoing());
+  //   assert.ok(message.isOutgoing());
-    message = messages.add({
+  //   message = messages.add({
-      type: 'incoming',
+  //     type: 'incoming',
-      conversationId: 'conversationId',
+  //     conversationId: 'conversationId',
-    });
+  //   });
-    assert.notOk(message.isOutgoing());
+  //   assert.notOk(message.isOutgoing());
-  });
+  // });
 
   it('checks if is group update', () => {
     const messages = new window.models.Message.MessageCollection();

ts/components/conversation/Message.tsx

@@ -41,6 +41,7 @@ import { updateUserDetailsModal } from '../../state/ducks/modalDialog';
 import { MessageInteraction } from '../../interactions';
 import autoBind from 'auto-bind';
 import { AudioPlayerWithEncryptedFile } from './H5AudioPlayer';
+import { ClickToTrustSender } from './message/ClickToTrustSender';
 
 // Same as MIN_WIDTH in ImageGrid.tsx
 const MINIMUM_LINK_PREVIEW_IMAGE_WIDTH = 200;
@@ -146,6 +147,7 @@ class MessageInner extends React.PureComponent<MessageRegularProps, State> {
       onClickAttachment,
       multiSelectMode,
       onSelectMessage,
+      isTrustedForAttachmentDownload,
     } = this.props;
     const { imageBroken } = this.state;
 
@@ -160,6 +162,10 @@ class MessageInner extends React.PureComponent<MessageRegularProps, State> {
       Boolean(quote) || (conversationType === 'group' && direction === 'incoming');
     const displayImage = canDisplayImage(attachments);
 
+    if (!isTrustedForAttachmentDownload) {
+      return <ClickToTrustSender messageId={id} />;
+    }
+
     if (
       displayImage &&
       !imageBroken &&

ts/components/conversation/message/ClickToTrustSender.tsx

@@ -0,0 +1,83 @@
+import React from 'react';
+import styled from 'styled-components';
+import { getMessageById, getMessagesByConversation } from '../../../data/data';
+import { ConversationController } from '../../../session/conversations';
+import { AttachmentDownloads } from '../../../session/utils';
+import { updateConfirmModal } from '../../../state/ducks/modalDialog';
+import { SessionIcon, SessionIconSize, SessionIconType } from '../../session/icon';
+import { SessionButtonColor } from '../../session/SessionButton';
+
+const StyledTrustSenderUI = styled.div`
+  padding: '${props => props.theme.common.margins.md}px';
+  display: flex;
+  align-items: center;
+`;
+
+const ClickToDownload = styled.div`
+  padding: ${props => props.theme.common.margins.xs} ${props => props.theme.common.margins.md};
+`;
+
+export const ClickToTrustSender = (props: { messageId: string }) => {
+  const openConfirmationModal = async (e: any) => {
+    e.stopPropagation();
+    e.preventDefault();
+    const found = await getMessageById(props.messageId);
+    if (!found) {
+      window.log.warn('message not found ClickToTrustSender');
+      return;
+    }
+    const sender = found.getSource();
+    const convo = ConversationController.getInstance().get(sender);
+    window.inboxStore?.dispatch(
+      updateConfirmModal({
+        title: window.i18n(
+          'trustThisContactDialogTitle',
+          convo.getContactProfileNameOrShortenedPubKey()
+        ),
+        message: window.i18n(
+          'trustThisContactDialogDescription',
+          convo.getContactProfileNameOrShortenedPubKey()
+        ),
+        okTheme: SessionButtonColor.Green,
+        onClickOk: async () => {
+          convo.set({ isTrustedForAttachmentDownload: true });
+          await convo.commit();
+          const messagesInConvo = await getMessagesByConversation(convo.id, {
+            limit: 100,
+          });
+
+          await Promise.all(
+            messagesInConvo.map(async message => {
+              const msgAttachments = message.get('attachments');
+              if (!msgAttachments || msgAttachments.length === 0) {
+                return;
+              }
+
+              const downloadedAttachments = await Promise.all(
+                msgAttachments.map(async (attachment: any, index: any) => {
+                  return AttachmentDownloads.addJob(attachment, {
+                    messageId: message.id,
+                    type: 'attachment',
+                    index,
+                    isOpenGroupV2: false,
+                    openGroupV2Details: undefined,
+                  });
+                })
+              );
+
+              message.set({ attachments: downloadedAttachments });
+              await message.commit();
+            })
+          );
+        },
+      })
+    );
+  };
+
+  return (
+    <StyledTrustSenderUI onClick={openConfirmationModal}>
+      <SessionIcon iconSize={SessionIconSize.Small} iconType={SessionIconType.Gallery} />
+      <ClickToDownload>{window.i18n('clickToTrustContact')}</ClickToDownload>
+    </StyledTrustSenderUI>
+  );
+};

ts/models/conversation.ts

@@ -94,6 +94,7 @@ export interface ConversationAttributes {
   profileKey?: string;
   accessKey?: any;
   triggerNotificationsFor: ConversationNotificationSettingType;
+  isTrustedForAttachmentDownload: boolean;
 }
 
 export interface ConversationAttributesOptionals {
@@ -130,6 +131,7 @@ export interface ConversationAttributesOptionals {
   profileKey?: string;
   accessKey?: any;
   triggerNotificationsFor?: ConversationNotificationSettingType;
+  isTrustedForAttachmentDownload?: boolean;
 }
 
 /**
@@ -158,6 +160,7 @@ export const fillConvoAttributesWithDefaults = (
     mentionedUs: false,
     active_at: 0,
     triggerNotificationsFor: 'all', // if the settings is not set in the db, this is the default
+    isTrustedForAttachmentDownload: false, // we don't trust a contact until we say so
   });
 };
 

ts/models/message.ts

@@ -34,6 +34,7 @@ import {
 import { acceptOpenGroupInvitation } from '../interactions/messageInteractions';
 import { OpenGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/OpenGroupVisibleMessage';
 import { getV2OpenGroupRoom } from '../data/opengroups';
+import { isUsFromCache } from '../session/utils/User';
 
 export class MessageModel extends Backbone.Model<MessageAttributes> {
   public propsForTimerNotification: any;
@@ -522,6 +523,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
     const isPublicOpenGroupV2 = isOpenGroupV2(this.getConversation()?.id || '');
 
     const attachments = this.get('attachments') || [];
+    const isTrustedForAttachmentDownload = this.isTrustedForAttachmentDownload();
 
     return {
       text: this.createNonBreakingLastSeparator(this.get('body')),
@@ -547,6 +549,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
       isPublic,
       isOpenGroupV2: isPublicOpenGroupV2,
       isKickedFromGroup: conversation && conversation.get('isKickedFromGroup'),
+      isTrustedForAttachmentDownload,
 
       onRetrySend: this.retrySend,
       markRead: this.markRead,
@@ -1114,6 +1117,20 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
       });
     }
   }
+
+  public isTrustedForAttachmentDownload() {
+    const convoId = this.getSource();
+    if (!!this.get('isPublic') || isUsFromCache(convoId)) {
+      return true;
+    }
+    // check the convo from this user
+    // we want the convo of the sender of this message
+    const senderConvo = ConversationController.getInstance().get(convoId);
+    if (!senderConvo) {
+      return false;
+    }
+    return senderConvo.get('isTrustedForAttachmentDownload') || false;
+  }
 }
 export class MessageCollection extends Backbone.Collection<MessageModel> {}
 

ts/models/messageType.ts

@@ -241,6 +241,7 @@ export interface MessageRegularProps {
   firstMessageOfSeries: boolean;
   isUnread: boolean;
   isQuotedMessageToAnimate?: boolean;
+  isTrustedForAttachmentDownload: boolean;
 
   onClickAttachment?: (attachment: AttachmentType) => void;
   onClickLinkPreview?: (url: string) => void;

ts/receiver/attachments.ts

@@ -136,22 +136,27 @@ async function processNormalAttachments(
   convo: ConversationModel
 ): Promise<number> {
   const isOpenGroupV2 = convo.isOpenGroupV2();
-  const openGroupV2Details = (isOpenGroupV2 && convo.toOpenGroupV2()) || undefined;
-  const attachments = await Promise.all(
-    normalAttachments.map(async (attachment: any, index: any) => {
-      return AttachmentDownloads.addJob(attachment, {
-        messageId: message.id,
-        type: 'attachment',
-        index,
-        isOpenGroupV2,
-        openGroupV2Details,
-      });
-    })
-  );
 
-  message.set({ attachments });
+  if (message.isTrustedForAttachmentDownload()) {
+    const openGroupV2Details = (isOpenGroupV2 && convo.toOpenGroupV2()) || undefined;
+    const attachments = await Promise.all(
+      normalAttachments.map(async (attachment: any, index: any) => {
+        return AttachmentDownloads.addJob(attachment, {
+          messageId: message.id,
+          type: 'attachment',
+          index,
+          isOpenGroupV2,
+          openGroupV2Details,
+        });
+      })
+    );
+
+    message.set({ attachments });
 
-  return attachments.length;
+    return attachments.length;
+  }
+  window.log.info('No downloading attachments yet as this user is not trusted for now.');
+  return 0;
 }
 
 async function processPreviews(message: MessageModel, convo: ConversationModel): Promise<number> {

ts/session/utils/AttachmentsDownload.ts

@@ -145,6 +145,13 @@ async function _runJob(job: any) {
       await _finishJob(null, id);
       return;
     }
+    const isTrusted = found.isTrustedForAttachmentDownload();
+
+    if (!isTrusted) {
+      logger.info('_runJob: sender conversation not trusted yet, deleting job');
+      await _finishJob(null, id);
+      return;
+    }
 
     if (isOpenGroupV2 && (!openGroupV2Details?.serverUrl || !openGroupV2Details.roomId)) {
       window?.log?.warn(

ts/test/test-utils/utils/message.ts

@@ -87,6 +87,7 @@ export class MockConversation {
       lastMessage: null,
       zombies: [],
       triggerNotificationsFor: 'all',
+      isTrustedForAttachmentDownload: false,
     };
   }