podchat 11.3.0 → 11.4.0

package/src/chat.js

@@ -162,9 +162,34 @@
                 STOP_BOT: 65,
                 BOT_COMMANDS: 68,
                 THREAD_ALL_BOTS: 69,
+
+                CALL_REQUEST: 70,
+                ACCEPT_CALL: 71,
+                REJECT_CALL: 72,
+                RECEIVE_CALL_REQUEST: 73,
+                START_CALL: 74,
+                END_CALL_REQUEST: 75,
+                END_CALL: 76,
+                GET_CALLS: 77,
+
                 CONTACT_SYNCED: 90,
+
+                GROUP_CALL_REQUEST: 91,
+                LEAVE_CALL: 92,
+                ADD_CALL_PARTICIPANT: 93,
+                CALL_PARTICIPANT_JOINED: 94,
+                REMOVE_CALL_PARTICIPANT: 95,
+                TERMINATE_CALL: 96,
+                MUTE_CALL_PARTICIPANT: 97,
+                UNMUTE_CALL_PARTICIPANT: 98,
+
                 LOGOUT: 100,
 
+                ACTIVE_CALL_PARTICIPANTS: 110,
+                CALL_SESSION_CREATED: 111,
+                TURN_ON_VIDEO_CALL: 113,
+                TURN_OFF_VIDEO_CALL: 114,
+
                 RECORD_CALL: 121,
                 END_RECORD_CALL: 122,
                 DESTINATED_RECORD_CALL: 126,
@@ -336,7 +361,37 @@
             chatWaitQueue = [],
             chatUploadQueue = [],
             chatSendQueueHandlerTimeout,
-            fullResponseObject = params.fullResponseObject || false;
+            fullResponseObject = params.fullResponseObject || false,
+
+            consoleLogging = (params.asyncLogging.consoleLogging && typeof params.asyncLogging.consoleLogging === 'boolean')
+                ? params.asyncLogging.consoleLogging
+                : false,
+
+            /** call variables */
+            callTypes = {
+                'VOICE': 0x0,
+                'VIDEO': 0x1
+            },
+            currentCallParams = {},
+            currentCallId = null,
+            callClientType = {
+                WEB: 1,
+                ANDROID: 2,
+                DESKTOP: 3,
+                NODE: 4
+            },
+            callRequestController = {
+                callRequestReceived: false,
+                callEstablishedInMySide: false,
+                iCanAcceptTheCall: function () {
+                    return callRequestController.callRequestReceived && callRequestController.callEstablishedInMySide;
+                }
+            },
+            callStopQueue = {
+                callStarted: false,
+            },
+            callRequestTimeout = (typeof params.callRequestTimeout === 'number' && params.callRequestTimeout >= 0) ? params.callRequestTimeout : 10000;
+
 
         /*******************************************************
          *            P R I V A T E   M E T H O D S            *
@@ -3120,221 +3175,561 @@
                         break;
 
                     /**
-                     * Type 90    Contacts Synced
+                     * Type 70    Send Call Request
                      */
-                    case chatMessageVOTypes.CONTACT_SYNCED:
-                        fireEvent('contactEvents', {
-                            type: 'CONTACTS_SYNCED',
+                    case chatMessageVOTypes.CALL_REQUEST:
+                        callRequestController.callRequestReceived = true;
+                        callReceived({
+                            callId: messageContent.callId
+                        }, function (r) {
+
+                        });
+
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'RECEIVE_CALL',
                             result: messageContent
                         });
+
+                        currentCallId = messageContent.callId;
+
                         break;
 
                     /**
-                     * Type 121    Record Call Request
+                     * Type 71    Accept Call Request
                      */
