podchat-browser 12.7.2-snapshot.2 → 12.7.2-snapshot.21

package/src/lib/constants.js

@@ -27,7 +27,6 @@ const chatMessageVOTypes = {
     THREAD_PARTICIPANTS: 27,
     EDIT_MESSAGE: 28,
     DELETE_MESSAGE: 29,
-    THREAD_INFO_UPDATED: 30,
     LAST_SEEN_UPDATED: 31,
     GET_MESSAGE_DELIVERY_PARTICIPANTS: 32,
     GET_MESSAGE_SEEN_PARTICIPANTS: 33,
@@ -125,6 +124,7 @@ const chatMessageVOTypes = {
     CALL_STICKER_SYSTEM_MESSAGE: 225,
     CUSTOMER_INFO: 226,
     RECALL_THREAD_PARTICIPANT: 227,
+    CALL_RECORDING_FAILED: 230,
     ERROR: 999
 };
 

package/src/lib/errorHandler.js

@@ -9,6 +9,10 @@ const errorList = {
         code: 12002,
         message:"[SDK] Async is not connected"
     },
+    SOCKET_CONNECTION_FAILED: {
+        code: 12003,
+        message:"[SDK] Async socket connection failed"
+    },
     /**
      * 12350-12399
      */

package/src/lib/store/eventEmitter.js

@@ -0,0 +1,16 @@
+import EventEmitter from "events";
+const Emitter = new EventEmitter();
+
+const storeEvents = {
+    on(eventName, callback) {
+        Emitter.on(eventName, callback)
+    },
+    off(eventName) {
+        Emitter.off(eventName);
+    },
+    emit(eventName, data) {
+        Emitter.emit(eventName, data);
+    }
+}
+
+export {storeEvents}

package/src/lib/store/index.js

@@ -0,0 +1,9 @@
+import {threadsList} from "./threads";
+import {storeEvents} from "./eventEmitter";
+
+let store = {
+    threads: threadsList,
+    events: storeEvents
+};
+
+export {store}

package/src/lib/store/threads.js

@@ -0,0 +1,99 @@
+import {storeEvents} from "./eventEmitter";
+
+let list = [];
+const eventsList = {
+    UNREAD_COUNT_UPDATED: 'unreadCountUpdated',
+    LAST_SEEN_MESSAGE_TIME_UPDATED: 'lastSeenMessageTimeUpdated',
+}
+
+const threadsList = {
+    eventsList,
+    get(id) {
+        return list[threadsList.findIndex(id)];
+    },
+    getAll() {
+        return list;
+    },
+    findIndex(threadId) {
+        return list.findIndex(item => item?.get().id == threadId);
+    },
+    save(thread) {
+        let localThreadIndex = threadsList.findIndex(thread.id);
+        if (localThreadIndex > -1) {
+            list[localThreadIndex].set(thread)
+
+        } else {
+            list = [new ThreadObject(thread)].concat(list);
+        }
+    },
+    saveMany(newThreads) {
+        if (Array.isArray(newThreads)) {
+            let nonExistingThreads = [];
+            for (let item in newThreads) {
+                let localThreadIndex = threadsList.findIndex(newThreads[item].id);
+                if (localThreadIndex > -1) {
+                    list[localThreadIndex].set(newThreads[item]);
+                } else {
+                    nonExistingThreads.push(new ThreadObject(newThreads[item]));
+                }
+            }
+            if (nonExistingThreads.length) {
+                list = nonExistingThreads.concat(list);
+            }
+        }
+    },
+    remove(id) {
+        let localThreadIndex = threadsList.findIndex(id);
+        if(localThreadIndex > -1) {
+            delete list[localThreadIndex];
+        }
+    }
+}
+
+function ThreadObject(thread) {
+    const config = {
+        thread
+    };
+    return {
+        set(thread) {
+            config.thread = {...config.thread, ...thread};
+        },
+        get() {
+            return config.thread;
+        },
+        update(field, newValue) {
+            config.thread[field] = newValue;
+        },
+        unreadCount: {
+            set(count) {
+                config.thread.unreadCount = count;
+                storeEvents.emit(eventsList.UNREAD_COUNT_UPDATED, config.thread);
+            },
+            get() {
+                return config.thread.unreadCount;
+            },
+            increase() {
+                config.thread.unreadCount++;
+                storeEvents.emit(eventsList.UNREAD_COUNT_UPDATED, config.thread);
+            },
+            decrease(time) {
+                if (time > config.thread.lastSeenMessageTime && config.thread.unreadCount > 0) {
+                    config.thread.unreadCount--;
+                    storeEvents.emit(eventsList.UNREAD_COUNT_UPDATED, config.thread);
+                }
+            },
+        },
+        lastSeenMessageTime: {
+            set(number) {
+                if(number > config.thread.lastSeenMessageTime) {
+                    config.thread.lastSeenMessageTime = number;
+                }
+            },
+            get() {
+                return config.thread.lastSeenMessageTime
+            }
+        }
+    };
+}
+
+export {threadsList}

package/src/messaging.module.js

@@ -27,10 +27,24 @@ import {errorList, raiseError} from "./lib/errorHandler";
         this.sendMessageCallbacks = {};
         this.messagesCallbacks = {};
         this.asyncRequestTimeouts = {};
-        this.sendPingTimeout = null;
+        // this.sendPingTimeout = null;
         this.chatState = false;
         this.userInfo = null;
 
+        /**
+         * sendPingTimeout removed,
+         *
+         * TODO: remove the interval when socket statet changes to closed
+         */
+        this.startChatPing = function () {
+            chatPingMessageInterval = setInterval(() => {
+                currentModuleInstance.ping();
+            }, 20000) ;//TODO: chatPingMessageInterval
+        }
+        this.stopChatPing = function() {
+            clearInterval(chatPingMessageInterval);
+        }
+
         this.asyncInitialized = function (client) {
             asyncClient = client
         }
@@ -222,7 +236,8 @@ import {errorList, raiseError} from "./lib/errorHandler";
                     ttl: (params.messageTtl > 0)
                         ? params.messageTtl
                         : messageTtl
-                }
+                },
+                uniqueId: messageVO.uniqueId
             };
 
             asyncClient.send(data, function (res) {
@@ -270,10 +285,10 @@ import {errorList, raiseError} from "./lib/errorHandler";
                 }, asyncRequestTimeout);
             }
 
-            currentModuleInstance.sendPingTimeout && clearTimeout(currentModuleInstance.sendPingTimeout);
+/*          currentModuleInstance.sendPingTimeout && clearTimeout(currentModuleInstance.sendPingTimeout);
             currentModuleInstance.sendPingTimeout = setTimeout(function () {
                 currentModuleInstance.ping();
-            }, chatPingMessageInterval);
+            }, chatPingMessageInterval); */
 
             recursiveCallback && recursiveCallback();
 
@@ -306,9 +321,10 @@ import {errorList, raiseError} from "./lib/errorHandler";
                     chatMessageVOType: chatMessageVOTypes.PING,
                     pushMsgType: 3
                 });
-            } else {
-                currentModuleInstance.sendPingTimeout && clearTimeout(currentModuleInstance.sendPingTimeout);
             }
+            /*else {
+                currentModuleInstance.sendPingTimeout && clearTimeout(currentModuleInstance.sendPingTimeout);
+            }*/
         };
 
     }