index.js - CometChatMessageComposer

index.js

...
buildTextMessage = (receiverId, messageInput, receiverType) => {
  const textMessage = new CometChat.TextMessage(receiverId, messageInput, receiverType);
  if (this.props.parentMessageId) {
    textMessage.setParentMessageId(this.props.parentMessageId);
  }
  textMessage.setSender(this.loggedInUser);
  textMessage.setReceiver(this.context.type);
  textMessage.setText(messageInput);
  textMessage._composedAt = getUnixTimestamp();
  textMessage._id = ID();
  return textMessage;
};

encryptUserMessage = async (messageInput, receiverId, authenticatedUser) => {
  try {
    const identities = [receiverId, authenticatedUser.id];
    const eThree = this.context.eThree;
    const findUserResults = await eThree.findUsers(identities);
    const encryptedMessage = await eThree.authEncrypt(messageInput, findUserResults);
    return encryptedMessage;
  } catch (error) {
    return messageInput
  }
};

encryptGroupMessage = async (messageInput) => {
  try {
    const guid = this.context.item.guid;
    const eThree = this.context.eThree;
    const group = await this.getVirgilGroupInstance(guid);
    const encryptedMessage = await group.encrypt(messageInput);		
    return encryptedMessage;
  } catch (error) {
    return messageInput;
  }
};

encryptMessage = async (messageInput, receiverId, receiverType, authenticatedUser) => {
  try {
    if (receiverType === 'group') {
      return await this.encryptGroupMessage(messageInput);
    } else if (receiverType === 'user') {
      return await this.encryptUserMessage(messageInput, receiverId, authenticatedUser);
    }
    return messageInput;
  } catch (error) {
    return messageInput;
  }
};

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.receiver);
      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.receiver];
      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;
  }
};

sendTextMessage = async () => {
  if (this.state.emojiViewer) {
    this.setState({ emojiViewer: false });
  }

  if (!this.state.messageInput.trim().length) {
    return false;
  }

  if (this.state.messageToBeEdited) {
    this.editMessage();
    return false;
  }

  this.endTyping(null, null);

  let { receiverId, receiverType } = this.getReceiverDetails();

  let messageInput = this.state.messageInput.trim();

  // encrypting the text message
  const authenticatedUser = JSON.parse(localStorage.getItem('auth'));
  const encryptedMessage = await this.encryptMessage(messageInput, receiverId, receiverType, authenticatedUser);
  // end ecrypting the text message

  let textMessage = this.buildTextMessage(receiverId, messageInput, receiverType);
  let encryptedTextMessage = this.buildTextMessage(receiverId, encryptedMessage, receiverType);

  this.props.actionGenerated(enums.ACTIONS["MESSAGE_COMPOSED"], [textMessage]);
  this.setState({ messageInput: "", replyPreview: false });

  this.messageInputRef.current.textContent = "";
  SoundManager.play(enums.CONSTANTS.AUDIO["OUTGOING_MESSAGE"], this.context);

  CometChat.sendMessage(encryptedTextMessage)
    .then(async message => {
      // decrypt text message.
      const decryptedMessage = await this.decryptMessage(encryptedTextMessage);
      // end decrypting text message.
      const newMessageObj = { ...message, _id: textMessage._id };
      newMessageObj.text = decryptedMessage;
      newMessageObj.data.text = decryptedMessage;
      this.props.actionGenerated(enums.ACTIONS["MESSAGE_SENT"], [newMessageObj]);
    })
    .catch(error => {
      const newMessageObj = { ...textMessage, error: error };
      this.props.actionGenerated(enums.ACTIONS["ERROR_IN_SENDING_MESSAGE"], [newMessageObj]);

      if (error && error.hasOwnProperty("code") && error.code === "ERR_GUID_NOT_FOUND") {
        //this.context.setDeletedGroupId(this.context.item.guid);
      }
    });
};
...