-                    case chatMessageVOTypes.RECORD_CALL:
+                    case chatMessageVOTypes.ACCEPT_CALL:
                         if (messagesCallbacks[uniqueId]) {
                             messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
 
                         fireEvent('callEvents', {
-                            type: 'START_RECORDING_CALL',
+                            type: 'ACCEPT_CALL',
                             result: messageContent
                         });
 
                         break;
 
                     /**
-                     * Type 122   End Record Call Request
+                     * Type 72    Reject Call Request
                      */
-                    case chatMessageVOTypes.END_RECORD_CALL:
+                    case chatMessageVOTypes.REJECT_CALL:
                         if (messagesCallbacks[uniqueId]) {
                             messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
 
                         fireEvent('callEvents', {
-                            type: 'STOP_RECORDING_CALL',
+                            type: 'REJECT_CALL',
                             result: messageContent
                         });
 
                         break;
 
                     /**
-                     * Type 126   Destined Record Call Request
+                     * Type 73    Receive Call Request
                      */
-                    case chatMessageVOTypes.DESTINATED_RECORD_CALL:
+                    case chatMessageVOTypes.RECEIVE_CALL_REQUEST:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        if (messageContent.callId > 0) {
+                            fireEvent('callEvents', {
+                                type: 'RECEIVE_CALL',
+                                result: messageContent
+                            });
+                        } else {
+                            fireEvent('callEvents', {
+                                type: 'PARTNER_RECEIVED_YOUR_CALL',
+                                result: messageContent
+                            });
+                        }
+
+                        currentCallId = messageContent.callId;
+
+                        break;
+
+                    /**
+                     * Type 74    Start Call Request
+                     */
+                    case chatMessageVOTypes.START_CALL:
+                        if(!callRequestController.iCanAcceptTheCall()) {
+                            //Do not handle the call if it is already started elsewhere for the same user
+                            fireEvent('callEvents', {
+                                type: 'CALL_STARTED_ELSEWHERE',
+                                message: 'Call already started somewhere else..., aborting...'
+                            });
+                            return;
+                        }
+
                         if (messagesCallbacks[uniqueId]) {
                             messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
 
                         fireEvent('callEvents', {
-                            type: 'START_RECORDING_CALL',
+                            type: 'CALL_STARTED',
                             result: messageContent
                         });
 
+                        if (typeof messageContent === 'object'
+                            && messageContent.hasOwnProperty('chatDataDto')
+                            && !!messageContent.chatDataDto.kurentoAddress) {
+                        } else {
+                            fireEvent('callEvents', {
+                                type: 'CALL_ERROR',
+                                message: 'Chat Data DTO is not present!'
+                            });
+                        }
+
                         break;
 
-                     /**
-                     * Type 127   Assistant call started
-                     *
-                     * Tells the assistant that a call started
+                    /**
+                     * Type 75    End Call Request
                      */
-                    case chatMessageVOTypes.ASSISTANT_CALL_STARTED:
-                        /*if (messagesCallbacks[uniqueId]) {
+                    case chatMessageVOTypes.END_CALL_REQUEST:
+                        if (messagesCallbacks[uniqueId]) {
                             messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
-                        }*/
+                        }
 
                         fireEvent('callEvents', {
-                            type: 'ASSISTANT_CALL_STARTED',
-                            result: {
-                                callId: threadId
-                            }
+                            type: 'END_CALL',
+                            result: messageContent
                         });
 
+                        callStop();
+
                         break;
 
-                     /**
-                     * Type 128   Assistant call ended
-                     *
-                     * Tells the assistant that a call ended
+                    /**
+                     * Type 76   Call Ended
                      */
-                    case chatMessageVOTypes.ASSISTANT_CALL_ENDED:
-                       /* if (messagesCallbacks[uniqueId]) {
+                    case chatMessageVOTypes.END_CALL:
+                        if (messagesCallbacks[uniqueId]) {
                             messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
-                        }*/
+                        }
 
-                        fireEvent('callEvents', {
-                            type: 'ASSISTANT_CALL_ENDED'
+                       fireEvent('callEvents', {
+                            type: 'CALL_ENDED',
+                            result: messageContent
                         });
 
+                        callStop();
+
                         break;
 
                     /**
-                     * Type 999   All unknown errors
+                     * Type 77    Get Calls History
                      */
-                    case chatMessageVOTypes.ERROR:
+                    case chatMessageVOTypes.GET_CALLS:
                         if (messagesCallbacks[uniqueId]) {
-                            messagesCallbacks[uniqueId](Utility.createReturnData(true, messageContent.message, messageContent.code, messageContent, 0));
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
 
-                        /**
-                         * If error code is 21, Token is invalid &
-                         * user should logged out
-                         */
-                        if (messageContent.code == 21) {
-                            // TODO: Temporarily removed due to unknown side-effects
-                            // chatState = false;
-                            // asyncClient.logout();
-                            // clearChatServerCaches();
-                        }
+                        break;
 
-                        fireEvent('error', {
-                            code: messageContent.code,
-                            message: messageContent.message,
-                            error: messageContent
+
+                    /**
+                     * Type 90    Contacts Synced
+                     */
+                    case chatMessageVOTypes.CONTACT_SYNCED:
+                        fireEvent('contactEvents', {
+                            type: 'CONTACTS_SYNCED',
+                            result: messageContent
                         });
                         break;
-                }
-            },
 
-            /**
-             * Send Message Callbacks Handler
-             *
-             * When you send Delivery or Seen Acknowledgements of a message
-             * You should send Delivery and Seen for all the Messages before
-             * that message so that you wont have un delivered/unseen messages
-             * after seeing the last message of a thread
-             *
-             * @access private
-             *
-             * @param {int}     actionType      Switch between Delivery or Seen
-             * @param {long}    threadId        Id of thread
-             * @param {string}  uniqueId        uniqueId of message
-             *
-             * @return {undefined}
-             */
-            sendMessageCallbacksHandler = function (actionType, threadId, uniqueId) {
-                switch (actionType) {
+                    /**
+                     * Type 91    Send Group Call Request
+                     */
+                    case chatMessageVOTypes.GROUP_CALL_REQUEST:
+                        callRequestController.callRequestReceived = true;
+                        callReceived({
+                            callId: messageContent.callId
+                        }, function (r) {});
 
-                    case chatMessageVOTypes.DELIVERY:
-                        if (threadCallbacks[threadId]) {
-                            var lastThreadCallbackIndex = Object.keys(threadCallbacks[threadId])
-                                .indexOf(uniqueId);
-                            if (lastThreadCallbackIndex !== undefined) {
-                                while (lastThreadCallbackIndex > -1) {
-                                    var tempUniqueId = Object.entries(threadCallbacks[threadId])[lastThreadCallbackIndex][0];
-                                    if (sendMessageCallbacks[tempUniqueId] && sendMessageCallbacks[tempUniqueId].onDeliver) {
-                                        if (threadCallbacks[threadId][tempUniqueId] && threadCallbacks[threadId][tempUniqueId].onSent) {
-                                            sendMessageCallbacks[tempUniqueId].onDeliver(
-                                                {
-                                                    uniqueId: tempUniqueId
-                                                });
-                                            delete (sendMessageCallbacks[tempUniqueId].onDeliver);
-                                            threadCallbacks[threadId][tempUniqueId].onDeliver = true;
-                                        }
-                                    }
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
 
-                                    lastThreadCallbackIndex -= 1;
-                                }
-                            }
+                        fireEvent('callEvents', {
+                            type: 'RECEIVE_CALL',
+                            result: messageContent
+                        });
+
+                        currentCallId = messageContent.callId;
+
+                        break;
+
+                    /**
+                     * Type 92    Call Partner Leave
+                     */
+                    case chatMessageVOTypes.LEAVE_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
+
+                        fireEvent('callEvents', {
+                            type: 'CALL_PARTICIPANT_LEFT',
+                            result: messageContent
+                        });
+
                         break;
 
-                    case chatMessageVOTypes.SEEN:
-                        if (threadCallbacks[threadId]) {
-                            var lastThreadCallbackIndex = Object.keys(threadCallbacks[threadId])
-                                .indexOf(uniqueId);
-                            if (lastThreadCallbackIndex !== undefined) {
-                                while (lastThreadCallbackIndex > -1) {
-                                    var tempUniqueId = Object.entries(threadCallbacks[threadId])[lastThreadCallbackIndex][0];
+                    /**
+                     * Type 93    Add Call Participant
+                     */
+                    case chatMessageVOTypes.ADD_CALL_PARTICIPANT:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
 
-                                    if (sendMessageCallbacks[tempUniqueId] && sendMessageCallbacks[tempUniqueId].onSeen) {
-                                        if (threadCallbacks[threadId][tempUniqueId] && threadCallbacks[threadId][tempUniqueId].onSent) {
-                                            if (!threadCallbacks[threadId][tempUniqueId].onDeliver) {
-                                                sendMessageCallbacks[tempUniqueId].onDeliver(
-                                                    {
-                                                        uniqueId: tempUniqueId
-                                                    });
-                                                delete (sendMessageCallbacks[tempUniqueId].onDeliver);
-                                                threadCallbacks[threadId][tempUniqueId].onDeliver = true;
-                                            }
+                        break;
 
-                                            sendMessageCallbacks[tempUniqueId].onSeen(
-                                                {
-                                                    uniqueId: tempUniqueId
-                                                });
+                    /**
+                     * Type 94    Call Participant Joined
+                     */
+                    case chatMessageVOTypes.CALL_PARTICIPANT_JOINED:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
 
-                                            delete (sendMessageCallbacks[tempUniqueId].onSeen);
-                                            threadCallbacks[threadId][tempUniqueId].onSeen = true;
+                        fireEvent('callEvents', {
+                            type: 'CALL_PARTICIPANT_JOINED',
+                            result: messageContent
+                        });
 
-                                            if (threadCallbacks[threadId][tempUniqueId].onSent &&
-                                                threadCallbacks[threadId][tempUniqueId].onDeliver &&
-                                                threadCallbacks[threadId][tempUniqueId].onSeen) {
-                                                delete threadCallbacks[threadId][tempUniqueId];
-                                                delete sendMessageCallbacks[tempUniqueId];
-                                            }
-                                        }
-                                    }
+                        break;
 
-                                    lastThreadCallbackIndex -= 1;
-                                }
-                            }
+                    /**
+                     * Type 95    Remove Call Participant
+                     */
+                    case chatMessageVOTypes.REMOVE_CALL_PARTICIPANT:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
                         }
+
+                        fireEvent('callEvents', {
+                            type: 'CALL_PARTICIPANT_REMOVED',
+                            result: messageContent
+                        });
+
                         break;
 
-                    default:
+                    /**
+                     * Type 96    Terminate Call
+                     */
+                    case chatMessageVOTypes.TERMINATE_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'TERMINATE_CALL',
+                            result: messageContent
+                        });
+
+                        callStop();
+
                         break;
-                }
-            },
 
-            /**
-             * New Message Handler
-             *
-             * Handles Event Emitter of a newly received Chat Message
-             *
-             * @access private
-             *
-             * @param {long}    threadId         ID of image
+                    /**
+                     * Type 97    Mute Call Participant
+                     */
+                    case chatMessageVOTypes.MUTE_CALL_PARTICIPANT:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+
+                        fireEvent('callEvents', {
+                            type: 'CALL_PARTICIPANT_MUTE',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 98    UnMute Call Participant
+                     */
+                    case chatMessageVOTypes.UNMUTE_CALL_PARTICIPANT:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        } else {
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'CALL_PARTICIPANT_UNMUTE',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 110    Active Call Participants List
+                     */
+                    case chatMessageVOTypes.ACTIVE_CALL_PARTICIPANTS:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        break;
+
+                    /**
+                     * Type 111    Kafka Call Session Created
+                     */
+                    case chatMessageVOTypes.CALL_SESSION_CREATED:
+                        if(!callRequestController.callEstablishedInMySide)
+                            return;
+
+                        fireEvent('callEvents', {
+                            type: 'CALL_SESSION_CREATED',
+                            result: messageContent
+                        });
+
+                        currentCallId = messageContent.callId;
+
+                        break;
+
+                    /**
+                     * Type 113    Turn On Video Call
+                     */
+                    case chatMessageVOTypes.TURN_ON_VIDEO_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'TURN_ON_VIDEO_CALL',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 114    Turn Off Video Call
+                     */
+                    case chatMessageVOTypes.TURN_OFF_VIDEO_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'TURN_OFF_VIDEO_CALL',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 121    Record Call Request
+                     */
+                    case chatMessageVOTypes.RECORD_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'START_RECORDING_CALL',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 122   End Record Call Request
+                     */
+                    case chatMessageVOTypes.END_RECORD_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'STOP_RECORDING_CALL',
+                            result: messageContent
+                        });
+
+                        break;
+
+                    /**
+                     * Type 126   Destined Record Call Request
+                     */
+                    case chatMessageVOTypes.DESTINATED_RECORD_CALL:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }
+
+                        fireEvent('callEvents', {
+                            type: 'START_RECORDING_CALL',
+                            result: messageContent
+                        });
+
+                        break;
+
+                     /**
+                     * Type 127   Assistant call started
+                     *
+                     * Tells the assistant that a call started
+                     */
+                    case chatMessageVOTypes.ASSISTANT_CALL_STARTED:
+                        /*if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }*/
+
+                        fireEvent('callEvents', {
+                            type: 'ASSISTANT_CALL_STARTED',
+                            result: {
+                                callId: threadId
+                            }
+                        });
+
+                        break;
+
+                     /**
+                     * Type 128   Assistant call ended
+                     *
+                     * Tells the assistant that a call ended
+                     */
+                    case chatMessageVOTypes.ASSISTANT_CALL_ENDED:
+                       /* if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                        }*/
+
+                        fireEvent('callEvents', {
+                            type: 'ASSISTANT_CALL_ENDED'
+                        });
+
+                        break;
+
+                    /**
+                     * Type 999   All unknown errors
+                     */
+                    case chatMessageVOTypes.ERROR:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(true, messageContent.message, messageContent.code, messageContent, 0));
+                        }
+
+                        /**
+                         * If error code is 21, Token is invalid &
+                         * user should logged out
+                         */
+                        if (messageContent.code == 21) {
+                            // TODO: Temporarily removed due to unknown side-effects
+                            // chatState = false;
+                            // asyncClient.logout();
+                            // clearChatServerCaches();
+                        }
+
+                        fireEvent('error', {
+                            code: messageContent.code,
+                            message: messageContent.message,
+                            error: messageContent
+                        });
+
+                        break;
+                }
+            },
+
+            /**
+             * Send Message Callbacks Handler
+             *
+             * When you send Delivery or Seen Acknowledgements of a message
+             * You should send Delivery and Seen for all the Messages before
+             * that message so that you wont have un delivered/unseen messages
+             * after seeing the last message of a thread
+             *
+             * @access private
+             *
+             * @param {int}     actionType      Switch between Delivery or Seen
+             * @param {long}    threadId        Id of thread
+             * @param {string}  uniqueId        uniqueId of message
+             *
+             * @return {undefined}
+             */
+            sendMessageCallbacksHandler = function (actionType, threadId, uniqueId) {
+                switch (actionType) {
+
+                    case chatMessageVOTypes.DELIVERY:
+                        if (threadCallbacks[threadId]) {
+                            var lastThreadCallbackIndex = Object.keys(threadCallbacks[threadId])
+                                .indexOf(uniqueId);
+                            if (lastThreadCallbackIndex !== undefined) {
+                                while (lastThreadCallbackIndex > -1) {
+                                    var tempUniqueId = Object.entries(threadCallbacks[threadId])[lastThreadCallbackIndex][0];
+                                    if (sendMessageCallbacks[tempUniqueId] && sendMessageCallbacks[tempUniqueId].onDeliver) {
+                                        if (threadCallbacks[threadId][tempUniqueId] && threadCallbacks[threadId][tempUniqueId].onSent) {
+                                            sendMessageCallbacks[tempUniqueId].onDeliver(
+                                                {
+                                                    uniqueId: tempUniqueId
+                                                });
+                                            delete (sendMessageCallbacks[tempUniqueId].onDeliver);
+                                            threadCallbacks[threadId][tempUniqueId].onDeliver = true;
+                                        }
+                                    }
+
+                                    lastThreadCallbackIndex -= 1;
+                                }
+                            }
+                        }
+                        break;
+
+                    case chatMessageVOTypes.SEEN:
+                        if (threadCallbacks[threadId]) {
+                            var lastThreadCallbackIndex = Object.keys(threadCallbacks[threadId])
+                                .indexOf(uniqueId);
+                            if (lastThreadCallbackIndex !== undefined) {
+                                while (lastThreadCallbackIndex > -1) {
+                                    var tempUniqueId = Object.entries(threadCallbacks[threadId])[lastThreadCallbackIndex][0];
+
+                                    if (sendMessageCallbacks[tempUniqueId] && sendMessageCallbacks[tempUniqueId].onSeen) {
+                                        if (threadCallbacks[threadId][tempUniqueId] && threadCallbacks[threadId][tempUniqueId].onSent) {
+                                            if (!threadCallbacks[threadId][tempUniqueId].onDeliver) {
+                                                sendMessageCallbacks[tempUniqueId].onDeliver(
+                                                    {
+                                                        uniqueId: tempUniqueId
+                                                    });
+                                                delete (sendMessageCallbacks[tempUniqueId].onDeliver);
+                                                threadCallbacks[threadId][tempUniqueId].onDeliver = true;
+                                            }
+
+                                            sendMessageCallbacks[tempUniqueId].onSeen(
+                                                {
+                                                    uniqueId: tempUniqueId
+                                                });
+
+                                            delete (sendMessageCallbacks[tempUniqueId].onSeen);
+                                            threadCallbacks[threadId][tempUniqueId].onSeen = true;
+
+                                            if (threadCallbacks[threadId][tempUniqueId].onSent &&
+                                                threadCallbacks[threadId][tempUniqueId].onDeliver &&
+                                                threadCallbacks[threadId][tempUniqueId].onSeen) {
+                                                delete threadCallbacks[threadId][tempUniqueId];
+                                                delete sendMessageCallbacks[tempUniqueId];
+                                            }
+                                        }
+                                    }
+
+                                    lastThreadCallbackIndex -= 1;
+                                }
+                            }
+                        }
+                        break;
+
+                    default:
+                        break;
+                }
+            },
+
+            /**
+             * New Message Handler
+             *
+             * Handles Event Emitter of a newly received Chat Message
+             *
+             * @access private
+             *
+             * @param {long}    threadId         ID of image
              * @param {object}  messageContent   Json Content of the message
              *
              * @return {undefined}
@@ -8691,16 +9086,171 @@
                     // separate out the mime component
                     var mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
 
-                    // write the bytes of the string to a typed array
-                    var ia = new Uint8Array(byteString.length);
-                    for (var i = 0; i < byteString.length; i++) {
-                        ia[i] = byteString.charCodeAt(i);
-                    }
+                    // write the bytes of the string to a typed array
+                    var ia = new Uint8Array(byteString.length);
+                    for (var i = 0; i < byteString.length; i++) {
+                        ia[i] = byteString.charCodeAt(i);
+                    }
+
+                    return callback(new Blob([ia], {type: mimeString}));
+                }
+
+                img.src = url;
+            },
+
+            callReceived = function (params, callback) {
+                var receiveCallData = {
+                    chatMessageVOType: chatMessageVOTypes.RECEIVE_CALL_REQUEST,
+                    typeCode: params.typeCode,
+                    pushMsgType: 3,
+                    token: token
+                };
+
+                if (params) {
+                    if (typeof +params.callId === 'number' && params.callId > 0) {
+                        receiveCallData.subjectId = +params.callId;
+                    } else {
+                        fireEvent('error', {
+                            code: 999,
+                            message: 'Invalid call id!'
+                        });
+                        return;
+                    }
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'No params have been sent to ReceiveCall()'
+                    });
+                    return;
+                }
+
+                return sendMessage(receiveCallData, {
+                    onResult: function (result) {
+                        callback && callback(result);
+                    }
+                });
+            },
+
+            endCall = function (params, callback) {
+                consoleLogging && console.log('[SDK][endCall] called...');
+
+                var endCallData = {
+                    chatMessageVOType: chatMessageVOTypes.END_CALL_REQUEST,
+                    typeCode: params.typeCode,
+                    pushMsgType: 3,
+                    token: token
+                };
+
+                if (!callRequestController.callEstablishedInMySide) {
+                    return;
+                }
+
+                if (params) {
+                    if (typeof +params.callId === 'number' && params.callId > 0) {
+                        endCallData.subjectId = +params.callId;
+                    } else {
+                        fireEvent('error', {
+                            code: 999,
+                            message: 'Invalid call id!'
+                        });
+                        return;
+                    }
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'No params have been sent to End the call!'
+                    });
+                    return;
+                }
+
+                callStop();
+
+                return sendMessage(endCallData, {
+                    onResult: function (result) {
+                        callback && callback(result);
+                    }
+                });
+            },
+
+            callStop = function () {
+                    if (callStopQueue.callStarted) {
+                        callStopQueue.callStarted = false;
+                    }
+
+                    callRequestController.callEstablishedInMySide = false;
+                    callRequestController.callRequestReceived = false;
+                    currentCallParams = {};
+                    currentCallId = null;
+                },
+
+            /**
+             * Reformat Call Participants
+             *
+             * This functions reformats given Array of call Participants
+             * into proper call participant
+             *
+             * @access private
+             *
+             * @param {object}  participantsContent   Array of Call Participant Objects
+             * @param {int}    threadId              Id of call
+             *
+             * @return {object} Formatted Call Participant Array
+             */
+            reformatCallParticipants = function (participantsContent) {
+                var returnData = [];
+
+                for (var i = 0; i < participantsContent.length; i++) {
+                    returnData.push(formatDataToMakeCallParticipant(participantsContent[i]));
+                }
+
+                return returnData;
+            },
+
+            formatDataToMakeCallParticipant = function (messageContent) {
+                /**
+                 * + CallParticipantVO                   {object}
+                 *    - id                           {int}
+                 *    - joinTime                     {int}
+                 *    - leaveTime                    {int}
+                 *    - threadParticipant            {object}
+                 *    - sendTopic                    {string}
+                 *    - receiveTopic                 {string}
+                 *    - brokerAddress                {string}
+                 *    - active                       {boolean}
+                 *    - callSession                  {object}
+                 *    - callStatus                   {int}
+                 *    - createTime                   {int}
+                 *    - sendKey                      {string}
+                 *    - mute                         {boolean}
+                 */
+
+                var participant = {
+                    id: messageContent.id,
+                    joinTime: messageContent.joinTime,
+                    leaveTime: messageContent.leaveTime,
+                    sendTopic: messageContent.sendTopic,
+                    receiveTopic: messageContent.receiveTopic,
+                    brokerAddress: messageContent.brokerAddress,
+                    active: messageContent.active,
+                    callSession: messageContent.callSession,
+                    callStatus: messageContent.callStatus,
+                    createTime: messageContent.createTime,
+                    sendKey: messageContent.sendKey,
+                    mute: messageContent.mute
+                };
+
+                // Add Chat Participant if exist
+                if (messageContent.participantVO) {
+                    participant.participantVO = messageContent.participantVO;
+                }
 
-                    return callback(new Blob([ia], {type: mimeString}));
+                // Add Call Session if exist
+                if (messageContent.callSession) {
+                    participant.callSession = messageContent.callSession;
                 }
 
-                img.src = url;
+                // return participant;
+                return JSON.parse(JSON.stringify(participant));
             };
 
         /******************************************************
@@ -10407,218 +10957,765 @@
                 timeout: params.timeout
             };
 
-            if (params) {
-                if (parseInt(params.contactId) > 0) {
-                    blockData.content.contactId = params.contactId;
-                }
+            if (params) {
+                if (parseInt(params.contactId) > 0) {
+                    blockData.content.contactId = params.contactId;
+                }
+
+                if (parseInt(params.threadId) > 0) {
+                    blockData.content.threadId = params.threadId;
+                }
+
+                if (parseInt(params.userId) > 0) {
+                    blockData.content.userId = params.userId;
+                }
+            }
+
+            return sendMessage(blockData, {
+                onResult: function (result) {
+                    if (typeof result.result == 'object') {
+                        result.result = formatDataToMakeBlockedUser(result.result);
+                    }
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.unblock = function (params, callback) {
+            var unblockData = {
+                chatMessageVOType: chatMessageVOTypes.UNBLOCK,
+                typeCode: params.typeCode,
+                pushMsgType: 4,
+                token: token,
+                content: {},
+                timeout: params.timeout
+            };
+
+            if (params) {
+                if (parseInt(params.blockId) > 0) {
+                    unblockData.subjectId = params.blockId;
+                }
+
+                if (parseInt(params.contactId) > 0) {
+                    unblockData.content.contactId = params.contactId;
+                }
+
+                if (parseInt(params.threadId) > 0) {
+                    unblockData.content.threadId = params.threadId;
+                }
+
+                if (parseInt(params.userId) > 0) {
+                    unblockData.content.userId = params.userId;
+                }
+            }
+
+            return sendMessage(unblockData, {
+                onResult: function (result) {
+                    if (typeof result.result == 'object') {
+                        result.result = formatDataToMakeBlockedUser(result.result);
+                    }
+
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.getBlockedList = function (params, callback) {
+            var count = 50,
+                offset = 0,
+                content = {};
+
+            if (params) {
+                if (parseInt(params.count) > 0) {
+                    count = params.count;
+                }
+
+                if (parseInt(params.offset) > 0) {
+                    offset = params.offset;
+                }
+            }
+
+            content.count = count;
+            content.offset = offset;
+
+            var getBlockedData = {
+                chatMessageVOType: chatMessageVOTypes.GET_BLOCKED,
+                typeCode: params.typeCode,
+                content: content,
+                pushMsgType: 4,
+                token: token,
+                timeout: params.timeout
+            };
+
+            return sendMessage(getBlockedData, {
+                onResult: function (result) {
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
+                    };
+
+                    if (!returnData.hasError) {
+                        var messageContent = result.result,
+                            messageLength = messageContent.length,
+                            resultData = {
+                                blockedUsers: [],
+                                contentCount: result.contentCount,
+                                hasNext: (offset + count < result.contentCount && messageLength > 0),
+                                nextOffset: offset + messageLength
+                            },
+                            blockedUser;
+
+                        for (var i = 0; i < messageLength; i++) {
+                            blockedUser = formatDataToMakeBlockedUser(messageContent[i]);
+                            if (blockedUser) {
+                                resultData.blockedUsers.push(blockedUser);
+                            }
+                        }
+
+                        returnData.result = resultData;
+                    }
+
+                    callback && callback(returnData);
+                }
+            });
+        };
+
+        this.getUserNotSeenDuration = function (params, callback) {
+            var content = {};
+
+            if (params) {
+                if (Array.isArray(params.userIds)) {
+                    content.userIds = params.userIds;
+                }
+            }
+
+            var getNotSeenDurationData = {
+                chatMessageVOType: chatMessageVOTypes.GET_NOT_SEEN_DURATION,
+                typeCode: params.typeCode,
+                content: content,
+                pushMsgType: 4,
+                token: token,
+                timeout: params.timeout
+            };
+
+            return sendMessage(getNotSeenDurationData, {
+                onResult: function (result) {
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
+                    };
+
+                    if (!returnData.hasError) {
+                        returnData.result = result.result;
+                    }
+
+                    callback && callback(returnData);
+                }
+            });
+        };
+
+        this.addContacts = function (params, callback) {
+            var data = {};
+
+            if (params) {
+                if (typeof params.firstName === 'string') {
+                    data.firstName = params.firstName;
+                } else {
+                    data.firstName = '';
+                }
+
+                if (typeof params.lastName === 'string') {
+                    data.lastName = params.lastName;
+                } else {
+                    data.lastName = '';
+                }
+
+                if (typeof params.typeCode === 'string') {
+                    data.typeCode = params.typeCode;
+                } else if (generalTypeCode) {
+                    data.typeCode = generalTypeCode;
+                }
+
+                if (typeof params.cellphoneNumber === 'string') {
+                    data.cellphoneNumber = params.cellphoneNumber;
+                } else {
+                    data.cellphoneNumber = '';
+                }
+
+                if (typeof params.email === 'string') {
+                    data.email = params.email;
+                } else {
+                    data.email = '';
+                }
+
+                if (typeof params.username === 'string') {
+                    data.username = params.username;
+                }
+
+                data.uniqueId = Utility.generateUUID();
+            }
+
+            var requestParams = {
+                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.ADD_CONTACTS,
+                method: 'POST',
+                data: data,
+                headers: {
+                    '_token_': token,
+                    '_token_issuer_': 1
+                }
+            };
+
+            httpRequest(requestParams, function (result) {
+                if (!result.hasError) {
+                    var responseData = JSON.parse(result.result.responseText);
+
+                    var returnData = {
+                        hasError: responseData.hasError,
+                        cache: false,
+                        errorMessage: responseData.message,
+                        errorCode: responseData.errorCode
+                    };
+
+                    if (!responseData.hasError) {
+                        var messageContent = responseData.result,
+                            messageLength = responseData.result.length,
+                            resultData = {
+                                contacts: [],
+                                contentCount: messageLength
+                            },
+                            contactData;
+
+                        for (var i = 0; i < messageLength; i++) {
+                            contactData = formatDataToMakeContact(messageContent[i]);
+                            if (contactData) {
+                                resultData.contacts.push(contactData);
+                            }
+                        }
+
+                        returnData.result = resultData;
+
+                        /**
+                         * Add Contacts into cache database #cache
+                         */
+                        if (canUseCache && cacheSecret.length > 0) {
+                            if (db) {
+                                var cacheData = [];
+
+                                for (var i = 0; i < resultData.contacts.length; i++) {
+                                    try {
+                                        var tempData = {},
+                                            salt = Utility.generateUUID();
+                                        tempData.id = resultData.contacts[i].id;
+                                        tempData.owner = userInfo.id;
+                                        tempData.uniqueId = resultData.contacts[i].uniqueId;
+                                        tempData.userId = Utility.crypt(resultData.contacts[i].userId, cacheSecret, salt);
+                                        tempData.cellphoneNumber = Utility.crypt(resultData.contacts[i].cellphoneNumber, cacheSecret, salt);
+                                        tempData.email = Utility.crypt(resultData.contacts[i].email, cacheSecret, salt);
+                                        tempData.firstName = Utility.crypt(resultData.contacts[i].firstName, cacheSecret, salt);
+                                        tempData.lastName = Utility.crypt(resultData.contacts[i].lastName, cacheSecret, salt);
+                                        tempData.expireTime = new Date().getTime() + cacheExpireTime;
+                                        tempData.data = Utility.crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
+                                        tempData.salt = salt;
 
-                if (parseInt(params.threadId) > 0) {
-                    blockData.content.threadId = params.threadId;
-                }
+                                        cacheData.push(tempData);
+                                    } catch (error) {
+                                        fireEvent('error', {
+                                            code: error.code,
+                                            message: error.message,
+                                            error: error
+                                        });
+                                    }
+                                }
 
-                if (parseInt(params.userId) > 0) {
-                    blockData.content.userId = params.userId;
-                }
-            }
+                                db.contacts.bulkPut(cacheData)
+                                    .catch(function (error) {
+                                        fireEvent('error', {
+                                            code: error.code,
+                                            message: error.message,
+                                            error: error
+                                        });
+                                    });
+                            } else {
+                                fireEvent('error', {
+                                    code: 6601,
+                                    message: CHAT_ERRORS[6601],
+                                    error: null
+                                });
+                            }
+                        }
 
