podchat-browser/dist/node/lib/chat/threadMethods.js

Javascript SDK to use POD's Chat Service - Browser Only

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _constants = require("../constants");

var _utility = _interopRequireDefault(require("../../utility/utility"));

var _dataFormatters = require("../helpers/dataFormatters");

function ThreadMethods(app) {
  var pinMessageRequests = {};

  function getPinMessages(params, callback) {
    var sendData = {
      chatMessageVOType: _constants.chatMessageVOTypes.GET_PIN_MESSAGE,
      typeCode: params.typeCode,
      //params.typeCode,
      token: app.sdkParams.token // content: params.content

    };

    if (!params.uniqueId) {
      sendData.uniqueId = _utility["default"].generateUUID();
    }

    if (!params.content || !params.content.length) {
      return;
    }

    var mustRequestIds = [],
        existingItems = [];
    params.content.forEach(function (item) {
      var thread = app.store.threads.findOrCreate({
        id: item
      });

      if (!thread.pinMessage.isPinMessageRequested() && !thread.get().pinMessageVO) {
        mustRequestIds.push(item);
      } else if (thread.get().pinMessageVO) {
        existingItems.push(JSON.parse(JSON.stringify({
          id: thread.get().id,
          pinMessageVO: thread.get().pinMessageVO
        })));
      }
    });

    if (existingItems.length) {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'GET_PIN_MESSAGES',
        result: existingItems,
        uniqueId: sendData.uniqueId
      });
    }

    if (mustRequestIds.length) {
      pinMessageRequests[sendData.uniqueId] = mustRequestIds;
      return app.messenger.sendMessage(sendData);
    } //     onResult: function (result) {
    //
    //         callback && callback(result);
    //     }
    // });

  }

  function getLastActionInthread(params) {
    var sendData = {
      chatMessageVOType: _constants.chatMessageVOTypes.LAST_ACTION_IN_THREAD,
      typeCode: params.typeCode,
      //params.typeCode,
      token: app.sdkParams.token // content: params.content

    };

    if (!params.uniqueId) {
      sendData.uniqueId = _utility["default"].generateUUID();
    }

    if (!params.content || !params.content.length) {
      return;
    }

    sendData.content = params.content;
    return app.messenger.sendMessage(sendData); // let mustRequestIds = [],
    //     existingItems = [];
    // params.content.forEach(item => {
    //     let thread = app.store.threads.findOrCreate({id: item});
    //     if (!thread.lastActionRequested() && !thread.lastReactionVO) {
    //         mustRequestIds.push(item);
    //     } else if (thread.lastReactionVO) {
    //         existingItems.push(JSON.parse(JSON.stringify({id: thread.id, lastReactionVO: thread.lastReactionVO})));
    //     }
    // });
    //
    // if (existingItems.length) {
    //     app.chatEvents.fireEvent('threadEvents', {
    //         type: 'GET_LAST_ACTION_IN_THREAD',
    //         result: existingItems,
    //         uniqueId: sendData.uniqueId
    //     });
    // }
  }

  function onGetPinMessages(uniqueId, messageContent, contentCount) {
    if (pinMessageRequests[uniqueId]) {
      var result = [];
      pinMessageRequests[uniqueId].forEach(function (it) {
        var th = app.store.threads.findOrCreate({
          id: it.id
        });
        var serverResult = messageContent.length && messageContent.find(function (item) {
          return item.id == th.id;
        });

        if (serverResult) {
          th.pinMessage.setPinMessage(serverResult.pinMessageVO);
          result.push(JSON.parse(JSON.stringify({
            id: th.id,
            pinMessageVO: serverResult.pinMessageVO
          })));
        }

        th.pinMessage.setPinMessageRequested(true);
      });
      app.chatEvents.fireEvent('threadEvents', {
        type: 'GET_PIN_MESSAGES',
        result: result,
        uniqueId: uniqueId
      });
    }
  }

  function onGetLastActionInThread(uniqueId, messageContent, contentCount) {
    var result = [];
    messageContent.forEach(function (item) {
      result.push({
        id: item.threadId,
        lastMessageVO: item.lastMessageVO,
        lastReactionVO: item.lastReactionVO
      });
    });
    app.chatEvents.fireEvent('threadEvents', {
      type: 'GET_LAST_ACTION_IN_THREAD',
      result: result,
      uniqueId: uniqueId
    });
  }
  /**
   * Create Thread
   *
   * Makes formatted Thread Object out of given contentCount,
   * If Thread has been newly created, a THREAD_NEW event
   * will be emitted
   *
   * @access private
   *
   * @param {object}    messageContent    Json object of thread taken from chat server
   * @param {boolean}   addFromService    if this is a newly created Thread, addFromService should be True
   *
   * @param showThread
   * @return {object} Formatted Thread Object
   */


  function createThread(messageContent, addFromService, showThread) {
    var threadData = (0, _dataFormatters.formatDataToMakeConversation)(messageContent);
    var redirectToThread = showThread === true ? showThread : false;

    if (addFromService) {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_NEW',
        redirectToThread: redirectToThread,
        result: {
          thread: threadData
        }
      });
    }

    return threadData;
  }

  function getThreads(params, callback) {
    var count = 25,
        offset = 0,
        content = {},
        returnCache = false;

    if (params) {
      if (parseInt(params.count) > 0) {
        count = params.count;
      }

      if (parseInt(params.offset) > 0) {
        offset = params.offset;
      }

      if (typeof params.threadName === 'string') {
        content.name = params.threadName;
      }

      if (typeof params.username === 'string') {
        content.username = params.username;
      }

      if (typeof params.cellphoneNumber === 'string') {
        content.cellphoneNumber = params.cellphoneNumber;
      }

      if (typeof params.archived === 'boolean') {
        content.archived = params.archived;
      }

      if (Array.isArray(params.threadIds)) {
        content.threadIds = params.threadIds;
      }

      if (typeof params["new"] === 'boolean') {
        content["new"] = params["new"];
      }

      if (parseInt(params.creatorCoreUserId) > 0) {
        content.creatorCoreUserId = params.creatorCoreUserId;
      }

      if (parseInt(params.partnerCoreUserId) > 0) {
        content.partnerCoreUserId = params.partnerCoreUserId;
      }

      if (parseInt(params.partnerCoreContactId) > 0) {
        content.partnerCoreContactId = params.partnerCoreContactId;
      }

      if (parseInt(params.fromTime) > 0 && parseInt(params.fromTime) < 9999999999999) {
        content.fromTime = parseInt(params.fromTime);
      }

      if (parseInt(params.toTime) > 0 && parseInt(params.toTime) < 9999999999999) {
        content.toTime = parseInt(params.toTime);
      }

      var functionLevelCache = typeof params.cache == 'boolean' ? params.cache : true;

      if (typeof params.isGroup === 'boolean') {
        content.isGroup = params.isGroup;
      }

      if (typeof params.type === 'number') {
        content.type = params.type;
      }
    }

    content.count = count;
    content.offset = offset;

    if (params.threadIds) {
      var cache = app.store.thread.getThreadByIds(params.threadIds, params.cache);

      if (cache) {
        callback && callback(cache);
        callback = undefined;
        return;
      }
    } else {
      var threadCache = app.store.thread.getCacheData(params);

      if (threadCache) {
        callback && callback(threadCache);
        callback = undefined;
        return;
      }
    }

    var sendMessageParams = {
      chatMessageVOType: _constants.chatMessageVOTypes.GET_THREADS,
      typeCode: params.typeCode,
      content: content
    };
    /**
     * Retrive get threads response from server
     */

    return app.messenger.sendMessage(sendMessageParams, {
      onResult: function onResult(result) {
        var returnData = {
          typeCode: result.typeCode,
          ownerId: result.ownerId,
          hasError: result.hasError,
          cache: false,
          errorMessage: result.errorMessage,
          errorCode: result.errorCode,
          uniqueId: result.uniqueId
        };

        if (!returnData.hasError) {
          var messageContent = result.result,
              messageLength = messageContent.length,
              resultData = {
            threads: [],
            contentCount: result.contentCount,
            hasNext: messageContent && !(messageLength < count),
            //(offset + count < result.contentCount && messageLength > 0),
            nextOffset: offset * 1 + messageLength * 1
          },
              threadData;

          for (var i = 0; i < messageLength; i++) {
            threadData = app.threadMethods.createThread(messageContent[i], false);

            if (threadData) {
              resultData.threads.push(threadData);
            }
          } // app.store.threads.saveMany(resultData.threads);


          app.store.thread.saveMany(resultData.threads, params);
          returnData.result = resultData;
        }

        callback && callback(returnData);
        /**
         * Delete callback so if server pushes response before
         * cache, cache won't send data again
         */

        callback = undefined;

        if (!returnData.hasError && returnCache) {
          app.chatEvents.fireEvent('threadEvents', {
            type: 'THREADS_LIST_CHANGE',
            result: returnData.result
          });
        }
      }
    });
  }

  function onRemovedFromThread(threadId) {
    app.store.thread.remove(threadId);
    app.chatEvents.fireEvent('threadEvents', {
      type: 'THREAD_REMOVED_FROM',
      result: {
        thread: threadId
      }
    });
  }

  function onCreateThread(uniqueId, messageContent, contentCount, chatMessage) {
    messageContent.uniqueId = uniqueId;

    if (app.store.messagesCallbacks[uniqueId]) {
      app.threadMethods.createThread(messageContent, true, true);
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount));
    } else {
      app.threadMethods.createThread(messageContent, true, false);
    }

    var threadData = (0, _dataFormatters.formatDataToMakeConversation)(messageContent);
    app.store.thread.putItemAfterLastPinThread(threadData);
  }

  function onLeaveThread(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount));
    }

    app.store.thread.remove(threadId);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode
      }, function (threadsResult) {
        var threads = threadsResult.result.threads;

        if (threads.length > 0) {
          app.chatEvents.fireEvent('threadEvents', {
            type: 'THREAD_LEAVE_PARTICIPANT',
            result: {
              threadId: threadId,
              messageContent: messageContent,
              thread: threads[0],
              participant: (0, _dataFormatters.formatDataToMakeParticipant)(messageContent, threadId),
              typeCode: typeCode
            }
          });
          app.chatEvents.fireEvent('threadEvents', {
            type: 'THREAD_LAST_ACTIVITY_TIME',
            result: {
              threadId: threadId,
              messageContent: messageContent,
              thread: threads[0],
              typeCode: typeCode
            }
          });
        } else {
          app.chatEvents.fireEvent('threadEvents', {
            type: 'THREAD_LEAVE_PARTICIPANT',
            result: {
              threadId: threadId,
              messageContent: messageContent,
              participant: (0, _dataFormatters.formatDataToMakeParticipant)(messageContent, threadId),
              typeCode: typeCode
            }
          });
        }
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_LEAVE_PARTICIPANT',
        result: {
          threadId: threadId,
          messageContent: messageContent,
          thread: threadId,
          participant: (0, _dataFormatters.formatDataToMakeParticipant)(messageContent, threadId),
          typeCode: typeCode
        }
      });
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_LAST_ACTIVITY_TIME',
        result: {
          threadId: threadId,
          thread: threadId,
          typeCode: typeCode
        }
      });
    }
  }

  function onArchiveThread(chatMessage, messageContent, contentCount, uniqueId) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount, uniqueId));
    }

    app.chatEvents.fireEvent('threadEvents', {
      type: 'THREAD_ARCHIVE',
      result: messageContent
    });
    app.store.thread.archive.archiveThread(messageContent);
  }

  function onUnArchiveThread(chatMessage, messageContent, contentCount, uniqueId) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount, uniqueId));
    }

    app.chatEvents.fireEvent('threadEvents', {
      type: 'THREAD_UNARCHIVE',
      result: messageContent
    });
    app.store.thread.archive.unArchiveThread(messageContent);
  }

  function onMuteThread(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.mute.muteThread(threadId);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode,
        cache: false
      }, function (threadsResult) {
        var thread = threadsResult.result.threads[0];
        thread.mute = true;
        app.chatEvents.fireEvent('threadEvents', {
          type: 'THREAD_MUTE',
          result: {
            thread: thread,
            typeCode: typeCode
          }
        });
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_MUTE',
        result: {
          thread: threadId,
          typeCode: typeCode
        }
      });
    }
  }

  function onUnMuteThread(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.mute.unMuteThread(threadId);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode,
        cache: false
      }, function (threadsResult) {
        var thread = threadsResult.result.threads[0];
        thread.mute = false;
        app.chatEvents.fireEvent('threadEvents', {
          type: 'THREAD_UNMUTE',
          result: {
            thread: thread,
            typeCode: typeCode
          }
        });
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_UNMUTE',
        result: {
          thread: threadId,
          typeCode: typeCode
        }
      });
    }
  }

  function onUpdateThreadInfo(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.changeTitle(threadId, messageContent === null || messageContent === void 0 ? void 0 : messageContent.title);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode
      }, function (threadsResult) {
        var thread = (0, _dataFormatters.formatDataToMakeConversation)(threadsResult.result.threads[0]);
        app.chatEvents.fireEvent('threadEvents', {
          type: 'THREAD_INFO_UPDATED',
          result: {
            thread: thread,
            typeCode: typeCode
          }
        });
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_INFO_UPDATED',
        result: {
          thread: messageContent,
          typeCode: typeCode
        }
      });
    }
  }

  function onPinThread(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.pin.pinThread(threadId);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode,
        cache: false
      }, function (threadsResult) {
        var thread = threadsResult.result.threads[0];
        app.chatEvents.fireEvent('threadEvents', {
          type: 'THREAD_PIN',
          result: {
            thread: thread,
            typeCode: typeCode
          }
        });
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_PIN',
        result: {
          thread: threadId,
          typeCode: typeCode
        }
      });
    }
  }

  function onUnPinThread(uniqueId, messageContent, contentCount, chatMessage, threadId, typeCode) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.pin.unPinThread(threadId);

    if (app.sdkParams.fullResponseObject) {
      app.threadMethods.getThreads({
        threadIds: [threadId],
        typeCode: typeCode,
        cache: false
      }, function (threadsResult) {
        var thread = threadsResult.result.threads[0];
        app.chatEvents.fireEvent('threadEvents', {
          type: 'THREAD_UNPIN',
          result: {
            thread: thread,
            typeCode: typeCode
          }
        });
      });
    } else {
      app.chatEvents.fireEvent('threadEvents', {
        type: 'THREAD_UNPIN',
        result: {
          thread: threadId,
          typeCode: typeCode
        }
      });
    }
  }

  function onContactThreadUpdate(threadId, messageContent) {
    messageContent.threadId = threadId;
    app.chatEvents.fireEvent('threadEvents', {
      type: 'CONTACT_THREAD_UPDATE',
      result: messageContent
    });
    app.store.thread.changeTitle(threadId, messageContent === null || messageContent === void 0 ? void 0 : messageContent.title);
  }

  function onDeleteMessageThread(uniqueId, messageContent, contentCount, chatMessage, threadId) {
    if (app.store.messagesCallbacks[uniqueId]) {
      app.store.messagesCallbacks[uniqueId](_utility["default"].createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
    }

    app.store.thread.remove(threadId);

    if (!messageContent) {
      messageContent = {};
    }

    messageContent.threadId = threadId;
    app.chatEvents.fireEvent('threadEvents', {
      type: 'DELETE_THREAD',
      result: messageContent
    });
  }

  return {
    getThreads: getThreads,
    createThread: createThread,
    getPinMessages: getPinMessages,
    getLastActionInthread: getLastActionInthread,
    onGetPinMessages: onGetPinMessages,
    onGetLastActionInThread: onGetLastActionInThread,
    onRemovedFromThread: onRemovedFromThread,
    onCreateThread: onCreateThread,
    onLeaveThread: onLeaveThread,
    onArchiveThread: onArchiveThread,
    onUnArchiveThread: onUnArchiveThread,
    onMuteThread: onMuteThread,
    onUnMuteThread: onUnMuteThread,
    onUpdateThreadInfo: onUpdateThreadInfo,
    onPinThread: onPinThread,
    onUnPinThread: onUnPinThread,
    onContactThreadUpdate: onContactThreadUpdate,
    onDeleteMessageThread: onDeleteMessageThread
  };
}

var _default = ThreadMethods;
exports["default"] = _default;