podchat 12.5.0 → 12.5.2

package/changelog.md

@@ -5,11 +5,15 @@ to see complete list of changelog please visit [ChangeLog](https://github.com/ma
 
 ## [12.5.0] - 11-7-2022
 ### Added
-- Added global typeCode and typeCodeOwnerId
-- Added SWITCH_TO_GROUP_CALL_REQUEST , RECORD_CALL_STARTED , fixed GET_CALLS_TO_JOIN
-- Added callId to event type: CALL_STARTED
+- Global typeCode and typeCodeOwnerId
+- event type: SWITCH_TO_GROUP_CALL_REQUEST , RECORD_CALL_STARTED
+- callId to event type: CALL_STARTED
+
+### Changed
 - Removed contentCount from hasNext calculation in getThreads and getHistory
 
+### Fixed
+- Bug in GET_CALLS_TO_JOIN
 
 ## [12.4.0] - 24-5-2022
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "podchat",
-  "version": "12.5.0",
+  "version": "12.5.2",
   "description": "Javascript SDK to use POD's Chat Service",
   "main": "./src/chat.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "publish:snapshot": "npm run version:snapshot && npm publish --tag snapshot",
     "version:snapshot": "npm version prerelease --preid snapshot",
     "publish:release": "npm run version:release && npm publish",
-    "version:release": "npm version 12.5.0"
+    "version:release": "npm version 12.5.2"
   },
   "repository": {
     "type": "git",

package/src/chat.js

@@ -290,6 +290,13 @@
                 // POD Drive Services
                 PODSPACE_UPLOAD_FILE_TO_USERGROUP: '/userGroup/uploadFile',
                 PODSPACE_UPLOAD_IMAGE_TO_USERGROUP: '/userGroup/uploadImage',
+
+                PODSPACE_UPLOAD_FILE_TO_USERGROUP_NEW: '/api/usergroups/{userGroupHash}/files',
+                PODSPACE_UPLOAD_IMAGE_TO_USERGROUP_NEW: '/api/usergroups/{userGroupHash}/images',
+
+                PODSPACE_DOWNLOAD_FILE_NEW: '/api/files/{fileHash}',
+                PODSPACE_DOWNLOAD_IMAGE_NEW: '/api/images/{fileHash}',
+
                 PODSPACE_UPLOAD_FILE: '/nzh/drive/uploadFile',
                 PODSPACE_UPLOAD_FILE_FROM_URL: '/nzh/drive/uploadFileFromUrl',
                 PODSPACE_UPLOAD_IMAGE: '/nzh/drive/uploadImage',
@@ -3622,6 +3629,17 @@
                         }
                         break;
 
+                    /**
+                     * Type 152    Gives us a json to export for user
+                     */
+                    case chatMessageVOTypes.EXPORT_CHAT:
+                        if (messagesCallbacks[uniqueId]) {
+                            messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount, uniqueId));
+                        }
+
+                        break;
+
+
                     /**
                      * Type 221  Event to tell us p2p call converted to a group call
                      */
@@ -3648,7 +3666,6 @@
 
                         break;
 
-
                     /**
                      * Type 999   All unknown errors
                      */
@@ -7178,6 +7195,184 @@
                 }
             },
 