-            return sendMessage(blockData, {
-                onResult: function (result) {
-                    if (typeof result.result == 'object') {
-                        result.result = formatDataToMakeBlockedUser(result.result);
                     }
-                    callback && callback(result);
+
+                    callback && callback(returnData);
+
+                } else {
+                    fireEvent('error', {
+                        code: result.errorCode,
+                        message: result.errorMessage,
+                        error: result
+                    });
                 }
             });
         };
 
-        this.unblock = function (params, callback) {
-            var unblockData = {
-                chatMessageVOType: chatMessageVOTypes.UNBLOCK,
-                typeCode: params.typeCode,
-                pushMsgType: 4,
-                token: token,
-                content: {},
-                timeout: params.timeout
-            };
+        this.updateContacts = function (params, callback) {
+            var data = {};
 
             if (params) {
-                if (parseInt(params.blockId) > 0) {
-                    unblockData.subjectId = params.blockId;
-                }
-
-                if (parseInt(params.contactId) > 0) {
-                    unblockData.content.contactId = params.contactId;
+                if (parseInt(params.id) > 0) {
+                    data.id = parseInt(params.id);
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'ID is required for Updating Contact!',
+                        error: undefined
+                    });
                 }
 
-                if (parseInt(params.threadId) > 0) {
-                    unblockData.content.threadId = params.threadId;
+                if (typeof params.firstName === 'string') {
+                    data.firstName = params.firstName;
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'firstName is required for Updating Contact!'
+                    });
                 }
 
-                if (parseInt(params.userId) > 0) {
-                    unblockData.content.userId = params.userId;
+                if (typeof params.lastName === 'string') {
+                    data.lastName = params.lastName;
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'lastName is required for Updating Contact!'
+                    });
                 }
-            }
 
-            return sendMessage(unblockData, {
-                onResult: function (result) {
-                    if (typeof result.result == 'object') {
-                        result.result = formatDataToMakeBlockedUser(result.result);
-                    }
-
-                    callback && callback(result);
+                if (typeof params.cellphoneNumber === 'string') {
+                    data.cellphoneNumber = params.cellphoneNumber;
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'cellphoneNumber is required for Updating Contact!'
+                    });
                 }
-            });
-        };
 
-        this.getBlockedList = function (params, callback) {
-            var count = 50,
-                offset = 0,
-                content = {};
-
-            if (params) {
-                if (parseInt(params.count) > 0) {
-                    count = params.count;
+                if (typeof params.email === 'string') {
+                    data.email = params.email;
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'email is required for Updating Contact!'
+                    });
                 }
 
-                if (parseInt(params.offset) > 0) {
-                    offset = params.offset;
-                }
+                data.uniqueId = Utility.generateUUID();
             }
 
