podchat-browser
Version:
Javascript SDK to use POD's Chat Service - Browser Only
650 lines (570 loc) • 23.7 kB
JavaScript
import {chatMessageVOTypes} from "../constants";
import Utility from "../../utility/utility";
import {formatDataToMakeConversation, formatDataToMakeParticipant} from "../helpers/dataFormatters";
function ThreadMethods(app) {
let pinMessageRequests = {};
function getPinMessages(params, callback) {
let sendData = {
chatMessageVOType: chatMessageVOTypes.GET_PIN_MESSAGE,
typeCode: params.typeCode, //params.typeCode,
token: app.sdkParams.token,
// content: params.content
};
if (!params.uniqueId) {
sendData.uniqueId = Utility.generateUUID();
}
if (!params.content || !params.content.length) {
return;
}
let mustRequestIds = [],
existingItems = [];
params.content.forEach(item => {
let 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) {
let sendData = {
chatMessageVOType: chatMessageVOTypes.LAST_ACTION_IN_THREAD,
typeCode: params.typeCode, //params.typeCode,
token: app.sdkParams.token,
// content: params.content
};
if (!params.uniqueId) {
sendData.uniqueId = Utility.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]) {
let result = [];
pinMessageRequests[uniqueId].forEach(it => {
let th = app.store.threads.findOrCreate({
id: it.id
});
let serverResult = messageContent.length && messageContent.find(item => 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,
uniqueId
});
}
}
function onGetLastActionInThread(uniqueId, messageContent, contentCount) {
let result = [];
messageContent.forEach(item => {
result.push({
id: item.threadId,
lastMessageVO: item.lastMessageVO,
lastReactionVO: item.lastReactionVO
})
});
app.chatEvents.fireEvent('threadEvents', {
type: 'GET_LAST_ACTION_IN_THREAD',
result,
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) {
let threadData = formatDataToMakeConversation(messageContent);
let 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){
const cache = app.store.thread.getThreadByIds(params.threadIds, params.cache)
if (cache) {
callback && callback(cache);
callback = undefined;
return ;
}
}else {
const threadCache = app.store.thread.getCacheData(params)
if (threadCache) {
callback && callback(threadCache);
callback = undefined;
return ;
}
}
var sendMessageParams = {
chatMessageVOType: chatMessageVOTypes.GET_THREADS,
typeCode: params.typeCode,
content: content
};
/**
* Retrive get threads response from server
*/
return app.messenger.sendMessage(sendMessageParams, {
onResult: function (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.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount));
} else {
app.threadMethods.createThread(messageContent, true, false);
}
let threadData = 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.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount));
}
app.store.thread.remove(threadId)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
typeCode,
}, function (threadsResult) {
var threads = threadsResult.result.threads;
if (threads.length > 0) {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_LEAVE_PARTICIPANT',
result: {
threadId,
messageContent,
thread: threads[0],
participant: formatDataToMakeParticipant(messageContent, threadId),
typeCode
}
});
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_LAST_ACTIVITY_TIME',
result: {
threadId,
messageContent,
thread: threads[0],
typeCode
}
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_LEAVE_PARTICIPANT',
result: {
threadId,
messageContent,
participant: formatDataToMakeParticipant(messageContent, threadId),
typeCode
}
});
}
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_LEAVE_PARTICIPANT',
result: {
threadId,
messageContent,
thread: threadId,
participant: formatDataToMakeParticipant(messageContent, threadId),
typeCode
}
});
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_LAST_ACTIVITY_TIME',
result: {
threadId,
thread: threadId,
typeCode
}
});
}
}
function onArchiveThread(chatMessage,messageContent, contentCount, uniqueId) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.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.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.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
}
app.store.thread.mute.muteThread(threadId)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
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
}
});
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_MUTE',
result: {
thread: threadId,
typeCode
}
});
}
}
function onUnMuteThread(uniqueId, messageContent, contentCount, chatMessage, threadId,typeCode) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
}
app.store.thread.mute.unMuteThread(threadId)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
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
}
});
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_UNMUTE',
result: {
thread: threadId,
typeCode
}
});
}
}
function onUpdateThreadInfo(uniqueId, messageContent, contentCount, chatMessage, threadId,typeCode) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
}
app.store.thread.changeTitle(threadId, messageContent?.title)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
typeCode,
}, function (threadsResult) {
var thread = formatDataToMakeConversation(threadsResult.result.threads[0]);
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_INFO_UPDATED',
result: {
thread: thread,
typeCode
}
});
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_INFO_UPDATED',
result: {
thread: messageContent,
typeCode
}
});
}
}
function onPinThread(uniqueId, messageContent, contentCount, chatMessage, threadId,typeCode) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
}
app.store.thread.pin.pinThread(threadId)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
typeCode,
cache: false
}, function (threadsResult) {
var thread = threadsResult.result.threads[0];
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_PIN',
result: {
thread: thread,
typeCode
}
});
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_PIN',
result: {
thread: threadId,
typeCode
}
});
}
}
function onUnPinThread(uniqueId, messageContent, contentCount, chatMessage, threadId,typeCode) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent));
}
app.store.thread.pin.unPinThread(threadId)
if (app.sdkParams.fullResponseObject) {
app.threadMethods.getThreads({
threadIds: [threadId],
typeCode,
cache: false
}, function (threadsResult) {
var thread = threadsResult.result.threads[0];
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_UNPIN',
result: {
thread: thread,
typeCode,
}
});
});
} else {
app.chatEvents.fireEvent('threadEvents', {
type: 'THREAD_UNPIN',
result: {
thread: threadId,
typeCode
}
});
}
}
function onContactThreadUpdate(threadId,messageContent) {
messageContent.threadId = threadId;
app.chatEvents.fireEvent('threadEvents', {
type: 'CONTACT_THREAD_UPDATE',
result: messageContent
});
app.store.thread.changeTitle(threadId, messageContent?.title)
}
function onDeleteMessageThread(uniqueId, messageContent, contentCount, chatMessage, threadId) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.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,
createThread,
getPinMessages,
getLastActionInthread,
onGetPinMessages,
onGetLastActionInThread,
onRemovedFromThread,
onCreateThread,
onLeaveThread,
onArchiveThread,
onUnArchiveThread,
onMuteThread,
onUnMuteThread,
onUpdateThreadInfo,
onPinThread,
onUnPinThread,
onContactThreadUpdate,
onDeleteMessageThread,
}
}
export default ThreadMethods