index.js - CometChatMessageList - Decrypt After Receiving the Message - Encrypted Chat App

index.js

...
async componentDidMount() {
  ...
  if (this.context.item && this.context.item.guid) {
    await this.startVirgilGroupChat();
  }
  ...
}
async componentDidUpdate(prevProps, prevState) {
  ...
  if (this.context.item && this.context.item.guid) {
    await this.startVirgilGroupChat();
  }
}
...
startVirgilGroupChat = async () => {
  if (this.context.item && this.context.item.guid) {
    try {
      const groupId = this.context.item.guid;
      const eThree = this.context.eThree;
      const ownerCard = await eThree.findUsers(this.context.item.owner);
      const group = await eThree.loadGroup(groupId, ownerCard);
    } catch (error) {

    }
  }
};
...
getVirgilGroupInstance = async guid => {
  try {
    if (guid) {
      const eThree = this.context.eThree;
      let group = await eThree.getGroup(guid);
      if (group) {
        return group;
      }
      const ownerCard = await eThree.findUsers(this.context.item.owner);
      group = await eThree.loadGroup(guid, ownerCard);
      return group;
    }
    return null
  } catch (error) {
    return null;
  }
}


decryptGroupMessage = async (message) => {
  try {
    if (message && message.data.text) {
      const eThree = this.context.eThree;
      const group = await this.getVirgilGroupInstance(message.receiverId);
      const messageSender = await eThree.findUsers(message.sender.uid);
      const decryptedMessage = await group.decrypt(message.data.text, messageSender);
      return decryptedMessage;
    }
    return message.data.text;
  } catch (error) {
    return message.data.text;
  }
}

decryptUserMessage = async (message) => {
  try {
    if (message && message.data.text) {
      const eThree = this.context.eThree;
      const identities = [message.sender.uid, message.receiverId];
      const findUserResults = await eThree.findUsers(identities);
      const decryptedMessage = await eThree.authDecrypt(message.data.text, findUserResults[message.sender.uid]);
      return decryptedMessage;
    }
    return message.data.text;
  } catch (error) {
    return message.data.text;
  }
};

decryptMessage = async (message) => {
  try {
    const receiverType = message.receiverType;
    if (receiverType === 'group') {
      return await this.decryptGroupMessage(message);
    } else if (receiverType === 'user') {
      return await this.decryptUserMessage(message);
    }
    return message.data.text;
  } catch (error) {
    return message.data.text;
  }
};
  
decryptMessages = async (messageList) => {
  if (messageList && messageList.length !== 0) {
    const decryptedMessages = [];
    for (const message of messageList) {
      if (message && message.data.text) {
        const decryptedMessage = await this.decryptMessage(message);
        message.text = decryptedMessage;
        message.data.text = decryptedMessage;
        decryptedMessages.push(message);
      } else {
        decryptedMessages.push(message);
      }
    }
    return decryptedMessages;
  }
  return messageList;
};

fetchMessages = () => {
  const promise = new Promise((resolve, reject) => {
    this.MessageListManager.fetchPreviousMessages()
      .then(async messageList => {
        const decryptedMessages = await this.decryptMessages(messageList);
        resolve(decryptedMessages);
      })
      .catch(error => reject(error));
  });

  return promise;
};
  
onMessageReceived = async message => {

  if (message && message.data.text) {
    const decryptedMessage = await this.decryptMessage(message);

    message.text = decryptedMessage;
    message.data.text = decryptedMessage;
  }
  ...
};
  
//callback for listener functions
messageUpdated = (key, message, group, options) => {

  switch (key) {
    ...
    case enums.GROUP_MEMBER_SCOPE_CHANGED:
    case enums.GROUP_MEMBER_JOINED:
    case enums.GROUP_MEMBER_LEFT:
    case enums.GROUP_MEMBER_ADDED:
    case enums.GROUP_MEMBER_KICKED:
    case enums.GROUP_MEMBER_BANNED:
    case enums.GROUP_MEMBER_UNBANNED:
      ...
      this.startVirgilGroupChat();
      break;
    ...
  }
};
...