+            getFileFromPodspaceNew = function (params, callback) {
+                var downloadUniqueId = Utility.generateUUID(),
+                    getFileData = {};
+                if (params) {
+                    if (params.hashCode && typeof params.hashCode == 'string') {
+                        getFileData.hash = params.hashCode;
+                    } else {
+                        callback({
+                            hasError: true,
+                            error: 'Enter a file hash to get'
+                        });
+                        return;
+                    }
+
+                    if(params.checkUserGroupAccess) {
+                        getFileData.checkUserGroupAccess = true;
+                    }
+                }
+
+                if (params.responseType === 'link') {
+                    var returnLink = SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS + SERVICES_PATH.PODSPACE_DOWNLOAD_FILE_NEW.replace('{fileHash}', params.hashCode) + `?checkUserGroupAccess=true`;
+                    callback({
+                        hasError: false,
+                        type: 'link',
+                        result: returnLink
+                    });
+                } else {
+                    httpRequest({
+                        url: SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS + SERVICES_PATH.PODSPACE_DOWNLOAD_FILE_NEW.replace('{fileHash}', params.hashCode) + `?checkUserGroupAccess=true`,
+                        method: 'GET',
+                        responseType: 'blob',
+                        uniqueId: downloadUniqueId,
+                        headers: {
+                            'Authorization': 'Bearer ' + token
+                        },
+                        enableDownloadProgressEvents: params.enableDownloadProgressEvents,
+                        hashCode: params.hashCode
+                        //data: getFileData
+                    }, function (result) {
+                        if (!result.hasError) {
+                            callback({
+                                hasError: result.hasError,
+                                result: result,
+                                type: 'blob'
+                            });
+                        } else {
+                            callback({
+                                hasError: true
+                            });
+                        }
+                    });
+
+                    return {
+                        uniqueId: downloadUniqueId,
+                        cancel: function () {
+                            cancelFileDownload({
+                                uniqueId: downloadUniqueId
+                            }, function () {
+                                consoleLogging && console.log(`"${downloadUniqueId}" - File download has been canceled!`);
+                            });
+                        }
+                    };
+                }
+            },
+
+            getImageFromPodspaceNew = function (params, callback) {
+                var downloadUniqueId = Utility.generateUUID(),
+                    getImageData = {
+                        size: params.size,
+                        quality: params.quality,
+                        crop: params.crop
+                    };
+                if (params) {
+                    if (params.hashCode && typeof params.hashCode == 'string') {
+                        getImageData.hash = params.hashCode;
+                    } else {
+                        callback({
+                            hasError: true,
+                            error: 'Enter a file hash to get'
+                        });
+                        return;
+                    }
+
+                    if (params.responseType === 'link') {
+                        var returnLink = SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS
+                            + SERVICES_PATH.PODSPACE_DOWNLOAD_IMAGE_NEW.replace('{fileHash}', params.hashCode) + `?checkUserGroupAccess=true&size=${params.size}&quality=${params.quality}&crop=${params.crop}`;
+                        //+ SERVICES_PATH.PODSPACE_DOWNLOAD_IMAGE + `?hash=${params.hashCode}&_token_=${token}&_token_issuer_=1&size=${params.size}&quality=${params.quality}&crop=${params.crop}`;
+
+                        callback({
+                            hasError: false,
+                            type: 'link',
+                            result: returnLink
+                        });
+                    } else if (params.responseType === 'base64') {
+                        httpRequest({
+                            url: SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS
+                                + SERVICES_PATH.PODSPACE_DOWNLOAD_IMAGE_NEW.replace('{fileHash}', params.hashCode) + `?checkUserGroupAccess=true&size=${params.size}&quality=${params.quality}&crop=${params.crop}`,
+                            method: 'GET',
+                            uniqueId: downloadUniqueId,
+                            responseType: 'blob',
+                            headers: {
+                                'Authorization': 'Bearer ' + token
+                            },
+                            enableDownloadProgressEvents: params.enableDownloadProgressEvents,
+                            hashCode: params.hashCode
+                            //data: getImageData
+                        }, function (result) {
+                            if (!result.hasError) {
+                                var fr = new FileReader();
+
+                                fr.onloadend = function () {
+                                    callback({
+                                        hasError: result.hasError,
+                                        type: 'base64',
+                                        result: fr.result
+                                    });
+                                }
+
+                                fr.readAsDataURL(result);
+                            } else {
+                                callback({
+                                    hasError: true
+                                });
+                            }
+                        });
+
+                        return {
+                            uniqueId: downloadUniqueId,
+                            cancel: function () {
+                                cancelFileDownload({
+                                    uniqueId: downloadUniqueId
+                                }, function () {
+                                    consoleLogging && console.log(`"${downloadUniqueId}" - Image download has been canceled!`);
+                                });
+                            }
+                        };
+                    } else {
+                        httpRequest({
+                            url: SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS
+                                + SERVICES_PATH.PODSPACE_DOWNLOAD_IMAGE_NEW.replace('{fileHash}', params.hashCode) + `?checkUserGroupAccess=true&size=${params.size}&quality=${params.quality}&crop=${params.crop}`,
+                            method: 'GET',
+                            responseType: 'blob',
+                            uniqueId: downloadUniqueId,
+                            headers: {
+                                'Authorization': 'Bearer ' + token
+                            },
+                            enableDownloadProgressEvents: params.enableDownloadProgressEvents,
+                            hashCode: params.hashCode
+                            //data: getImageData
+                        }, function (result) {
+                            if (!result.hasError) {
+                                callback({
+                                    hasError: result.hasError,
+                                    type: 'blob',
+                                    result: result
+                                });
+                            } else {
+                                callback({
+                                    hasError: true
+                                });
+                            }
+                        });
+
+                        return {
+                            uniqueId: downloadUniqueId,
+                            cancel: function () {
+                                cancelFileDownload({
+                                    uniqueId: downloadUniqueId
+                                }, function () {
+                                    consoleLogging && console.log(`"${downloadUniqueId}" - Image download has been canceled!`);
+                                });
+                            }
+                        };
+                    }
+                }
+            },
+
+
             /**
              * Get Image Download Link From PodSpace
              *
@@ -8158,6 +8353,284 @@
                 }
             },
 
+            uploadImageToPodspaceUserGroupNew = function (params, callback) {
+                var fileName,
+                    fileType,
+                    fileSize,
+                    fileWidth = 0,
+                    fileHeight = 0,
+                    fileExtension,
+                    uploadUniqueId,
+                    uploadThreadId;
+                var continueImageUpload = function (params) {
+                    if (imageMimeTypes.indexOf(fileType) >= 0 || imageExtentions.indexOf(fileExtension) >= 0) {
+                        var uploadImageData = {};
+                        if (params) {
+                            if (typeof params.image !== 'undefined') {
+                                uploadImageData.file = params.image;
+                            } else {
+                                callback({
+                                    hasError: true,
+                                    errorCode: 999,
+                                    errorMessage: 'You need to send a image file!'
+                                });
+                                return;
+                            }
+                            if (typeof params.userGroupHash == 'string') {
+                                uploadImageData.userGroupHash = params.userGroupHash;
+                            } else {
+                                callback({
+                                    hasError: true,
+                                    errorCode: 999,
+                                    errorMessage: 'You need to enter a userGroupHash to be able to upload on PodSpace!'
+                                });
+                                return;
+                            }
+                            if (params.randomFileName) {
+                                uploadImageData.fileName = Utility.generateUUID() + '.' + fileExtension;
+                            } else {
+                                uploadImageData.filename = fileName;
+                            }
+                            uploadImageData.fileSize = fileSize;
+                            if (parseInt(params.threadId) > 0) {
+                                uploadThreadId = params.threadId;
+                                uploadImageData.threadId = params.threadId;
+                            } else {
+                                uploadThreadId = 0;
+                                uploadImageData.threadId = 0;
+                            }
+                            if (typeof params.uniqueId == 'string') {
+                                uploadUniqueId = params.uniqueId;
+                                uploadImageData.uniqueId = params.uniqueId;
+                            } else {
+                                uploadUniqueId = Utility.generateUUID();
+                                uploadImageData.uniqueId = uploadUniqueId;
+                            }
+                            if (typeof params.originalFileName == 'string') {
+                                uploadImageData.originalFileName = params.originalFileName;
+                            } else {
+                                uploadImageData.originalFileName = fileName;
+                            }
+                            uploadImageData.x = parseInt(params.xC) || 0;
+                            uploadImageData.y = parseInt(params.yC) || 0;
+                            uploadImageData.height = parseInt(params.hC) || fileHeight;
+                            uploadImageData.weight = parseInt(params.wC) || fileWidth;
+                        }
+                        httpRequest({
+                            url: SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS + SERVICES_PATH.PODSPACE_UPLOAD_IMAGE_TO_USERGROUP_NEW.replace('{userGroupHash}', uploadImageData.userGroupHash),
+                            method: 'POST',
+                            headers: {
+                                'Authorization': 'Bearer ' + token,
+                            },
+                            data: uploadImageData,
+                            uniqueId: uploadUniqueId
+                        }, function (result) {
+                            if (!result.hasError) {
+                                try {
+                                    var response = (typeof result.result.responseText == 'string')
+                                        ? JSON.parse(result.result.responseText)
+                                        : result.result.responseText;
+                                    if (response.status < 400) {
+                                        response.result.actualHeight = fileHeight;
+                                        response.result.actualWidth = fileWidth;
+                                        callback({
+                                            hasError: response.hasError,
+                                            result: response.result
+                                        });
+                                    } else {
+                                        callback({
+                                            hasError: true,
+                                            errorCode: response.errorCode,
+                                            errorMessage: response.message
+                                        });
+                                    }
+                                } catch (e) {
+                                    consoleLogging && console.log(e)
+                                    callback({
+                                        hasError: true,
+                                        errorCode: 6300,
+                                        errorMessage: CHAT_ERRORS[6300]
+                                    });
+                                }
+                            } else {
+                                callback({
+                                    hasError: true,
+                                    errorCode: result.errorCode,
+                                    errorMessage: result.errorMessage
+                                });
+                            }
+                        });
+                        return {
+                            uniqueId: uploadUniqueId,
+                            threadId: uploadThreadId,
+                            participant: userInfo,
+                            content: {
+                                caption: params.content,
+                                file: {
+                                    uniqueId: uploadUniqueId,
+                                    fileName: fileName,
+                                    fileSize: fileSize,
+                                    fileObject: params.file
+                                }
+                            }
+                        };
+                    } else {
+                        callback({
+                            hasError: true,
+                            errorCode: 6301,
+                            errorMessage: CHAT_ERRORS[6301]
+                        });
+                    }
+                }
+
+                if (isNode) {
+                    fileName = params.image.split('/')
+                        .pop();
+                    fileType = Mime.getType(params.image);
+                    fileSize = FS.statSync(params.image).size;
+                    fileExtension = params.image.split('.')
+                        .pop();
+
+                    var dimensions = SizeOf(params.image);
+                    fileWidth = dimensions.width;
+                    fileHeight = dimensions.height;
+
+                    continueImageUpload(params);
+                } else {
+                    fileName = params.image.name;
+                    fileType = params.image.type;
+                    fileSize = params.image.size;
+                    fileExtension = params.image.name.split('.')
+                        .pop();
+
+                    var reader = new FileReader();
+                    reader.onload = function (e) {
+                        var image = new Image();
+                        image.onload = function () {
+                            fileWidth = this.width;
+                            fileHeight = this.height;
+                            continueImageUpload(params);
+                        };
+                        image.src = e.target.result;
+                    };
+                    reader.readAsDataURL(params.image);
+                }
+
+            },
+
+            uploadFileToPodspaceUserGroupNew = function (params, callback) {
+                var fileName,
+                    //fileType,
+                    fileSize,
+                    //fileExtension,
+                    uploadUniqueId,
+                    uploadThreadId;
+
+                console.log(params)
+
+                if (isNode) {
+                    fileName = params.file.split('/')
+                        .pop();
+                    fileType = Mime.getType(params.file);
+                    fileSize = FS.statSync(params.file).size;
+                    fileExtension = params.file.split('.')
+                        .pop();
+                } else {
+                    fileName = params.file.name;
+                    fileType = params.file.type;
+                    fileSize = params.file.size;
+                    fileExtension = params.file.name.split('.')
+                        .pop();
+                }
+                // fileName = params.file.name;
+                //fileType = params.file.type;
+                // fileSize = params.file.size;
+                //fileExtension = params.file.name.split('.').pop();
+
+                var uploadFileData = {};
+                if (params) {
+                    if (typeof params.file !== 'undefined') {
+                        uploadFileData.file = params.file;
+                    }
+                    if (parseInt(params.threadId) > 0) {
+                        uploadThreadId = params.threadId;
+                        uploadFileData.threadId = params.threadId;
+                    } else {
+                        uploadThreadId = 0;
+                        uploadFileData.threadId = 0;
+                    }
+                    if (typeof params.uniqueId == 'string') {
+                        uploadUniqueId = params.uniqueId;
+                        uploadFileData.uniqueId = params.uniqueId;
+                    } else {
+                        uploadUniqueId = Utility.generateUUID();
+                        uploadFileData.uniqueId = uploadUniqueId;
+                    }
+                    if (typeof params.userGroupHash == 'string') {
+                        uploadFileData.userGroupHash = params.userGroupHash;
+                    } else {
+                        callback({
+                            hasError: true,
+                            errorCode: 999,
+                            errorMessage: 'You need to enter a userGroupHash to be able to upload on PodSpace!'
+                        });
+                        return;
+                    }
+                    if (typeof params.originalFileName == 'string') {
+                        uploadFileData.originalFileName = params.originalFileName;
+                    } else {
+                        uploadFileData.originalFileName = fileName;
+                    }
+                }
+                httpRequest({
+                    url: SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS + SERVICES_PATH.PODSPACE_UPLOAD_FILE_TO_USERGROUP_NEW.replace('{userGroupHash}', uploadFileData.userGroupHash),
+                    method: 'POST',
+                    headers: {
+                        'Authorization': 'Bearer ' + token,
+                    },
+                    data: uploadFileData,
+                    uniqueId: uploadUniqueId
+                }, function (result) {
+                    if (!result.hasError) {
+                        try {
+                            var response = (typeof result.result.responseText == 'string')
+                                ? JSON.parse(result.result.responseText)
+                                : result.result.responseText;
+                            callback({
+                                hasError: response.hasError,
+                                result: response.result
+                            });
+                        } catch (e) {
+                            callback({
+                                hasError: true,
+                                errorCode: 999,
+                                errorMessage: 'Problem in Parsing result'
+                            });
+                        }
+                    } else {
+                        callback({
+                            hasError: true,
+                            errorCode: result.errorCode,
+                            errorMessage: result.errorMessage
+                        });
+                    }
+                });
+                return {
+                    uniqueId: uploadUniqueId,
+                    threadId: uploadThreadId,
+                    participant: userInfo,
+                    content: {
+                        caption: params.content,
+                        file: {
+                            uniqueId: uploadUniqueId,
+                            fileName: fileName,
+                            fileSize: fileSize,
+                            fileObject: params.file
+                        }
+                    }
+                };
+            }
+
             sendFileMessage = function (params, callbacks) {
                 var metadata = {file: {}},
                     fileUploadParams = {},
@@ -8173,6 +8646,8 @@
                         fileUploadParams.userGroupHash = params.userGroupHash;
                     }
 
+                    let msgType = (params.messageType && typeof params.messageType.toUpperCase() !== 'undefined' && chatMessageTypes[params.messageType.toUpperCase()] > 0) ? chatMessageTypes[params.messageType.toUpperCase()] : 1;
+
                     return chatUploadHandler({
                         threadId: params.threadId,
                         file: params.file,
@@ -8184,7 +8659,7 @@
                             message: {
                                 chatMessageVOType: chatMessageVOTypes.MESSAGE,
                                 typeCode: params.typeCode,
-                                messageType: (params.messageType && params.messageType.toUpperCase() !== undefined && chatMessageTypes[params.messageType.toUpperCase()] > 0) ? chatMessageTypes[params.messageType.toUpperCase()] : 1,
+                                messageType: msgType,
                                 subjectId: params.threadId,
                                 repliedTo: params.repliedTo,
                                 content: params.content,
@@ -8195,19 +8670,31 @@
                             },
                             callbacks: callbacks
                         }, function () {
-                            if (imageMimeTypes.indexOf(fileType) >= 0 || imageExtentions.indexOf(fileExtension) >= 0) {
-
-                                uploadImageToPodspaceUserGroup(fileUploadParams, function (result) {
+                            if ((imageMimeTypes.indexOf(fileType) >= 0 || imageExtentions.indexOf(fileExtension) >= 0)) {
+                                uploadImageToPodspaceUserGroupNew(fileUploadParams, function (result) {
                                     if (!result.hasError) {
+                                        // Send onFileUpload callback result
+                                        if (typeof callbacks === 'object' && callbacks.hasOwnProperty('onFileUpload')) {
+                                            callbacks.onFileUpload && callbacks.onFileUpload({
+                                                name: result.result.name,
+                                                hashCode: result.result.hash,
+                                                parentHash: result.result.parentHash,
+                                                size: result.result.size,
+                                                actualHeight: result.result.actualHeight,
+                                                actualWidth: result.result.actualWidth,
+                                                link: `${SERVICE_ADDRESSES.PODSPACE_FILESERVER_ADDRESS}/api/images/${result.result.hash}?checkUserGroupAccess=true`
+                                            });
+                                        }
                                         metadata['name'] = result.result.name;
-                                        metadata['fileHash'] = result.result.hashCode;
+                                        metadata['fileHash'] = result.result.hash;
                                         metadata['file']['name'] = result.result.name;
-                                        metadata['file']['fileHash'] = result.result.hashCode;
-                                        metadata['file']['hashCode'] = result.result.hashCode;
+                                        metadata['file']['fileHash'] = result.result.hash;
+                                        metadata['file']['hashCode'] = result.result.hash;
                                         metadata['file']['parentHash'] = result.result.parentHash;
                                         metadata['file']['size'] = result.result.size;
                                         metadata['file']['actualHeight'] = result.result.actualHeight;
                                         metadata['file']['actualWidth'] = result.result.actualWidth;
+
                                         metadata['file']['link'] = `https://podspace.pod.ir/nzh/drive/downloadImage?hash=${result.result.hashCode}`;
                                         transferFromUploadQToSendQ(parseInt(params.threadId), fileUniqueId, JSON.stringify(metadata), function () {
                                             chatSendQueueHandler();
@@ -8217,13 +8704,14 @@
                                     }
                                 });
                             } else {
-                                uploadFileToPodspace(fileUploadParams, function (result) {
+                                uploadFileToPodspaceUserGroupNew(fileUploadParams, function (result) {
+                                    console.log('result.result.hashCode ::', result.result.hash)
                                     if (!result.hasError) {
-                                        metadata['fileHash'] = result.result.hashCode;
+                                        metadata['fileHash'] = result.result.hash;
                                         metadata['name'] = result.result.name;
                                         metadata['file']['name'] = result.result.name;
-                                        metadata['file']['fileHash'] = result.result.hashCode;
-                                        metadata['file']['hashCode'] = result.result.hashCode;
+                                        metadata['file']['fileHash'] = result.result.hash;
+                                        metadata['file']['hashCode'] = result.result.hash;
                                         metadata['file']['parentHash'] = result.result.parentHash;
                                         metadata['file']['size'] = result.result.size;
 
@@ -10321,13 +10809,200 @@
             });
         };
 
+        function requestExportChat(stackArr, wantedCount, stepCount, offset, sendData) {
+            sendData.content.offset = offset;
+            sendData.content.count = stepCount;
+            return new Promise(function(resolve, reject){
+                return sendMessage(sendData, {
+                    onResult: function (result) {
+
+                        var returnData = {
+                            hasError: result.hasError,
+                            cache: false,
+                            errorMessage: result.errorMessage,
+                            errorCode: result.errorCode
+                        };
+
+                        if (!returnData.hasError) {
+                            for(var i in result.result) {
+                                stackArr.push(result.result[i]);
+                            }
+
+                            consoleLogging && console.log("[SDK][exportChat] a step passed...");
+                            wantedCount = wantedCount > result.contentCount ? result.contentCount : wantedCount;
+                            setTimeout(function () {
+                                fireEvent('threadEvents', {
+                                    type: 'EXPORT_CHAT',
+                                    subType: 'IN_PROGRESS',
+                                    threadId: sendData.subjectId,
+                                    percent: Math.floor((stackArr.length / wantedCount) * 100)
+                                });
+
+                                if(stackArr.length < wantedCount) {
+                                    stepCount = wantedCount - stackArr.length < stepCount ? wantedCount - stackArr.length : stepCount;
+                                    //setTimeout(function () {
+                                    resolve(requestExportChat(stackArr, wantedCount, stepCount, stackArr.length, sendData));
+                                    //}, 1000)
+                                } else {
+                                    resolve(stackArr);
+                                }
+                            });
+                        } else {
+                            if(result.errorCode !== 21) {
+                                consoleLogging && console.log("[SDK][exportChat] Problem in one step... . Rerunning the request.", wantedCount, stepCount, stackArr.length, sendData, result);
+                                setTimeout(function () {
+                                    resolve(requestExportChat(stackArr, wantedCount, stepCount, stackArr.length, sendData))
+                                }, 2000)
+                            } else {
+                                reject(result)
+                            }
+                        }
+                    }
+                });
+            })
+        }
+
+        this.exportChat = function (params, callback) {
+            var stackArr = [], wantedCount = 10000, stepCount = 500, offset = 0;
+            var sendData = {
+                chatMessageVOType: chatMessageVOTypes.EXPORT_CHAT,
+                typeCode: generalTypeCode,//params.typeCode,
+                content: {
+                    offset: +params.offset > 0 ? +params.offset : offset,
+                    count: +params.count > 0 ? +params.count : wantedCount,//config.getHistoryCount,
+                },
+                subjectId: params.threadId
+            };
+
+            if (+params.fromTime > 0 && +params.fromTime < 9999999999999) {
+                sendData.content.fromTime = +params.fromTime;
+            }
+
+            if (+params.toTime > 0 && +params.toTime < 9999999999999) {
+                sendData.content.toTime = +params.toTime;
+            }
+
+            if(+params.wantedCount > 0) {
+                wantedCount = params.wantedCount;
+            }
+
+            if(+params.stepCount > 0) {
+                stepCount = params.stepCount;
+            }
+
+            if(+params.offset > 0) {
+                offset = params.offset;
+            }
+
+            // if (params.messageType && typeof params.messageType.toUpperCase() !== 'undefined' && chatMessageTypes[params.messageType.toUpperCase()] > 0) {
+            //     sendData.content.messageType = chatMessageTypes[params.messageType.toUpperCase()];
+            // }
+            sendData.content.messageType = 1;
+
+            if(wantedCount < stepCount)
+                stepCount = wantedCount;
+
+            consoleLogging && console.log("[SDK][exportChat] Starting...");
+            requestExportChat(stackArr, wantedCount, stepCount, offset, sendData).then(function (resultArray) {
+                consoleLogging && console.log("[SDK][exportChat] Export done..., Now converting...");
+
+                if(!params.exportPath) {
+                    callback && callback({
+                        hasError: false,
+                        result: resultArray
+                    });
+                    fireEvent('threadEvents', {
+                        type: 'EXPORT_CHAT',
+                        subType: 'DONE',
+                        threadId: sendData.subjectId,
+                        result: resultArray
+                    });
+
+                    return;
+                }
+
+                var str = ''
+                    , universalBOM = "\uFEFF";
+
+                str += "\u{62A}\u{627}\u{631}\u{6CC}\u{62E} " + ','; //tarikh
+                str += " \u{633}\u{627}\u{639}\u{62A} " + ','; //saat
+                str += "\u{646}\u{627}\u{645} \u{641}\u{631}\u{633}\u{62A}\u{646}\u{62F}\u{647}" + ',';//name ferestande
+                str += "\u{646}\u{627}\u{645} \u{6A9}\u{627}\u{631}\u{628}\u{631}\u{6CC} \u{641}\u{631}\u{633}\u{62A}\u{646}\u{62F}\u{647}" + ','; //name karbariye ferestande
+                str += "\u{645}\u{62A}\u{646} \u{67E}\u{6CC}\u{627}\u{645}" + ',';//matne payam
+                str += '\r\n';
+                var line = '', radif = 1;
+                for (var i = 0; i < resultArray.length; i++) {
+                    line = '';
+
+                    if(resultArray[i].messageType !== 1) {
+                        continue;
+                    }
+
+                    var sender = '';
+                    if(resultArray[i].participant.contactName) {
+                        sender = resultArray[i].participant.contactName + ',';
+                    } else {
+                        if(resultArray[i].participant.firstName) {
+                            sender = resultArray[i].participant.firstName + ' ';
+                        }
+                        if(resultArray[i].participant.lastName) {
+                            sender += resultArray[i].participant.lastName;
+                        }
+                        sender += ','
+                    }
+
+                    line += new Date(resultArray[i].time).toLocaleDateString('fa-IR') + ',';
+                    line += new Date(resultArray[i].time).toLocaleTimeString('fa-IR') + ',';
+                    line += sender;
+                    line += resultArray[i].participant.username + ',';
+                    line += '"' + resultArray[i].message.replace(/,/g, "،").replace(/"/g, '”') + '",';
+                    // line += result[i].message.replaceAll(",", ".").replace(/(\r\n|\n|\r)/gm, " ") + ',';
+                    str += line + '\r\n';
+                    radif++;
+                }
+
+
+                FS.writeFile(params.exportPath, universalBOM + str, {encoding: 'utf8'}, function (err) {
+                    if (err){
+                        fireEvent('ERROR', {
+                            code: null,
+                            message: err
+                        });
+                        callback && callback({
+                            hasError: true,
+                            code: null,
+                            message: err
+                        });
+                    }
+
+                    callback && callback({
+                        hasError: false,
+                        result: resultArray,
+                        exportPath: params.exportPath
+                    });
+
+                    fireEvent('threadEvents', {
+                        type: 'EXPORT_CHAT',
+                        subType: 'EXPORTED_TO_DIRECTORY',
+                        threadId: sendData.subjectId,
+                        exportPath: params.exportPath,
+                        result: resultArray
+                    });
+
+
+                });
+
+                callback = undefined;
+            })
+        }
+
         this.getImage = getImage;
 
         this.getFile = getFile;
 
-        this.getFileFromPodspace = getFileFromPodspace;
+        this.getFileFromPodspace = getFileFromPodspaceNew;//getFileFromPodspace;
 
-        this.getImageFromPodspace = getImageFromPodspace;
+        this.getImageFromPodspace = getImageFromPodspaceNew;
 
         this.uploadFile = uploadFile;