-            content.count = count;
-            content.offset = offset;
-
-            var getBlockedData = {
-                chatMessageVOType: chatMessageVOTypes.GET_BLOCKED,
-                typeCode: params.typeCode,
-                content: content,
-                pushMsgType: 4,
-                token: token,
-                timeout: params.timeout
+            var requestParams = {
+                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS +
+                    SERVICES_PATH.UPDATE_CONTACTS,
+                method: 'GET',
+                data: data,
+                headers: {
+                    '_token_': token,
+                    '_token_issuer_': 1
+                }
             };
 
-            return sendMessage(getBlockedData, {
-                onResult: function (result) {
+            httpRequest(requestParams, function (result) {
+                if (!result.hasError) {
+                    var responseData = JSON.parse(result.result.responseText);
+
                     var returnData = {
-                        hasError: result.hasError,
+                        hasError: responseData.hasError,
                         cache: false,
-                        errorMessage: result.errorMessage,
-                        errorCode: result.errorCode
+                        errorMessage: responseData.message,
+                        errorCode: responseData.errorCode
                     };
 
-                    if (!returnData.hasError) {
-                        var messageContent = result.result,
-                            messageLength = messageContent.length,
+                    if (!responseData.hasError) {
+                        var messageContent = responseData.result,
+                            messageLength = responseData.result.length,
                             resultData = {
-                                blockedUsers: [],
-                                contentCount: result.contentCount,
-                                hasNext: (offset + count < result.contentCount && messageLength > 0),
-                                nextOffset: offset + messageLength
+                                contacts: [],
+                                contentCount: messageLength
                             },
-                            blockedUser;
+                            contactData;
 
                         for (var i = 0; i < messageLength; i++) {
-                            blockedUser = formatDataToMakeBlockedUser(messageContent[i]);
-                            if (blockedUser) {
-                                resultData.blockedUsers.push(blockedUser);
+                            contactData = formatDataToMakeContact(messageContent[i]);
+                            if (contactData) {
+                                resultData.contacts.push(contactData);
                             }
                         }
 
                         returnData.result = resultData;
+
+                        /**
+                         * Add Contacts into cache database #cache
+                         */
+                        if (canUseCache && cacheSecret.length > 0) {
+                            if (db) {
+                                var cacheData = [];
+
+                                for (var i = 0; i < resultData.contacts.length; i++) {
+                                    try {
+                                        var tempData = {},
+                                            salt = Utility.generateUUID();
+                                        tempData.id = resultData.contacts[i].id;
+                                        tempData.owner = userInfo.id;
+                                        tempData.uniqueId = resultData.contacts[i].uniqueId;
+                                        tempData.userId = Utility.crypt(resultData.contacts[i].userId, cacheSecret, salt);
+                                        tempData.cellphoneNumber = Utility.crypt(resultData.contacts[i].cellphoneNumber, cacheSecret, salt);
+                                        tempData.email = Utility.crypt(resultData.contacts[i].email, cacheSecret, salt);
+                                        tempData.firstName = Utility.crypt(resultData.contacts[i].firstName, cacheSecret, salt);
+                                        tempData.lastName = Utility.crypt(resultData.contacts[i].lastName, cacheSecret, salt);
+                                        tempData.expireTime = new Date().getTime() + cacheExpireTime;
+                                        tempData.data = Utility.crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
+                                        tempData.salt = salt;
+
+                                        cacheData.push(tempData);
+                                    } catch (error) {
+                                        fireEvent('error', {
+                                            code: error.code,
+                                            message: error.message,
+                                            error: error
+                                        });
+                                    }
+                                }
+
+                                db.contacts.bulkPut(cacheData)
+                                    .catch(function (error) {
+                                        fireEvent('error', {
+                                            code: error.code,
+                                            message: error.message,
+                                            error: error
+                                        });
+                                    });
+                            } else {
+                                fireEvent('error', {
+                                    code: 6601,
+                                    message: CHAT_ERRORS[6601],
+                                    error: null
+                                });
+                            }
+                        }
+
                     }
 
                     callback && callback(returnData);
+
+                } else {
+                    fireEvent('error', {
+                        code: result.errorCode,
+                        message: result.errorMessage,
+                        error: result
+                    });
                 }
             });
         };
 
-        this.getUserNotSeenDuration = function (params, callback) {
-            var content = {};
+        this.removeContacts = function (params, callback) {
+            var data = {};
 
             if (params) {
-                if (Array.isArray(params.userIds)) {
-                    content.userIds = params.userIds;
+                if (parseInt(params.id) > 0) {
+                    data.id = parseInt(params.id);
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'ID is required for Deleting Contact!',
+                        error: undefined
+                    });
                 }
             }
 
-            var getNotSeenDurationData = {
-                chatMessageVOType: chatMessageVOTypes.GET_NOT_SEEN_DURATION,
-                typeCode: params.typeCode,
-                content: content,
-                pushMsgType: 4,
-                token: token,
-                timeout: params.timeout
+            var requestParams = {
+                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.REMOVE_CONTACTS,
+                method: 'POST',
+                data: data,
+                headers: {
+                    '_token_': token,
+                    '_token_issuer_': 1
+                }
             };
 
-            return sendMessage(getNotSeenDurationData, {
-                onResult: function (result) {
+            httpRequest(requestParams, function (result) {
+                if (!result.hasError) {
+                    var responseData = JSON.parse(result.result.responseText);
+
                     var returnData = {
-                        hasError: result.hasError,
+                        hasError: responseData.hasError,
                         cache: false,
-                        errorMessage: result.errorMessage,
-                        errorCode: result.errorCode
+                        errorMessage: responseData.message,
+                        errorCode: responseData.errorCode
                     };
 
-                    if (!returnData.hasError) {
-                        returnData.result = result.result;
+                    if (!responseData.hasError) {
+                        returnData.result = responseData.result;
+                    }
+
+                    /**
+                     * Remove the contact from cache
+                     */
+                    if (canUseCache) {
+                        if (db) {
+                            db.contacts.where('id')
+                                .equals(parseInt(params.id))
+                                .delete()
+                                .catch(function (error) {
+                                    fireEvent('error', {
+                                        code: 6602,
+                                        message: CHAT_ERRORS[6602],
+                                        error: error
+                                    });
+                                });
+                        } else {
+                            fireEvent('error', {
+                                code: 6601,
+                                message: CHAT_ERRORS[6601],
+                                error: null
+                            });
+                        }
                     }
 
                     callback && callback(returnData);
+
+                } else {
+                    fireEvent('error', {
+                        code: result.errorCode,
+                        message: result.errorMessage,
+                        error: result
+                    });
                 }
             });
         };
 
-        this.addContacts = function (params, callback) {
-            var data = {};
+        this.searchContacts = function (params, callback) {
+            var data = {
+                    size: 50,
+                    offset: 0
+                },
+                whereClause = {},
+                returnCache = false;
 
             if (params) {
                 if (typeof params.firstName === 'string') {
-                    data.firstName = params.firstName;
-                } else {
-                    data.firstName = '';
+                    data.firstName = whereClause.firstName = params.firstName;
                 }
 
                 if (typeof params.lastName === 'string') {
-                    data.lastName = params.lastName;
-                } else {
-                    data.lastName = '';
+                    data.lastName = whereClause.lastName = params.lastName;
                 }
 
-                if (typeof params.typeCode === 'string') {
-                    data.typeCode = params.typeCode;
-                } else if (generalTypeCode) {
-                    data.typeCode = generalTypeCode;
+                if (parseInt(params.cellphoneNumber) > 0) {
+                    data.cellphoneNumber = whereClause.cellphoneNumber = params.cellphoneNumber;
                 }
 
-                if (typeof params.cellphoneNumber === 'string') {
-                    data.cellphoneNumber = params.cellphoneNumber;
-                } else {
-                    data.cellphoneNumber = '';
+                if (typeof params.email === 'string') {
+                    data.email = whereClause.email = params.email;
+                }
+
+                if (typeof params.query === 'string') {
+                    data.q = whereClause.q = params.query;
+                }
+
+                if (typeof params.uniqueId === 'string') {
+                    data.uniqueId = whereClause.uniqueId = params.uniqueId;
+                }
+
+                if (parseInt(params.id) > 0) {
+                    data.id = whereClause.id = params.id;
+                }
+
+                if (parseInt(params.typeCode) > 0) {
+                    data.typeCode = whereClause.typeCode = params.typeCode;
+                }
+
+                if (parseInt(params.size) > 0) {
+                    data.size = params.size;
+                }
+
+                if (parseInt(params.offset) > 0) {
+                    data.offset = params.offset;
+                }
+
+                var functionLevelCache = (typeof params.cache == 'boolean') ? params.cache : true;
+            }
+
+            var requestParams = {
+                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.SEARCH_CONTACTS,
+                method: 'POST',
+                data: data,
+                headers: {
+                    '_token_': token,
+                    '_token_issuer_': 1
                 }
+            };
+
+            /**
+             * Search contacts in cache #cache
+             */
+            if (functionLevelCache && canUseCache && cacheSecret.length > 0) {
+                if (db) {
+
+                    /**
+                     * First of all we delete all contacts those
+                     * expireTime has been expired. after that
+                     * we query our cache database to retrieve
+                     * what we wanted
+                     */
+                    db.contacts.where('expireTime')
+                        .below(new Date().getTime())
+                        .delete()
+                        .then(function () {
+
+                            /**
+                             * Query cache database to get contacts
+                             */
+
+                            var thenAble;
+
+                            if (Object.keys(whereClause).length === 0) {
+                                thenAble = db.contacts.where('owner')
+                                    .equals(parseInt(userInfo.id));
+                            } else {
+                                if (whereClause.hasOwnProperty('id')) {
+                                    thenAble = db.contacts.where('owner')
+                                        .equals(parseInt(userInfo.id))
+                                        .and(function (contact) {
+                                            return contact.id == whereClause.id;
+                                        });
+                                } else if (whereClause.hasOwnProperty('uniqueId')) {
+                                    thenAble = db.contacts.where('owner')
+                                        .equals(parseInt(userInfo.id))
+                                        .and(function (contact) {
+                                            return contact.uniqueId == whereClause.uniqueId;
+                                        });
+                                } else {
+                                    if (whereClause.hasOwnProperty('firstName')) {
+                                        thenAble = db.contacts.where('owner')
+                                            .equals(parseInt(userInfo.id))
+                                            .filter(function (contact) {
+                                                var reg = new RegExp(whereClause.firstName);
+                                                return reg.test(chatDecrypt(contact.firstName, cacheSecret, contact.salt));
+                                            });
+                                    }
+
+                                    if (whereClause.hasOwnProperty('lastName')) {
+                                        thenAble = db.contacts.where('owner')
+                                            .equals(parseInt(userInfo.id))
+                                            .filter(function (contact) {
+                                                var reg = new RegExp(whereClause.lastName);
+                                                return reg.test(chatDecrypt(contact.lastName, cacheSecret, contact.salt));
+                                            });
+                                    }
+
+                                    if (whereClause.hasOwnProperty('email')) {
+                                        thenAble = db.contacts.where('owner')
+                                            .equals(parseInt(userInfo.id))
+                                            .filter(function (contact) {
+                                                var reg = new RegExp(whereClause.email);
+                                                return reg.test(chatDecrypt(contact.email, cacheSecret, contact.salt));
+                                            });
+                                    }
+
+                                    if (whereClause.hasOwnProperty('q')) {
+                                        thenAble = db.contacts.where('owner')
+                                            .equals(parseInt(userInfo.id))
+                                            .filter(function (contact) {
+                                                var reg = new RegExp(whereClause.q);
+                                                return reg.test(chatDecrypt(contact.firstName, cacheSecret, contact.salt) + ' ' +
+                                                    chatDecrypt(contact.lastName, cacheSecret, contact.salt) + ' ' +
+                                                    chatDecrypt(contact.email, cacheSecret, contact.salt));
+                                            });
+                                    }
+                                }
+                            }
+
+                            thenAble.offset(data.offset)
+                                .limit(data.size)
+                                .toArray()
+                                .then(function (contacts) {
+                                    db.contacts.where('owner')
+                                        .equals(parseInt(userInfo.id))
+                                        .count()
+                                        .then(function (contactsCount) {
+                                            var cacheData = [];
+
+                                            for (var i = 0; i < contacts.length; i++) {
+                                                try {
+                                                    var tempData = {},
+                                                        salt = contacts[i].salt;
+
+                                                    cacheData.push(formatDataToMakeContact(JSON.parse(chatDecrypt(contacts[i].data, cacheSecret, ontacts[i].salt))));
+                                                } catch (error) {
+                                                    fireEvent('error', {
+                                                        code: error.code,
+                                                        message: error.message,
+                                                        error: error
+                                                    });
+                                                }
+                                            }
+
+                                            var returnData = {
+                                                hasError: false,
+                                                cache: true,
+                                                errorCode: 0,
+                                                errorMessage: '',
+                                                result: {
+                                                    contacts: cacheData,
+                                                    contentCount: contactsCount,
+                                                    hasNext: !(contacts.length < data.size),
+                                                    nextOffset: data.offset + contacts.length
+                                                }
+                                            };
 
-                if (typeof params.email === 'string') {
-                    data.email = params.email;
+                                            if (cacheData.length > 0) {
+                                                callback && callback(returnData);
+                                                callback = undefined;
+                                                returnCache = true;
+                                            }
+                                        })
+                                        .catch(function (error) {
+                                            fireEvent('error', {
+                                                code: error.code,
+                                                message: error.message,
+                                                error: error
+                                            });
+                                        });
+                                })
+                                .catch(function (error) {
+                                    fireEvent('error', {
+                                        code: error.code,
+                                        message: error.message,
+                                        error: error
+                                    });
+                                });
+                        })
+                        .catch(function (error) {
+                            fireEvent('error', {
+                                code: error.code,
+                                message: error.message,
+                                error: error
+                            });
+                        });
                 } else {
-                    data.email = '';
-                }
-
-                if (typeof params.username === 'string') {
-                    data.username = params.username;
+                    fireEvent('error', {
+                        code: 6601,
+                        message: CHAT_ERRORS[6601],
+                        error: null
+                    });
                 }
-
-                data.uniqueId = Utility.generateUUID();
             }
 
-            var requestParams = {
-                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.ADD_CONTACTS,
-                method: 'POST',
-                data: data,
-                headers: {
-                    '_token_': token,
-                    '_token_issuer_': 1
-                }
-            };
-
+            /**
+             * Get Search Contacts Result From Server
+             */
             httpRequest(requestParams, function (result) {
                 if (!result.hasError) {
                     var responseData = JSON.parse(result.result.responseText);
@@ -10659,6 +11756,7 @@
                                     try {
                                         var tempData = {},
                                             salt = Utility.generateUUID();
+
                                         tempData.id = resultData.contacts[i].id;
                                         tempData.owner = userInfo.id;
                                         tempData.uniqueId = resultData.contacts[i].uniqueId;
@@ -10668,7 +11766,7 @@
                                         tempData.firstName = Utility.crypt(resultData.contacts[i].firstName, cacheSecret, salt);
                                         tempData.lastName = Utility.crypt(resultData.contacts[i].lastName, cacheSecret, salt);
                                         tempData.expireTime = new Date().getTime() + cacheExpireTime;
-                                        tempData.data = Utility.crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
+                                        tempData.data = crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
                                         tempData.salt = salt;
 
                                         cacheData.push(tempData);
@@ -10697,11 +11795,21 @@
                                 });
                             }
                         }
-
                     }
 
                     callback && callback(returnData);
+                    /**
+                     * Delete callback so if server pushes response before
+                     * cache, cache won't send data again
+                     */
+                    callback = undefined;
 
+                    if (!returnData.hasError && returnCache) {
+                        fireEvent('contactEvents', {
+                            type: 'CONTACTS_SEARCH_RESULT_CHANGE',
+                            result: returnData.result
+                        });
+                    }
                 } else {
                     fireEvent('error', {
                         code: result.errorCode,
@@ -10712,67 +11820,285 @@
             });
         };
 
-        this.updateContacts = function (params, callback) {
-            var data = {};
+        this.createBot = function (params, callback) {
+            var createBotData = {
+                chatMessageVOType: chatMessageVOTypes.CREATE_BOT,
+                typeCode: params.typeCode,
+                content: '',
+                pushMsgType: 4,
+                token: token
+            };
+
+            if (params) {
+                if (typeof params.botName === 'string' && params.botName.length > 0) {
+                    if (params.botName.substr(-3) === "BOT") {
+                        createBotData.content = params.botName;
+                    } else {
+                        fireEvent('error', {
+                            code: 999,
+                            message: 'Bot name should end in "BOT", ex. "testBOT"'
+                        });
+                        return;
+                    }
+                } else {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'Insert a bot name to create one!'
+                    });
+                    return;
+                }
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'Insert a bot name to create one!'
+                });
+                return;
+            }
+
+            return sendMessage(createBotData, {
+                onResult: function (result) {
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.defineBotCommand = function (params, callback) {
+            var defineBotCommandData = {
+                chatMessageVOType: chatMessageVOTypes.DEFINE_BOT_COMMAND,
+                typeCode: params.typeCode,
+                content: {},
+                pushMsgType: 4,
+                token: token
+            }, commandList = [];
+
+            if (params) {
+                if (typeof params.botName !== 'string' || params.botName.length == 0) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'You need to insert a botName!'
+                    });
+                    return;
+                }
+
+                if (!Array.isArray(params.commandList) || !params.commandList.length) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'Bot Commands List has to be an array of strings.'
+                    });
+                    return;
+                } else {
+                    for (var i = 0; i < params.commandList.length; i++) {
+                        commandList.push('/' + params.commandList[i].trim());
+                    }
+                }
+
+                defineBotCommandData.content = {
+                    botName: params.botName.trim(),
+                    commandList: commandList
+                };
+
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to create bot commands'
+                });
+                return;
+            }
+
+            return sendMessage(defineBotCommandData, {
+                onResult: function (result) {
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.startBot = function (params, callback) {
+            var startBotData = {
+                chatMessageVOType: chatMessageVOTypes.START_BOT,
+                typeCode: params.typeCode,
+                content: {},
+                pushMsgType: 4,
+                token: token
+            };
+
+            if (params) {
+                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'Enter a valid Thread Id for Bot to start in!'
+                    });
+                    return;
+                }
+
+                if (typeof params.botName !== 'string' || params.botName.length == 0) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'You need to insert a botName!'
+                    });
+                    return;
+                }
+
+                startBotData.subjectId = +params.threadId;
+
+                startBotData.content = JSON.stringify({
+                    botName: params.botName.trim()
+                });
+
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to create bot commands'
+                });
+                return;
+            }
+
+            return sendMessage(startBotData, {
+                onResult: function (result) {
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.stopBot = function (params, callback) {
+            var stopBotData = {
+                chatMessageVOType: chatMessageVOTypes.STOP_BOT,
+                typeCode: params.typeCode,
+                content: {},
+                pushMsgType: 4,
+                token: token
+            }, commandList = [];
+
+            if (params) {
+                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'Enter a valid Thread Id for Bot to stop on!'
+                    });
+                    return;
+                }
+
+                if (typeof params.botName !== 'string' || params.botName.length == 0) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'You need to insert a botName!'
+                    });
+                    return;
+                }
+
+                stopBotData.subjectId = +params.threadId;
+
+                stopBotData.content = JSON.stringify({
+                    botName: params.botName.trim()
+                });
+
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to create bot commands'
+                });
+                return;
+            }
+
+            return sendMessage(stopBotData, {
+                onResult: function (result) {
+                    callback && callback(result);
+                }
+            });
+        };
+
+        this.getBotCommandsList = function (params, callback) {
+            var getBotCommandsListData = {
+                chatMessageVOType: chatMessageVOTypes.BOT_COMMANDS,
+                typeCode: params.typeCode,
+                content: {},
+                pushMsgType: 4,
+                token: token
+            };
 
             if (params) {
-                if (parseInt(params.id) > 0) {
-                    data.id = parseInt(params.id);
-                } else {
+                if (typeof params.botName !== 'string' || params.botName.length == 0) {
                     fireEvent('error', {
                         code: 999,
-                        message: 'ID is required for Updating Contact!',
-                        error: undefined
+                        message: 'You need to insert a botName!'
                     });
+                    return;
                 }
 
-                if (typeof params.firstName === 'string') {
-                    data.firstName = params.firstName;
-                } else {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'firstName is required for Updating Contact!'
-                    });
+                getBotCommandsListData.content = JSON.stringify({
+                    botName: params.botName.trim()
+                });
+
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to get bot commands'
+                });
+                return;
+            }
+
+            return sendMessage(getBotCommandsListData, {
+                onResult: function (result) {
+                    callback && callback(result);
                 }
+            });
+        };
 
