podchat-browser
Version:
Javascript SDK to use POD's Chat Service - Browser Only
375 lines (331 loc) • 18.5 kB
JavaScript
import {formatDataToMakeMessage, reformatThreadHistory} from "../helpers/dataFormatters";
import {chatMessageTypes, chatMessageVOTypes} from "../constants";
import Utility from "../../utility/utility";
function ThreadHistoryMethods(app) {
/**
* Get History.
*
* This functions gets history of a thread
*
* @access private
*
* @param {int} count Count of threads to be received
* @param {int} offset Offset of select query
* @param {int} threadId Id of thread to get its history
* @param {int} id Id of single message to get
* @param {int} userId Messages of this SSO User
* @param {int} messageType Type of messages to get (types should be set by client)
* @param {int} fromTime Get messages which have bigger time than given fromTime
* @param {int} fromTimeNanos Get messages which have bigger time than given fromTimeNanos
* @param {int} toTime Get messages which have smaller time than given toTime
* @param {int} toTimeNanos Get messages which have smaller time than given toTimeNanos
* @param {int} senderId Messages of this sender only
* @param {string} uniqueIds Array of unique ids to retrieve
* @param {string} order Order of select query (default: DESC)
* @param {string} query Search term to be looked up in messages content
* @param {object} metadataCriteria This JSON will be used to search in message metadata with GraphQL
* @param {function} callback The callback function to call after
*
* @return {object} Instant result of sendMessage
*/
function getHistory(params, callback) {
if (parseInt(params.threadId) > 0) {
var sendMessageParams = {
chatMessageVOType: chatMessageVOTypes.GET_HISTORY,
typeCode: params.typeCode,
content: {},
subjectId: params.threadId
},
offset = (parseInt(params.offset) > 0) ? parseInt(params.offset) : 0,
count = (parseInt(params.count) > 0) ? parseInt(params.count) : 20,
order = (typeof params.order != 'undefined') ? (params.order).toLowerCase() : 'desc',
dynamicHistoryCount = (params.dynamicHistoryCount && typeof params.dynamicHistoryCount === 'boolean')
? params.dynamicHistoryCount
: false,
sendingQueue = (params.queues && typeof params.queues.sending === 'boolean')
? params.queues.sending
: true,
failedQueue = (params.queues && typeof params.queues.failed === 'boolean')
? params.queues.failed
: true,
uploadingQueue = (params.queues && typeof params.queues.uploading === 'boolean')
? params.queues.uploading
: true,
sendingQueueMessages = [],
failedQueueMessages = [],
uploadingQueueMessages = [];
if (sendingQueue) {
app.messageQueues.getChatSendQueue(parseInt(params.threadId), function (sendQueueMessages) {
for (var i = 0; i < sendQueueMessages.length; i++) {
var time = new Date().getTime();
sendingQueueMessages.push(formatDataToMakeMessage(sendQueueMessages[i].threadId, {
uniqueId: sendQueueMessages[i].uniqueId,
ownerId: app.store.user.get().id,
message: sendQueueMessages[i].content,
metadata: sendQueueMessages[i].metadata,
systemMetadata: sendQueueMessages[i].systemMetadata,
replyInfo: sendQueueMessages[i].replyInfo,
forwardInfo: sendQueueMessages[i].forwardInfo,
time: time,
timeNanos: (time % 1000) * 1000000
}));
}
});
}
if (uploadingQueue) {
app.messageQueues.getChatUploadQueue(parseInt(params.threadId), function (uploadQueueMessages) {
for (var i = 0; i < uploadQueueMessages.length; i++) {
uploadQueueMessages[i].message.participant = app.store.user.get();
var time = new Date().getTime();
uploadQueueMessages[i].message.time = time;
uploadQueueMessages[i].message.timeNanos = (time % 1000) * 1000000;
uploadingQueueMessages.push(formatDataToMakeMessage(params.threadId, uploadQueueMessages[i].message, false));
}
});
}
app.messageQueues.getChatWaitQueue(parseInt(params.threadId), failedQueue, function (waitQueueMessages) {
failedQueueMessages = [];
if (dynamicHistoryCount) {
var tempCount = count - (sendingQueueMessages.length + failedQueueMessages.length + uploadingQueueMessages.length);
sendMessageParams.content.count = (tempCount > 0) ? tempCount : 0;
} else {
sendMessageParams.content.count = count;
}
sendMessageParams.content.offset = offset;
sendMessageParams.content.order = order;
if (parseInt(params.messageId) > 0) {
sendMessageParams.content.id = params.messageId;
}
if (Array.isArray(params.uniqueIds)) {
sendMessageParams.content.uniqueIds = params.uniqueIds;
}
if (parseInt(params.fromTimeFull) > 0 && params.fromTimeFull.toString().length === 19) {
sendMessageParams.content.fromTime = parseInt(params.fromTimeFull.toString()
.substring(0, 13));
sendMessageParams.content.fromTimeNanos = parseInt(params.fromTimeFull.toString()
.substring(10, 19));
} else {
if (parseInt(params.fromTime) > 0 && parseInt(params.fromTime) < 9999999999999) {
sendMessageParams.content.fromTime = parseInt(params.fromTime);
}
if (parseInt(params.fromTimeNanos) > 0 && parseInt(params.fromTimeNanos) < 999999999) {
sendMessageParams.content.fromTimeNanos = parseInt(params.fromTimeNanos);
}
}
if (parseInt(params.toTimeFull) > 0 && params.toTimeFull.toString().length === 19) {
sendMessageParams.content.toTime = parseInt(params.toTimeFull.toString()
.substring(0, 13));
sendMessageParams.content.toTimeNanos = parseInt(params.toTimeFull.toString()
.substring(10, 19));
} else {
if (parseInt(params.toTime) > 0 && parseInt(params.toTime) < 9999999999999) {
sendMessageParams.content.toTime = parseInt(params.toTime);
}
if (parseInt(params.toTimeNanos) > 0 && parseInt(params.toTimeNanos) < 999999999) {
sendMessageParams.content.toTimeNanos = parseInt(params.toTimeNanos);
}
}
if (typeof params.query != 'undefined') {
sendMessageParams.content.query = params.query;
}
if (params.allMentioned && typeof params.allMentioned == 'boolean') {
sendMessageParams.content.allMentioned = params.allMentioned;
}
if (params.unreadMentioned && typeof params.unreadMentioned == 'boolean') {
sendMessageParams.content.unreadMentioned = params.unreadMentioned;
}
if (params.messageType && typeof params.messageType.toUpperCase() !== 'undefined' && chatMessageTypes[params.messageType.toUpperCase()] > 0) {
sendMessageParams.content.messageType = chatMessageTypes[params.messageType.toUpperCase()];
}
if (typeof params.metadataCriteria == 'object' && params.metadataCriteria.hasOwnProperty('field')) {
sendMessageParams.content.metadataCriteria = params.metadataCriteria;
}
if (typeof params.onlyNewMessages === "boolean") {
sendMessageParams.content.newMessages = params.onlyNewMessages;
}
let memoryCache = false;
if (typeof params.cache === "boolean") {
memoryCache = params.cache;
}
const lastMessageItem=app.store.thread.getLastMessageItem(params.threadId)
const { timeMiliSeconds} = lastMessageItem
if (memoryCache && app.store.history.canGetFromCache(params.threadId, sendMessageParams.content,lastMessageItem)) {
let retrnData = {
hasError: false,
cache: false,
errorMessage: "",
errorCode: 0
},
res = app.store.history.get(params.threadId).getCacheData(sendMessageParams.content,timeMiliSeconds)
retrnData.result = {
history: res,
hasNext: !(res.length < params.count),//(res.length >= sendMessageParams.content.count),//(sendMessageParams.content.offset + sendMessageParams.content.count < result.contentCount && messageLength > 0),
nextOffset: sendMessageParams.content.offset * 1 + res.length * 1
};
if (sendingQueue) {
retrnData.result.sending = sendingQueueMessages;
}
if (uploadingQueue) {
retrnData.result.uploading = uploadingQueueMessages;
}
if (failedQueue) {
retrnData.result.failed = failedQueueMessages;
}
callback && callback(retrnData);
callback = undefined;
} else {
/**
* Get Thread Messages From Server
*/
return app.messenger.sendMessage(sendMessageParams, {
onResult: function (result) {
var returnData = {
hasError: result.hasError,
cache: false,
errorMessage: result.errorMessage,
errorCode: result.errorCode
},
resultMessagesId = [];
if (!returnData.hasError) {
var messageContent = result.result,
messageLength = messageContent.length;
var history = reformatThreadHistory(params.threadId, messageContent);
const hasNext = !(result.result.length < sendMessageParams.content.count);
if (memoryCache && app.store.history.isParamsValid(sendMessageParams.content)) {
app.store.history.saveList(params.threadId, sendMessageParams.content, JSON.parse(JSON.stringify(history)), hasNext);
}
if (messageLength > 0) {
/**
* Calculating First and Last Messages of result
*/
var lastMessage = history[messageContent.length - 1],
firstMessage = history[0];
/**
* Sending Delivery for Last Message of Thread
*/
if (app.store.user.get().id !== firstMessage.participant.id && !firstMessage.delivered) {
app.messageQueues.putInMessagesDeliveryQueue(params.threadId, firstMessage.id);
}
}
returnData.result = {
history: history,
contentCount: result.contentCount,
hasNext: result.result && hasNext,//(sendMessageParams.content.offset + sendMessageParams.content.count < result.contentCount && messageLength > 0),
nextOffset: sendMessageParams.content.offset * 1 + messageLength * 1
};
if (sendingQueue) {
returnData.result.sending = sendingQueueMessages;
}
if (uploadingQueue) {
returnData.result.uploading = uploadingQueueMessages;
}
if (failedQueue) {
returnData.result.failed = failedQueueMessages;
}
callback && callback(returnData);
callback = undefined;
}
}
});
}
});
} else {
app.chatEvents.fireEvent('error', {
code: 999,
message: '[SDK] Thread ID is required for Getting history!'
});
}
}
function onGetHistory(uniqueId, messageContent, contentCount, chatMessage) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, contentCount));
}
}
/**
* Returns some messages before and after the received messageId based on the size
*
* @param params
* @param callback
*/
function getHistoryByMessageIdRange(params, callback) {
if (!params) {
app.chatEvents.fireEvent('error', {
code: 999,
message: '[SDK] No params have been received'
});
return;
}
let sendMessageParams = {
chatMessageVOType: chatMessageVOTypes.GET_HISTORY_BY_MESSAGE_ID_RANGE,
typeCode: params.typeCode,
content: {},
subjectId: params.threadId
};
if (params.messageId) {
sendMessageParams.content.messageId = params.messageId;
} else {
app.chatEvents.fireEvent('error', {
code: 999,
message: `[SDK] messageId is required`
});
return;
}
sendMessageParams.content.size = ((typeof params.size == 'number' && params.size <= 10) ? params.size : 10);
let memoryCache = false;
if (typeof params.cache === "boolean") {
memoryCache = params.cache;
}
const lastMessageItem =app.store.thread.getLastMessageItem(params.threadId)
if (memoryCache && app.store.history.canGetFromCache(params.threadId, sendMessageParams.content,lastMessageItem)) {
let retrnData = {
hasError: false,
cache: true,
errorMessage: null,
errorCode: 0
},
res = app.store.history.get(params.threadId).getRangeCacheData(sendMessageParams.content)
retrnData.result = {
history: res,
hasNext: true
};
callback && callback(retrnData);
callback = undefined;
return;
}
return app.messenger.sendMessage(sendMessageParams, {
onResult: function (result) {
let returnData = {
hasError: result.hasError,
cache: false,
errorMessage: result.errorMessage,
errorCode: result.errorCode
};
if (!returnData.hasError) {
let messageContent = result.result;
let history = reformatThreadHistory(params.threadId, messageContent);
if (memoryCache && app.store.history.isParamsValid(sendMessageParams.content)) {
app.store.history.saveList(params.threadId, sendMessageParams.content, JSON.parse(JSON.stringify(history)), true);
}
returnData.result = {
history,
hasNext: true
};
callback && callback(returnData);
callback = undefined;
}
}
});
}
function onGetHistoryByMessageIdRange(uniqueId, threadId, messageContent, chatMessage) {
if (app.store.messagesCallbacks[uniqueId]) {
app.store.messagesCallbacks[uniqueId](Utility.createReturnData(chatMessage.typeCode, chatMessage.ownerId, false, '', 0, messageContent, null));
}
}
return {
getHistory,
onGetHistory,
getHistoryByMessageIdRange,
onGetHistoryByMessageIdRange
}
}
export default ThreadHistoryMethods;