-                if (typeof params.lastName === 'string') {
-                    data.lastName = params.lastName;
-                } else {
+        this.getThreadAllBots = function (params, callback) {
+            var getThreadBotsData = {
+                chatMessageVOType: chatMessageVOTypes.THREAD_ALL_BOTS,
+                typeCode: params.typeCode,
+                content: {},
+                pushMsgType: 4,
+                token: token
+            };
+
+            if (params) {
+                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
                     fireEvent('error', {
                         code: 999,
-                        message: 'lastName is required for Updating Contact!'
+                        message: 'Enter a valid Thread Id to get all Bots List!'
                     });
+                    return;
                 }
 
-                if (typeof params.cellphoneNumber === 'string') {
-                    data.cellphoneNumber = params.cellphoneNumber;
-                } else {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'cellphoneNumber is required for Updating Contact!'
-                    });
+                getThreadBotsData.subjectId = +params.threadId;
+
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to get thread\' bots list!'
+                });
+                return;
+            }
+
+            return sendMessage(getThreadBotsData, {
+                onResult: function (result) {
+                    callback && callback(result);
                 }
+            });
+        };
 
-                if (typeof params.email === 'string') {
-                    data.email = params.email;
-                } else {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'email is required for Updating Contact!'
-                    });
+        this.mapReverse = function (params, callback) {
+            var data = {};
+
+            if (params) {
+                if (parseFloat(params.lat) > 0) {
+                    data.lat = params.lat;
+                }
+
+                if (parseFloat(params.lng) > 0) {
+                    data.lng = params.lng;
                 }
 
                 data.uniqueId = Utility.generateUUID();
             }
 
             var requestParams = {
-                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS +
-                    SERVICES_PATH.UPDATE_CONTACTS,
+                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.REVERSE,
                 method: 'GET',
                 data: data,
                 headers: {
-                    '_token_': token,
-                    '_token_issuer_': 1
+                    'Api-Key': mapApiKey
                 }
             };
 
@@ -10781,82 +12107,13 @@
                     var responseData = JSON.parse(result.result.responseText);
 
                     var returnData = {
-                        hasError: responseData.hasError,
-                        cache: false,
-                        errorMessage: responseData.message,
-                        errorCode: responseData.errorCode
+                        hasError: result.hasError,
+                        cache: result.cache,
+                        errorMessage: result.message,
+                        errorCode: result.errorCode,
+                        result: responseData
                     };
 
-                    if (!responseData.hasError) {
-                        var messageContent = responseData.result,
-                            messageLength = responseData.result.length,
-                            resultData = {
-                                contacts: [],
-                                contentCount: messageLength
-                            },
-                            contactData;
-
-                        for (var i = 0; i < messageLength; i++) {
-                            contactData = formatDataToMakeContact(messageContent[i]);
-                            if (contactData) {
-                                resultData.contacts.push(contactData);
-                            }
-                        }
-
-                        returnData.result = resultData;
-
-                        /**
-                         * Add Contacts into cache database #cache
-                         */
-                        if (canUseCache && cacheSecret.length > 0) {
-                            if (db) {
-                                var cacheData = [];
-
-                                for (var i = 0; i < resultData.contacts.length; i++) {
-                                    try {
-                                        var tempData = {},
-                                            salt = Utility.generateUUID();
-                                        tempData.id = resultData.contacts[i].id;
-                                        tempData.owner = userInfo.id;
-                                        tempData.uniqueId = resultData.contacts[i].uniqueId;
-                                        tempData.userId = Utility.crypt(resultData.contacts[i].userId, cacheSecret, salt);
-                                        tempData.cellphoneNumber = Utility.crypt(resultData.contacts[i].cellphoneNumber, cacheSecret, salt);
-                                        tempData.email = Utility.crypt(resultData.contacts[i].email, cacheSecret, salt);
-                                        tempData.firstName = Utility.crypt(resultData.contacts[i].firstName, cacheSecret, salt);
-                                        tempData.lastName = Utility.crypt(resultData.contacts[i].lastName, cacheSecret, salt);
-                                        tempData.expireTime = new Date().getTime() + cacheExpireTime;
-                                        tempData.data = Utility.crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
-                                        tempData.salt = salt;
-
-                                        cacheData.push(tempData);
-                                    } catch (error) {
-                                        fireEvent('error', {
-                                            code: error.code,
-                                            message: error.message,
-                                            error: error
-                                        });
-                                    }
-                                }
-
-                                db.contacts.bulkPut(cacheData)
-                                    .catch(function (error) {
-                                        fireEvent('error', {
-                                            code: error.code,
-                                            message: error.message,
-                                            error: error
-                                        });
-                                    });
-                            } else {
-                                fireEvent('error', {
-                                    code: 6601,
-                                    message: CHAT_ERRORS[6601],
-                                    error: null
-                                });
-                            }
-                        }
-
-                    }
-
                     callback && callback(returnData);
 
                 } else {
@@ -10869,69 +12126,45 @@
             });
         };
 
-        this.removeContacts = function (params, callback) {
+        this.mapSearch = function (params, callback) {
             var data = {};
 
             if (params) {
-                if (parseInt(params.id) > 0) {
-                    data.id = parseInt(params.id);
-                } else {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'ID is required for Deleting Contact!',
-                        error: undefined
-                    });
+                if (typeof params.term === 'string') {
+                    data.term = params.term;
                 }
-            }
 
-            var requestParams = {
-                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.REMOVE_CONTACTS,
-                method: 'POST',
-                data: data,
-                headers: {
-                    '_token_': token,
-                    '_token_issuer_': 1
+                if (parseFloat(params.lat) > 0) {
+                    data.lat = params.lat;
                 }
-            };
-
-            httpRequest(requestParams, function (result) {
-                if (!result.hasError) {
-                    var responseData = JSON.parse(result.result.responseText);
 
-                    var returnData = {
-                        hasError: responseData.hasError,
-                        cache: false,
-                        errorMessage: responseData.message,
-                        errorCode: responseData.errorCode
-                    };
+                if (parseFloat(params.lng) > 0) {
+                    data.lng = params.lng;
+                }
 
-                    if (!responseData.hasError) {
-                        returnData.result = responseData.result;
-                    }
+                data.uniqueId = Utility.generateUUID();
+            }
 
-                    /**
-                     * Remove the contact from cache
-                     */
-                    if (canUseCache) {
-                        if (db) {
-                            db.contacts.where('id')
-                                .equals(parseInt(params.id))
-                                .delete()
-                                .catch(function (error) {
-                                    fireEvent('error', {
-                                        code: 6602,
-                                        message: CHAT_ERRORS[6602],
-                                        error: error
-                                    });
-                                });
-                        } else {
-                            fireEvent('error', {
-                                code: 6601,
-                                message: CHAT_ERRORS[6601],
-                                error: null
-                            });
-                        }
-                    }
+            var requestParams = {
+                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.SEARCH,
+                method: 'GET',
+                data: data,
+                headers: {
+                    'Api-Key': mapApiKey
+                }
+            };
+
+            httpRequest(requestParams, function (result) {
+                if (!result.hasError) {
+                    var responseData = JSON.parse(result.result.responseText);
+
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: result.cache,
+                        errorMessage: result.message,
+                        errorCode: result.errorCode,
+                        result: responseData
+                    };
 
                     callback && callback(returnData);
 
@@ -10945,913 +12178,869 @@
             });
         };
 
-        this.searchContacts = function (params, callback) {
-            var data = {
-                    size: 50,
-                    offset: 0
-                },
-                whereClause = {},
-                returnCache = false;
+        this.mapRouting = function (params, callback) {
+            var data = {};
 
             if (params) {
-                if (typeof params.firstName === 'string') {
-                    data.firstName = whereClause.firstName = params.firstName;
-                }
-
-                if (typeof params.lastName === 'string') {
-                    data.lastName = whereClause.lastName = params.lastName;
-                }
-
-                if (parseInt(params.cellphoneNumber) > 0) {
-                    data.cellphoneNumber = whereClause.cellphoneNumber = params.cellphoneNumber;
-                }
-
-                if (typeof params.email === 'string') {
-                    data.email = whereClause.email = params.email;
-                }
-
-                if (typeof params.query === 'string') {
-                    data.q = whereClause.q = params.query;
-                }
-
-                if (typeof params.uniqueId === 'string') {
-                    data.uniqueId = whereClause.uniqueId = params.uniqueId;
-                }
-
-                if (parseInt(params.id) > 0) {
-                    data.id = whereClause.id = params.id;
-                }
-
-                if (parseInt(params.typeCode) > 0) {
-                    data.typeCode = whereClause.typeCode = params.typeCode;
+                if (typeof params.alternative === 'boolean') {
+                    data.alternative = params.alternative;
+                } else {
+                    data.alternative = true;
                 }
 
-                if (parseInt(params.size) > 0) {
-                    data.size = params.size;
+                if (typeof params.origin === 'object') {
+                    if (parseFloat(params.origin.lat) > 0 && parseFloat(params.origin.lng)) {
+                        data.origin = params.origin.lat + ',' + parseFloat(params.origin.lng);
+                    } else {
+                        console.log('No origin has been selected!');
+                    }
                 }
 
-                if (parseInt(params.offset) > 0) {
-                    data.offset = params.offset;
+                if (typeof params.destination === 'object') {
+                    if (parseFloat(params.destination.lat) > 0 && parseFloat(params.destination.lng)) {
+                        data.destination = params.destination.lat + ',' + parseFloat(params.destination.lng);
+                    } else {
+                        console.log('No destination has been selected!');
+                    }
                 }
 
-                var functionLevelCache = (typeof params.cache == 'boolean') ? params.cache : true;
+                data.uniqueId = Utility.generateUUID();
             }
 
             var requestParams = {
-                url: SERVICE_ADDRESSES.PLATFORM_ADDRESS + SERVICES_PATH.SEARCH_CONTACTS,
-                method: 'POST',
+                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.ROUTING,
+                method: 'GET',
                 data: data,
                 headers: {
-                    '_token_': token,
-                    '_token_issuer_': 1
+                    'Api-Key': mapApiKey
                 }
             };
 
-            /**
-             * Search contacts in cache #cache
-             */
-            if (functionLevelCache && canUseCache && cacheSecret.length > 0) {
-                if (db) {
-
-                    /**
-                     * First of all we delete all contacts those
-                     * expireTime has been expired. after that
-                     * we query our cache database to retrieve
-                     * what we wanted
-                     */
-                    db.contacts.where('expireTime')
-                        .below(new Date().getTime())
-                        .delete()
-                        .then(function () {
-
-                            /**
-                             * Query cache database to get contacts
-                             */
-
-                            var thenAble;
-
-                            if (Object.keys(whereClause).length === 0) {
-                                thenAble = db.contacts.where('owner')
-                                    .equals(parseInt(userInfo.id));
-                            } else {
-                                if (whereClause.hasOwnProperty('id')) {
-                                    thenAble = db.contacts.where('owner')
-                                        .equals(parseInt(userInfo.id))
-                                        .and(function (contact) {
-                                            return contact.id == whereClause.id;
-                                        });
-                                } else if (whereClause.hasOwnProperty('uniqueId')) {
-                                    thenAble = db.contacts.where('owner')
-                                        .equals(parseInt(userInfo.id))
-                                        .and(function (contact) {
-                                            return contact.uniqueId == whereClause.uniqueId;
-                                        });
-                                } else {
-                                    if (whereClause.hasOwnProperty('firstName')) {
-                                        thenAble = db.contacts.where('owner')
-                                            .equals(parseInt(userInfo.id))
-                                            .filter(function (contact) {
-                                                var reg = new RegExp(whereClause.firstName);
-                                                return reg.test(chatDecrypt(contact.firstName, cacheSecret, contact.salt));
-                                            });
-                                    }
-
-                                    if (whereClause.hasOwnProperty('lastName')) {
-                                        thenAble = db.contacts.where('owner')
-                                            .equals(parseInt(userInfo.id))
-                                            .filter(function (contact) {
-                                                var reg = new RegExp(whereClause.lastName);
-                                                return reg.test(chatDecrypt(contact.lastName, cacheSecret, contact.salt));
-                                            });
-                                    }
-
-                                    if (whereClause.hasOwnProperty('email')) {
-                                        thenAble = db.contacts.where('owner')
-                                            .equals(parseInt(userInfo.id))
-                                            .filter(function (contact) {
-                                                var reg = new RegExp(whereClause.email);
-                                                return reg.test(chatDecrypt(contact.email, cacheSecret, contact.salt));
-                                            });
-                                    }
+            httpRequest(requestParams, function (result) {
+                if (!result.hasError) {
+                    var responseData = JSON.parse(result.result.responseText);
 
-                                    if (whereClause.hasOwnProperty('q')) {
-                                        thenAble = db.contacts.where('owner')
-                                            .equals(parseInt(userInfo.id))
-                                            .filter(function (contact) {
-                                                var reg = new RegExp(whereClause.q);
-                                                return reg.test(chatDecrypt(contact.firstName, cacheSecret, contact.salt) + ' ' +
-                                                    chatDecrypt(contact.lastName, cacheSecret, contact.salt) + ' ' +
-                                                    chatDecrypt(contact.email, cacheSecret, contact.salt));
-                                            });
-                                    }
-                                }
-                            }
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: result.cache,
+                        errorMessage: result.message,
+                        errorCode: result.errorCode,
+                        result: responseData
+                    };
 
-                            thenAble.offset(data.offset)
-                                .limit(data.size)
-                                .toArray()
-                                .then(function (contacts) {
-                                    db.contacts.where('owner')
-                                        .equals(parseInt(userInfo.id))
-                                        .count()
-                                        .then(function (contactsCount) {
-                                            var cacheData = [];
+                    callback && callback(returnData);
 
-                                            for (var i = 0; i < contacts.length; i++) {
-                                                try {
-                                                    var tempData = {},
-                                                        salt = contacts[i].salt;
+                } else {
+                    fireEvent('error', {
+                        code: result.errorCode,
+                        message: result.errorMessage,
+                        error: result
+                    });
+                }
+            });
+        };
 
-                                                    cacheData.push(formatDataToMakeContact(JSON.parse(chatDecrypt(contacts[i].data, cacheSecret, ontacts[i].salt))));
-                                                } catch (error) {
-                                                    fireEvent('error', {
-                                                        code: error.code,
-                                                        message: error.message,
-                                                        error: error
-                                                    });
-                                                }
-                                            }
+        this.mapStaticImage = function (params, callback) {
+            var data = {},
+                url = SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.STATIC_IMAGE,
+                hasError = false;
 
-                                            var returnData = {
-                                                hasError: false,
-                                                cache: true,
-                                                errorCode: 0,
-                                                errorMessage: '',
-                                                result: {
-                                                    contacts: cacheData,
-                                                    contentCount: contactsCount,
-                                                    hasNext: !(contacts.length < data.size),
-                                                    nextOffset: data.offset + contacts.length
-                                                }
-                                            };
+            if (params) {
+                if (typeof params.type === 'string') {
+                    data.type = params.type;
+                } else {
+                    data.type = 'standard-night';
+                }
 
-                                            if (cacheData.length > 0) {
-                                                callback && callback(returnData);
-                                                callback = undefined;
-                                                returnCache = true;
-                                            }
-                                        })
-                                        .catch(function (error) {
-                                            fireEvent('error', {
-                                                code: error.code,
-                                                message: error.message,
-                                                error: error
-                                            });
-                                        });
-                                })
-                                .catch(function (error) {
-                                    fireEvent('error', {
-                                        code: error.code,
-                                        message: error.message,
-                                        error: error
-                                    });
-                                });
-                        })
-                        .catch(function (error) {
-                            fireEvent('error', {
-                                code: error.code,
-                                message: error.message,
-                                error: error
-                            });
+                if (parseInt(params.zoom) > 0) {
+                    data.zoom = params.zoom;
+                } else {
+                    data.zoom = 15;
+                }
+
+                if (parseInt(params.width) > 0) {
+                    data.width = params.width;
+                } else {
+                    data.width = 800;
+                }
+
+                if (parseInt(params.height) > 0) {
+                    data.height = params.height;
+                } else {
+                    data.height = 600;
+                }
+
+                if (typeof params.center === 'object') {
+                    if (parseFloat(params.center.lat) > 0 && parseFloat(params.center.lng)) {
+                        data.center = params.center.lat + ',' + parseFloat(params.center.lng);
+                    } else {
+                        hasError = true;
+                        fireEvent('error', {
+                            code: 6700,
+                            message: CHAT_ERRORS[6700],
+                            error: undefined
                         });
+                    }
                 } else {
+                    hasError = true;
                     fireEvent('error', {
-                        code: 6601,
-                        message: CHAT_ERRORS[6601],
-                        error: null
+                        code: 6700,
+                        message: CHAT_ERRORS[6700],
+                        error: undefined
                     });
                 }
+
+                data.key = mapApiKey;
             }
 
-            /**
-             * Get Search Contacts Result From Server
-             */
-            httpRequest(requestParams, function (result) {
-                if (!result.hasError) {
-                    var responseData = JSON.parse(result.result.responseText);
+            var keys = Object.keys(data);
 
-                    var returnData = {
-                        hasError: responseData.hasError,
-                        cache: false,
-                        errorMessage: responseData.message,
-                        errorCode: responseData.errorCode
-                    };
+            if (keys.length > 0) {
+                url += '?';
 
-                    if (!responseData.hasError) {
-                        var messageContent = responseData.result,
-                            messageLength = responseData.result.length,
-                            resultData = {
-                                contacts: [],
-                                contentCount: messageLength
-                            },
-                            contactData;
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    url += key + '=' + data[key];
+                    if (i < keys.length - 1) {
+                        url += '&';
+                    }
+                }
+            }
 
-                        for (var i = 0; i < messageLength; i++) {
-                            contactData = formatDataToMakeContact(messageContent[i]);
-                            if (contactData) {
-                                resultData.contacts.push(contactData);
-                            }
-                        }
+            var returnData = {
+                hasError: hasError,
+                cache: false,
+                errorMessage: (hasError) ? CHAT_ERRORS[6700] : '',
+                errorCode: (hasError) ? 6700 : undefined,
+                result: {
+                    link: (!hasError) ? url : ''
+                }
+            };
 
-                        returnData.result = resultData;
+            callback && callback(returnData);
+        };
 
-                        /**
-                         * Add Contacts into cache database #cache
-                         */
-                        if (canUseCache && cacheSecret.length > 0) {
-                            if (db) {
-                                var cacheData = [];
+        this.setAdmin = function (params, callback) {
+            setRoleToUser(params, callback);
+        };
 
-                                for (var i = 0; i < resultData.contacts.length; i++) {
-                                    try {
-                                        var tempData = {},
-                                            salt = Utility.generateUUID();
+        this.removeAdmin = function (params, callback) {
+            removeRoleFromUser(params, callback);
+        };
 
-                                        tempData.id = resultData.contacts[i].id;
-                                        tempData.owner = userInfo.id;
-                                        tempData.uniqueId = resultData.contacts[i].uniqueId;
-                                        tempData.userId = Utility.crypt(resultData.contacts[i].userId, cacheSecret, salt);
-                                        tempData.cellphoneNumber = Utility.crypt(resultData.contacts[i].cellphoneNumber, cacheSecret, salt);
-                                        tempData.email = Utility.crypt(resultData.contacts[i].email, cacheSecret, salt);
-                                        tempData.firstName = Utility.crypt(resultData.contacts[i].firstName, cacheSecret, salt);
-                                        tempData.lastName = Utility.crypt(resultData.contacts[i].lastName, cacheSecret, salt);
-                                        tempData.expireTime = new Date().getTime() + cacheExpireTime;
-                                        tempData.data = crypt(JSON.stringify(unsetNotSeenDuration(resultData.contacts[i])), cacheSecret, salt);
-                                        tempData.salt = salt;
+        this.setAuditor = function (params, callback) {
+            setRoleToUser(params, callback);
+        };
 
-                                        cacheData.push(tempData);
-                                    } catch (error) {
-                                        fireEvent('error', {
-                                            code: error.code,
-                                            message: error.message,
-                                            error: error
-                                        });
-                                    }
-                                }
+        this.removeAuditor = function (params, callback) {
+            removeRoleFromUser(params, callback);
+        };
 
-                                db.contacts.bulkPut(cacheData)
-                                    .catch(function (error) {
-                                        fireEvent('error', {
-                                            code: error.code,
-                                            message: error.message,
-                                            error: error
-                                        });
-                                    });
-                            } else {
-                                fireEvent('error', {
-                                    code: 6601,
-                                    message: CHAT_ERRORS[6601],
-                                    error: null
-                                });
-                            }
-                        }
-                    }
+        this.clearChatServerCaches = clearChatServerCaches;
 
-                    callback && callback(returnData);
-                    /**
-                     * Delete callback so if server pushes response before
-                     * cache, cache won't send data again
-                     */
-                    callback = undefined;
+        this.deleteCacheDatabases = deleteCacheDatabases;
 
-                    if (!returnData.hasError && returnCache) {
-                        fireEvent('contactEvents', {
-                            type: 'CONTACTS_SEARCH_RESULT_CHANGE',
-                            result: returnData.result
-                        });
-                    }
+        this.clearCacheDatabasesOfUser = clearCacheDatabasesOfUser;
+
+        this.getChatState = function () {
+            return chatFullStateObject;
+        };
+
+        this.reconnect = function () {
+            asyncClient.reconnectSocket();
+        };
+
+        this.setToken = function (newToken) {
+            if (typeof newToken != 'undefined') {
+                token = newToken;
+            }
+        };
+
+        this.generateUUID = Utility.generateUUID;
+
+
+        /** Call public methods */
+        this.startRecordingCall = function (params, callback) {
+            var recordCallData = {
+                chatMessageVOType: chatMessageVOTypes.RECORD_CALL,
+                typeCode: params.typeCode,
+                pushMsgType: 3,
+                token: token,
+                content: {}
+            };
+
+            if (params) {
+                if (typeof +params.callId === 'number' && params.callId > 0) {
+                    recordCallData.subjectId = +params.callId;
                 } else {
                     fireEvent('error', {
-                        code: result.errorCode,
-                        message: result.errorMessage,
-                        error: result
+                        code: 999,
+                        message: 'Invalid Call id!'
                     });
+                    return;
+                }
+
+                if(params.destinated === true) {
+                    recordCallData.chatMessageVOType = chatMessageVOTypes.DESTINATED_RECORD_CALL;
+                    recordCallData.content.recordType = typeof +params.recordType === 'number' ? params.recordType : 1;
+                    recordCallData.content.tags = Array.isArray(params.tags) ? params.tags : null;
+                    recordCallData.content.threadId = typeof +params.threadId === 'number' ? params.threadId : null;
+                }
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to Record call!'
+                });
+                return;
+            }
+
+            return sendMessage(recordCallData, {
+                onResult: function (result) {
+                    callback && callback(result);
                 }
             });
         };
 
-        this.createBot = function (params, callback) {
-            var createBotData = {
-                chatMessageVOType: chatMessageVOTypes.CREATE_BOT,
+        this.stopRecordingCall = function (params, callback) {
+            var stopRecordingCallData = {
+                chatMessageVOType: chatMessageVOTypes.END_RECORD_CALL,
                 typeCode: params.typeCode,
-                content: '',
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
             };
 
             if (params) {
-                if (typeof params.botName === 'string' && params.botName.length > 0) {
-                    if (params.botName.substr(-3) === "BOT") {
-                        createBotData.content = params.botName;
-                    } else {
-                        fireEvent('error', {
-                            code: 999,
-                            message: 'Bot name should end in "BOT", ex. "testBOT"'
-                        });
-                        return;
-                    }
+                if (typeof +params.callId === 'number' && params.callId > 0) {
+                    stopRecordingCallData.subjectId = +params.callId;
                 } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'Insert a bot name to create one!'
+                        message: 'Invalid Call id!'
                     });
                     return;
                 }
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'Insert a bot name to create one!'
+                    message: 'No params have been sent to Stop Recording the call!'
                 });
                 return;
             }
 
-            return sendMessage(createBotData, {
+            return sendMessage(stopRecordingCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.defineBotCommand = function (params, callback) {
-            var defineBotCommandData = {
-                chatMessageVOType: chatMessageVOTypes.DEFINE_BOT_COMMAND,
+        this.startCall = function (params, callback) {
+            var startCallData = {
+                chatMessageVOType: chatMessageVOTypes.CALL_REQUEST,
                 typeCode: params.typeCode,
-                content: {},
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
-            }, commandList = [];
+            }, content = {
+                creatorClientDto: {}
+            };
 
             if (params) {
-                if (typeof params.botName !== 'string' || params.botName.length == 0) {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'You need to insert a botName!'
-                    });
-                    return;
+                /*if (typeof params.type === 'string' && callTypes.hasOwnProperty(params.type.toUpperCase())) {
+                    content.type = callTypes[params.type.toUpperCase()];
+                } else {
+                    content.type = 0x0; // Defaults to AUDIO Call
+                }*/
+
+                content.type = 0x0;
+
+                //TODO: Check for mute
+                content.creatorClientDto.mute = true;//(params.mute && typeof params.mute === 'boolean') ? params.mute : false;
+                content.mute = true;//(params.mute && typeof params.mute === 'boolean') ? params.mute : false;
+
+                if (params.clientType
+                    && typeof params.clientType === 'string'
+                    && callClientType[params.clientType.toUpperCase()] > 0) {
+                    content.creatorClientDto.clientType = callClientType[params.clientType.toUpperCase()];
+                } else {
+                    content.creatorClientDto.clientType = callClientType.NODE;
                 }
 
-                if (!Array.isArray(params.commandList) || !params.commandList.length) {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'Bot Commands List has to be an array of strings.'
-                    });
-                    return;
+                if (typeof +params.threadId === 'number' && +params.threadId > 0) {
+                    content.threadId = +params.threadId;
                 } else {
-                    for (var i = 0; i < params.commandList.length; i++) {
-                        commandList.push('/' + params.commandList[i].trim());
+                    if (Array.isArray(params.invitees)) {
+                        content.invitees = params.invitees;
+                    } else {
+                        fireEvent('error', {
+                            code: 999,
+                            message: 'Invitees list is empty! Send an array of invitees to start a call with, Or send a Thread Id to start a call with current participants'
+                        });
+                        return;
                     }
                 }
 
-                defineBotCommandData.content = {
-                    botName: params.botName.trim(),
-                    commandList: commandList
-                };
-
+                startCallData.content = JSON.stringify(content);
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to create bot commands'
+                    message: 'No params have been sent to start call!'
                 });
                 return;
             }
 
-            return sendMessage(defineBotCommandData, {
+            callRequestController.callRequestReceived = true;
+            callRequestController.callEstablishedInMySide = true;
+
+            return sendMessage(startCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.startBot = function (params, callback) {
-            var startBotData = {
-                chatMessageVOType: chatMessageVOTypes.START_BOT,
+        this.startGroupCall = function (params, callback) {
+            var startCallData = {
+                chatMessageVOType: chatMessageVOTypes.GROUP_CALL_REQUEST,
                 typeCode: params.typeCode,
-                content: {},
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
+            }, content = {
+                creatorClientDto: {}
             };
 
             if (params) {
-                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'Enter a valid Thread Id for Bot to start in!'
-                    });
-                    return;
-                }
+                /*if (typeof params.type === 'string' && callTypes.hasOwnProperty(params.type.toUpperCase())) {
+                    content.type = callTypes[params.type.toUpperCase()];
+                } else {
+                    content.type = 0x0; // Defaults to AUDIO Call
+                }*/
+                content.type = 0x0;
 
-                if (typeof params.botName !== 'string' || params.botName.length == 0) {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'You need to insert a botName!'
-                    });
-                    return;
+                content.creatorClientDto.mute = true;//(typeof params.mute === 'boolean') ? params.mute : false;
+                content.mute = true;//(params.mute && typeof params.mute === 'boolean') ? params.mute : false;
+
+                if (params.clientType && typeof params.clientType === 'string' && callClientType[params.clientType.toUpperCase()] > 0) {
+                    content.creatorClientDto.clientType = callClientType[params.clientType.toUpperCase()];
+                } else {
+                    content.creatorClientDto.clientType = callClientType.NODE;
                 }
 
-                startBotData.subjectId = +params.threadId;
+                if (typeof +params.threadId === 'number' && params.threadId > 0) {
+                    content.threadId = +params.threadId;
+                } else {
+                    if (Array.isArray(params.invitees)) {
+                        content.invitees = params.invitees;
 
-                startBotData.content = JSON.stringify({
-                    botName: params.botName.trim()
-                });
+                    } else {
+                        fireEvent('error', {
+                            code: 999,
+                            message: 'Invitees list is empty! Send an array of invitees to start a call with, Or send a Thread Id to start a call with current participants'
+                        });
+                        return;
+                    }
+                }
 
+                startCallData.content = JSON.stringify(content);
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to create bot commands'
+                    message: 'No params have been sent to start call!'
                 });
                 return;
             }
 
-            return sendMessage(startBotData, {
+            callRequestController.callRequestReceived = true;
+            callRequestController.callEstablishedInMySide = true;
+
+            return sendMessage(startCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.stopBot = function (params, callback) {
-            var stopBotData = {
-                chatMessageVOType: chatMessageVOTypes.STOP_BOT,
+        this.callReceived = callReceived;
+
+        this.terminateCall = function (params, callback) {
+            var terminateCallData = {
+                chatMessageVOType: chatMessageVOTypes.TERMINATE_CALL,
                 typeCode: params.typeCode,
-                content: {},
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
-            }, commandList = [];
+            }, content = {};
 
             if (params) {
-                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
-                    fireEvent('error', {
-                        code: 999,
-                        message: 'Enter a valid Thread Id for Bot to stop on!'
-                    });
-                    return;
-                }
-
-                if (typeof params.botName !== 'string' || params.botName.length == 0) {
+                if (typeof +params.callId === 'number' && params.callId > 0) {
+                    terminateCallData.subjectId = +params.callId;
+                } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'You need to insert a botName!'
+                        message: 'Invalid call id!'
                     });
                     return;
                 }
 
-                stopBotData.subjectId = +params.threadId;
-
-                stopBotData.content = JSON.stringify({
-                    botName: params.botName.trim()
-                });
-
+                terminateCallData.content = JSON.stringify(content);
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to create bot commands'
+                    message: 'No params have been sent to terminate the call!'
                 });
                 return;
             }
 
-            return sendMessage(stopBotData, {
+            return sendMessage(terminateCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.getBotCommandsList = function (params, callback) {
-            var getBotCommandsListData = {
-                chatMessageVOType: chatMessageVOTypes.BOT_COMMANDS,
+        this.acceptCall = function (params, callback) {
+            var acceptCallData = {
+                chatMessageVOType: chatMessageVOTypes.ACCEPT_CALL,
                 typeCode: params.typeCode,
-                content: {},
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
-            };
+            }, content = {};
 
             if (params) {
-                if (typeof params.botName !== 'string' || params.botName.length == 0) {
+                if (typeof +params.callId === 'number' && params.callId > 0) {
+                    acceptCallData.subjectId = +params.callId;
+                } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'You need to insert a botName!'
+                        message: 'Invalid call id!'
                     });
                     return;
                 }
 
-                getBotCommandsListData.content = JSON.stringify({
-                    botName: params.botName.trim()
-                });
+                content.mute = true;//(typeof params.mute === 'boolean') ? params.mute : false;
+
+                content.video = false;//(typeof params.video === 'boolean') ? params.video : false;
 
+                content.videoCall = false;// content.video;
+
+                if (params.clientType && typeof params.clientType === 'string' && callClientType[params.clientType.toUpperCase()] > 0) {
+                    content.clientType = callClientType[params.clientType.toUpperCase()];
+                } else {
+                    content.clientType = callClientType.NODE;
+                }
+
+                acceptCallData.content = JSON.stringify(content);
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to get bot commands'
+                    message: 'No params have been sent to accept the call!'
                 });
                 return;
             }
-
-            return sendMessage(getBotCommandsListData, {
+            callRequestController.callEstablishedInMySide = true;
+            return sendMessage(acceptCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.getThreadAllBots = function (params, callback) {
-            var getThreadBotsData = {
-                chatMessageVOType: chatMessageVOTypes.THREAD_ALL_BOTS,
+        this.rejectCall = this.cancelCall = function (params, callback) {
+            var rejectCallData = {
+                chatMessageVOType: chatMessageVOTypes.REJECT_CALL,
                 typeCode: params.typeCode,
-                content: {},
-                pushMsgType: 4,
+                pushMsgType: 3,
                 token: token
             };
 
             if (params) {
-                if (typeof +params.threadId !== 'number' || params.threadId < 0) {
+                if (typeof +params.callId === 'number' && params.callId > 0) {
+                    rejectCallData.subjectId = +params.callId;
+                } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'Enter a valid Thread Id to get all Bots List!'
+                        message: 'Invalid call id!'
                     });
                     return;
                 }
-
-                getThreadBotsData.subjectId = +params.threadId;
-
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to get thread\' bots list!'
+                    message: 'No params have been sent to reject the call!'
                 });
                 return;
             }
 
-            return sendMessage(getThreadBotsData, {
+            return sendMessage(rejectCallData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.mapReverse = function (params, callback) {
-            var data = {};
+        this.endCall = endCall;
+
+        this.getCallsList = function (params, callback) {
+            var getCallListData = {
+                chatMessageVOType: chatMessageVOTypes.GET_CALLS,
+                typeCode: params.typeCode,
+                pushMsgType: 3,
+                token: token
+            }, content = {};
 
             if (params) {
-                if (parseFloat(params.lat) > 0) {
-                    data.lat = params.lat;
+                if (typeof params.count === 'number' && params.count >= 0) {
+                    content.count = +params.count;
+                } else {
+                    content.count = 50;
                 }
 
-                if (parseFloat(params.lng) > 0) {
-                    data.lng = params.lng;
+                if (typeof params.offset === 'number' && params.offset >= 0) {
+                    content.offset = +params.offset;
+                } else {
+                    content.offset = 0;
                 }
 
-                data.uniqueId = Utility.generateUUID();
-            }
-
-            var requestParams = {
-                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.REVERSE,
-                method: 'GET',
-                data: data,
-                headers: {
-                    'Api-Key': mapApiKey
+                if (typeof params.creatorCoreUserId === 'number' && params.creatorCoreUserId > 0) {
+                    content.creatorCoreUserId = +params.creatorCoreUserId;
                 }
-            };
-
-            httpRequest(requestParams, function (result) {
-                if (!result.hasError) {
-                    var responseData = JSON.parse(result.result.responseText);
-
-                    var returnData = {
-                        hasError: result.hasError,
-                        cache: result.cache,
-                        errorMessage: result.message,
-                        errorCode: result.errorCode,
-                        result: responseData
-                    };
 
-                    callback && callback(returnData);
+                if (typeof params.creatorSsoId === 'number' && params.creatorSsoId > 0) {
+                    content.creatorSsoId = +params.creatorSsoId;
+                }
 
-                } else {
-                    fireEvent('error', {
-                        code: result.errorCode,
-                        message: result.errorMessage,
-                        error: result
-                    });
+                if (typeof params.name === 'string') {
+                    content.name = params.name;
                 }
-            });
-        };
 
-        this.mapSearch = function (params, callback) {
-            var data = {};
+                if (typeof params.type === 'string' && callTypes.hasOwnProperty(params.type.toUpperCase())) {
+                    content.type = callTypes[params.type.toUpperCase()];
+                }
 
-            if (params) {
-                if (typeof params.term === 'string') {
-                    data.term = params.term;
+                if (Array.isArray(params.callIds)) {
+                    content.callIds = params.callIds;
                 }
 
-                if (parseFloat(params.lat) > 0) {
-                    data.lat = params.lat;
+                if (typeof params.contactType === 'string') {
+                    content.contactType = params.contactType;
                 }
 
-                if (parseFloat(params.lng) > 0) {
-                    data.lng = params.lng;
+                if (typeof params.uniqueId === 'string') {
+                    content.uniqueId = params.uniqueId;
                 }
 
-                data.uniqueId = Utility.generateUUID();
+                getCallListData.content = JSON.stringify(content);
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to End the call!'
+                });
+                return;
             }
 
-            var requestParams = {
-                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.SEARCH,
-                method: 'GET',
-                data: data,
-                headers: {
-                    'Api-Key': mapApiKey
+            return sendMessage(getCallListData, {
+                onResult: function (result) {
+                    callback && callback(result);
                 }
+            });
+        };
+
+        this.getCallParticipants = function (params, callback) {
+            var sendMessageParams = {
+                chatMessageVOType: chatMessageVOTypes.ACTIVE_CALL_PARTICIPANTS,
+                typeCode: params.typeCode,
+                content: {}
             };
 
-            httpRequest(requestParams, function (result) {
-                if (!result.hasError) {
-                    var responseData = JSON.parse(result.result.responseText);
+            if (params) {
+                if (isNaN(params.callId)) {
+                    fireEvent('error', {
+                        code: 999,
+                        message: 'Call Id should be a valid number!'
+                    });
+                    return;
+                } else {
+                    var callId = +params.callId;
+                    sendMessageParams.subjectId = callId;
 
-                    var returnData = {
-                        hasError: result.hasError,
-                        cache: result.cache,
-                        errorMessage: result.message,
-                        errorCode: result.errorCode,
-                        result: responseData
-                    };
+                    var offset = (parseInt(params.offset) > 0)
+                        ? parseInt(params.offset)
+                        : 0,
+                        count = (parseInt(params.count) > 0)
+                            ? parseInt(params.count)
+                            : config.getHistoryCount;
 
-                    callback && callback(returnData);
+                    sendMessageParams.content.count = count;
+                    sendMessageParams.content.offset = offset;
 
-                } else {
-                    fireEvent('error', {
-                        code: result.errorCode,
-                        message: result.errorMessage,
-                        error: result
+                    return sendMessage(sendMessageParams, {
+                        onResult: function (result) {
+                            var returnData = {
+                                hasError: result.hasError,
+                                cache: false,
+                                errorMessage: result.errorMessage,
+                                errorCode: result.errorCode
+                            };
+
+                            if (!returnData.hasError) {
+                                var messageContent = result.result,
+                                    messageLength = messageContent.length,
+                                    resultData = {
+                                        participants: reformatCallParticipants(messageContent),
+                                        contentCount: result.contentCount,
+                                        hasNext: (sendMessageParams.content.offset + sendMessageParams.content.count < result.contentCount && messageLength > 0),
+                                        nextOffset: sendMessageParams.content.offset * 1 + messageLength * 1
+                                    };
+
+                                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) {
+                                fireEvent('callEvents', {
+                                    type: 'CALL_PARTICIPANTS_LIST_CHANGE',
+                                    threadId: callId,
+                                    result: returnData.result
+                                });
+                            }
+                        }
                     });
                 }
-            });
+            } else {
+                fireEvent('error', {
+                    code: 999,
+                    message: 'No params have been sent to Get Call Participants!'
+                });
+                return;
+            }
         };
 
-        this.mapRouting = function (params, callback) {
-            var data = {};
+        this.addCallParticipants = function (params, callback) {
+            /**
+             * + AddCallParticipantsRequest     {object}
+             *    - subjectId                   {int}
+             *    + content                     {list} List of CONTACT IDs or inviteeVO Objects
+             *    - uniqueId                    {string}
+             */
+
+            var sendMessageParams = {
+                chatMessageVOType: chatMessageVOTypes.ADD_CALL_PARTICIPANT,
+                typeCode: params.typeCode,
+                content: []
+            };
 
             if (params) {
-                if (typeof params.alternative === 'boolean') {
-                    data.alternative = params.alternative;
-                } else {
-                    data.alternative = true;
+                if (typeof params.callId === 'number' && params.callId > 0) {
+                    sendMessageParams.subjectId = params.callId;
                 }
 
-                if (typeof params.origin === 'object') {
-                    if (parseFloat(params.origin.lat) > 0 && parseFloat(params.origin.lng)) {
-                        data.origin = params.origin.lat + ',' + parseFloat(params.origin.lng);
-                    } else {
-                        console.log('No origin has been selected!');
-                    }
+                if (Array.isArray(params.contactIds)) {
+                    sendMessageParams.content = params.contactIds;
                 }
 
-                if (typeof params.destination === 'object') {
-                    if (parseFloat(params.destination.lat) > 0 && parseFloat(params.destination.lng)) {
-                        data.destination = params.destination.lat + ',' + parseFloat(params.destination.lng);
-                    } else {
-                        console.log('No destination has been selected!');
+                if (Array.isArray(params.usernames)) {
+                    sendMessageParams.content = [];
+                    for (var i = 0; i < params.usernames.length; i++) {
+                        sendMessageParams.content.push({
+                            id: params.usernames[i],
+                            idType: inviteeVOidTypes.TO_BE_USER_USERNAME
+                        });
                     }
                 }
 
-                data.uniqueId = Utility.generateUUID();
-            }
-
-            var requestParams = {
-                url: SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.ROUTING,
-                method: 'GET',
-                data: data,
-                headers: {
-                    'Api-Key': mapApiKey
+                if (Array.isArray(params.coreUserids)) {
+                    sendMessageParams.content = [];
+                    for (var i = 0; i < params.coreUserids.length; i++) {
+                        sendMessageParams.content.push({
+                            id: params.coreUserids[i],
+                            idType: inviteeVOidTypes.TO_BE_CORE_USER_ID
+                        });
+                    }
                 }
-            };
-
-            httpRequest(requestParams, function (result) {
-                if (!result.hasError) {
-                    var responseData = JSON.parse(result.result.responseText);
+            }
 
+            return sendMessage(sendMessageParams, {
+                onResult: function (result) {
                     var returnData = {
                         hasError: result.hasError,
-                        cache: result.cache,
-                        errorMessage: result.message,
-                        errorCode: result.errorCode,
-                        result: responseData
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
                     };
-
+                    if (!returnData.hasError) {
+                        // TODO : What is the result?!
+                        var messageContent = result.result;
+                        returnData.result = messageContent;
+                    }
                     callback && callback(returnData);
-
-                } else {
-                    fireEvent('error', {
-                        code: result.errorCode,
-                        message: result.errorMessage,
-                        error: result
-                    });
                 }
             });
         };
 
-        this.mapStaticImage = function (params, callback) {
-            var data = {},
-                url = SERVICE_ADDRESSES.MAP_ADDRESS + SERVICES_PATH.STATIC_IMAGE,
-                hasError = false;
-
-            if (params) {
-                if (typeof params.type === 'string') {
-                    data.type = params.type;
-                } else {
-                    data.type = 'standard-night';
-                }
+        this.removeCallParticipants = function (params, callback) {
+            /**
+             * + removeCallParticipantsRequest     {object}
+             *    - subjectId                   {int}
+             *    + content                     {list} List of Participants UserIds
+             */
 
-                if (parseInt(params.zoom) > 0) {
-                    data.zoom = params.zoom;
-                } else {
-                    data.zoom = 15;
-                }
+            var sendMessageParams = {
+                chatMessageVOType: chatMessageVOTypes.REMOVE_CALL_PARTICIPANT,
+                typeCode: params.typeCode,
+                content: []
+            };
 
-                if (parseInt(params.width) > 0) {
-                    data.width = params.width;
-                } else {
-                    data.width = 800;
+            if (params) {
+                if (typeof params.callId === 'number' && params.callId > 0) {
+                    sendMessageParams.subjectId = params.callId;
                 }
 
-                if (parseInt(params.height) > 0) {
-                    data.height = params.height;
-                } else {
-                    data.height = 600;
+                if (Array.isArray(params.userIds)) {
+                    sendMessageParams.content = params.userIds;
                 }
+            }
 
-                if (typeof params.center === 'object') {
-                    if (parseFloat(params.center.lat) > 0 && parseFloat(params.center.lng)) {
-                        data.center = params.center.lat + ',' + parseFloat(params.center.lng);
-                    } else {
-                        hasError = true;
-                        fireEvent('error', {
-                            code: 6700,
-                            message: CHAT_ERRORS[6700],
-                            error: undefined
-                        });
+            return sendMessage(sendMessageParams, {
+                onResult: function (result) {
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
+                    };
+                    if (!returnData.hasError) {
+                        // TODO : What is the result?!
+                        var messageContent = result.result;
+                        returnData.result = messageContent;
                     }
-                } else {
-                    hasError = true;
-                    fireEvent('error', {
-                        code: 6700,
-                        message: CHAT_ERRORS[6700],
-                        error: undefined
-                    });
+                    callback && callback(returnData);
                 }
+            });
+        };
 
-                data.key = mapApiKey;
-            }
+        this.muteCallParticipants = function (params, callback) {
+            /**
+             * + muteCallParticipantsRequest     {object}
+             *    - subjectId                   {int}
+             *    + content                     {list} List of Participants UserIds
+             */
 
-            var keys = Object.keys(data);
+            var sendMessageParams = {
+                chatMessageVOType: chatMessageVOTypes.MUTE_CALL_PARTICIPANT,
+                typeCode: params.typeCode,
+                content: []
+            };
 
-            if (keys.length > 0) {
-                url += '?';
+            if (params) {
+                if (typeof params.callId === 'number' && params.callId > 0) {
+                    sendMessageParams.subjectId = params.callId;
+                }
 
-                for (var i = 0; i < keys.length; i++) {
-                    var key = keys[i];
-                    url += key + '=' + data[key];
-                    if (i < keys.length - 1) {
-                        url += '&';
-                    }
+                if (Array.isArray(params.userIds)) {
+                    sendMessageParams.content = params.userIds;
                 }
             }
 
-            var returnData = {
-                hasError: hasError,
-                cache: false,
-                errorMessage: (hasError) ? CHAT_ERRORS[6700] : '',
-                errorCode: (hasError) ? 6700 : undefined,
-                result: {
-                    link: (!hasError) ? url : ''
+            return sendMessage(sendMessageParams, {
+                onResult: function (result) {
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
+                    };
+                    if (!returnData.hasError) {
+                        // TODO : What is the result?!
+                        var messageContent = result.result;
+                        returnData.result = messageContent;
+                    }
+                    callback && callback(returnData);
                 }
-            };
-
-            callback && callback(returnData);
-        };
-
-        this.setAdmin = function (params, callback) {
-            setRoleToUser(params, callback);
-        };
-
-        this.removeAdmin = function (params, callback) {
-            removeRoleFromUser(params, callback);
-        };
-
-        this.setAuditor = function (params, callback) {
-            setRoleToUser(params, callback);
-        };
-
-        this.removeAuditor = function (params, callback) {
-            removeRoleFromUser(params, callback);
+            });
         };
 
-        this.clearChatServerCaches = clearChatServerCaches;
-
-        this.deleteCacheDatabases = deleteCacheDatabases;
-
-        this.clearCacheDatabasesOfUser = clearCacheDatabasesOfUser;
+        this.unMuteCallParticipants = function (params, callback) {
+            /**
+             * + unMuteCallParticipantsRequest     {object}
+             *    - subjectId                   {int}
+             *    + content                     {list} List of Participants UserIds
+             */
 
-        this.getChatState = function () {
-            return chatFullStateObject;
-        };
+            var sendMessageParams = {
+                chatMessageVOType: chatMessageVOTypes.UNMUTE_CALL_PARTICIPANT,
+                typeCode: params.typeCode,
+                content: []
+            };
 
-        this.reconnect = function () {
-            asyncClient.reconnectSocket();
-        };
+            if (params) {
+                if (typeof params.callId === 'number' && params.callId > 0) {
+                    sendMessageParams.subjectId = params.callId;
+                }
 
-        this.setToken = function (newToken) {
-            if (typeof newToken != 'undefined') {
-                token = newToken;
+                if (Array.isArray(params.userIds)) {
+                    sendMessageParams.content = params.userIds;
+                }
             }
-        };
+            var myId = userInfo.id;
 
-        this.generateUUID = Utility.generateUUID;
+            return sendMessage(sendMessageParams, {
+                onResult: function (result) {
+                    var returnData = {
+                        hasError: result.hasError,
+                        cache: false,
+                        errorMessage: result.errorMessage,
+                        errorCode: result.errorCode
+                    };
+                    if (!returnData.hasError) {
+                        // TODO : What is the result?!
+                        var messageContent = result.result;
+                        returnData.result = messageContent;
+                    }
+                    callback && callback(returnData);
+                }
+            });
+        };
 
-        this.startRecordingCall = function (params, callback) {
-            var recordCallData = {
-                chatMessageVOType: chatMessageVOTypes.RECORD_CALL,
+        this.turnOnVideoCall = function (params, callback) {
+            var turnOnVideoData = {
+                chatMessageVOType: chatMessageVOTypes.TURN_ON_VIDEO_CALL,
                 typeCode: params.typeCode,
                 pushMsgType: 3,
-                token: token,
-                content: {}
+                token: token
             };
 
             if (params) {
                 if (typeof +params.callId === 'number' && params.callId > 0) {
-                    recordCallData.subjectId = +params.callId;
+                    turnOnVideoData.subjectId = +params.callId;
                 } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'Invalid Call id!'
+                        message: 'Invalid call id!'
                     });
                     return;
                 }
-
-                if(params.destinated === true) {
-                    recordCallData.chatMessageVOType = chatMessageVOTypes.DESTINATED_RECORD_CALL;
-                    recordCallData.content.recordType = typeof +params.recordType === 'number' ? params.recordType : 1;
-                    recordCallData.content.tags = Array.isArray(params.tags) ? params.tags : null;
-                    recordCallData.content.threadId = typeof +params.threadId === 'number' ? params.threadId : null;
-                }
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to Record call!'
+                    message: 'No params have been sent to turn on the video call!'
                 });
                 return;
             }
 
-            return sendMessage(recordCallData, {
+            return sendMessage(turnOnVideoData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
-        this.stopRecordingCall = function (params, callback) {
-            var stopRecordingCallData = {
-                chatMessageVOType: chatMessageVOTypes.END_RECORD_CALL,
+        this.turnOffVideoCall = function (params, callback) {
+            var turnOffVideoData = {
+                chatMessageVOType: chatMessageVOTypes.TURN_OFF_VIDEO_CALL,
                 typeCode: params.typeCode,
                 pushMsgType: 3,
                 token: token
@@ -11859,29 +13048,31 @@
 
             if (params) {
                 if (typeof +params.callId === 'number' && params.callId > 0) {
-                    stopRecordingCallData.subjectId = +params.callId;
+                    turnOffVideoData.subjectId = +params.callId;
                 } else {
                     fireEvent('error', {
                         code: 999,
-                        message: 'Invalid Call id!'
+                        message: 'Invalid call id!'
                     });
                     return;
                 }
             } else {
                 fireEvent('error', {
                     code: 999,
-                    message: 'No params have been sent to Stop Recording the call!'
+                    message: 'No params have been sent to turn off the video call!'
                 });
                 return;
             }
 
-            return sendMessage(stopRecordingCallData, {
+
+            return sendMessage(turnOffVideoData, {
                 onResult: function (result) {
                     callback && callback(result);
                 }
             });
         };
 
+        this.callStop = callStop;
 
         this.logout = function () {
             clearChatServerCaches();