@ind-rcg/backend 246.1008.0

package/src/sfAttachmentsHandler.js

@@ -0,0 +1,283 @@
+/*
+ * FILE_HEADER
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const Utils = require("./utils");
+const sharp = require("sharp");
+const md5 = require("md5");
+let log = require('log4js').getLogger("local");
+const _ = require('lodash');
+const GlobalConfig = require('./globalConfig');
+
+const SFAttachmentsHandler = new function () {
+    const getFilePathNotFoundErrorMessage = (fileName, operationName) => {
+        return `The ${fileName} file for the ${operationName} operation either doesn’t exist or couldn’t be found. Check the filename and try again.`;
+    };
+
+    const getGenericErrorMessage = (operationName, error) => {
+        return `We couldn’t complete the ${operationName} operation. Try again or contact Salesforce Support and provide the error details: ${error}`;
+    };
+
+    const getInvalidInputErrorResponse = (operationName) => {
+        log.error(`Invalid input parameters for ${operationName}. Check the input parameters and try again.`);
+        return {
+            success: false,
+            results: { "error_message": Utils.internalServerError }
+        };
+    };
+
+    const generateThumbnail = (fileBuffer, fileType, attachmentFilePath, thumbnailFilePath) => {
+        const tFileType = Utils.getThumbnailImageFormat(fileType);
+
+        if (Utils.isDefined(tFileType)) {
+            // thumbnail image applicable
+            const sharpInstance = sharp(fileBuffer);
+            return sharpInstance.metadata()
+                .then((imageMetadata) => {
+                    if (imageMetadata.width > 480 || imageMetadata.height > 480) {
+                        // generate thumbnail
+                        let thumbnailWidth, thumbnailHeight;
+
+                        if (imageMetadata.width > imageMetadata.height) {
+                            thumbnailWidth = 480;
+                            thumbnailHeight = Math.round((thumbnailWidth / imageMetadata.width) * imageMetadata.height);
+                        } else {
+                            thumbnailHeight = 480;
+                            thumbnailWidth = Math.round((thumbnailHeight / imageMetadata.height) * imageMetadata.width);
+                        }
+                        return sharpInstance.resize(thumbnailWidth, thumbnailHeight).toFile(thumbnailFilePath)
+                            .then(() => {
+                                return {
+                                    finalPath: attachmentFilePath,
+                                    previewPath: thumbnailFilePath
+                                };
+                            })
+                            .catch((e) => {
+                                return Promise.reject(getGenericErrorMessage("saveSFFile", e.message));
+                            });
+                    } else {
+                        // use original image as thumbnail
+                        fs.writeFileSync(thumbnailFilePath, fileBuffer);
+                        return {
+                            finalPath: attachmentFilePath,
+                            previewPath: thumbnailFilePath
+                        };
+                    }
+                })
+                .catch((e) => {
+                    return Promise.reject(getGenericErrorMessage("saveSFFile", e.message));
+                });
+        } else {
+            // use fallback thumbnail image
+            fs.writeFileSync(thumbnailFilePath, Buffer.from(Utils.fallbackThumbnailImageData, "base64"));
+            return Promise.resolve({ finalPath: attachmentFilePath, previewPath: thumbnailFilePath });
+        }
+    };
+
+    this.saveSFFile = (id, fileType, content, readFromPath) => {
+        try {
+
+            if (!Utils.isValidParamString(id) || !Utils.isValidParamString(fileType) || !_.isBoolean(readFromPath)) {
+                log.error(`Invalid input parameters for saveSFFile. Check the input parameters and try again.`);
+                return Promise.reject(Utils.internalServerError);
+            }
+
+            let base64EncodedData;
+
+            if (readFromPath) {
+                // read content data from the local path
+                let filePath = content;
+
+                if (Utils.isFilePathValid(filePath)) {
+                    // TODO: recheck the file path verification logic
+                    if (filePath.startsWith(Utils.getAttachmentFolderName() + path.sep)) {
+                        if (fs.existsSync(filePath)) {
+                            base64EncodedData = fs.readFileSync(filePath, { encoding: "base64" });
+                        } else {
+                            return Promise.reject(getFilePathNotFoundErrorMessage("attachment", "saveSFFile"));
+                        }
+                    } else {
+                        return Promise.reject("This isn’t a supported file path. Specify a valid file path and try again.");
+                    }
+                } else {
+                    return Promise.reject("Looks like you haven't specified a file path for the saveSFFile operation. Specify a file path and try again.");
+                }
+            } else {
+                base64EncodedData = content;
+            }
+
+            if (Utils.isValidString(base64EncodedData)) {
+                const fileBuffer = Buffer.from(base64EncodedData, "base64");
+
+                // file size in MB
+                const fileSize = fileBuffer.length / 1000000;
+                if (fileSize > GlobalConfig.MAX_FILE_SIZE) {
+                    return Promise.reject(`Content data exceeds the size limit of ${GlobalConfig.MAX_FILE_SIZE} for the file ${Utils.getSFFileName(id, fileType)}.`);
+                }
+
+                // get attachment & thumbnail paths
+                let attachmentFilePath = Utils.getSFFilePath(id, fileType);
+                let thumbnailFilePath = Utils.getSFFileThumbnailPath(id, fileType);
+
+                // ensure directory for attachment is available
+                let attachmentPathDir = path.dirname(attachmentFilePath);
+                if (!fs.existsSync(attachmentPathDir)) {
+                    fs.mkdirSync(attachmentPathDir, { recursive: true });
+                }
+
+                fs.writeFileSync(attachmentFilePath, fileBuffer);
+
+                // ensure directory for thumbnail is available
+                let dirName = path.dirname(thumbnailFilePath);
+                if (!fs.existsSync(dirName)) {
+                    fs.mkdirSync(dirName, { recursive: true });
+                }
+
+                return generateThumbnail(fileBuffer, fileType, attachmentFilePath, thumbnailFilePath);
+            } else {
+                return Promise.reject(`The attachment data of the ${Utils.getSFFileName(id, fileType)} file is missing in the request for the saveSFFile operation.`);
+            }
+        } catch (e) {
+            return Promise.reject(getGenericErrorMessage("saveSFFile", e.message));
+        }
+    };
+
+    this.readSFFile = (id, fileType, returnPath) => {
+        const result = { success: false, results: {} };
+
+        try {
+
+            if (!Utils.isValidParamString(id) || !Utils.isValidParamString(fileType) || !_.isBoolean(returnPath)) {
+                return getInvalidInputErrorResponse("readSFFile");
+            }
+
+            // get attachment & thumbnail paths
+            const attachmentFilePath = Utils.getSFFilePath(id, fileType);
+            const thumbnailFilePath = Utils.getSFFileThumbnailPath(id, fileType);
+
+            let errorMessage = "", attachmentPathExists = true, thumbnailPathExists = true;
+            if (!fs.existsSync(attachmentFilePath)) {
+                attachmentPathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(id, fileType) + " attachment", "readSFFile");
+            }
+            if (!fs.existsSync(thumbnailFilePath)) {
+                thumbnailPathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(id, fileType) + " thumbnail", "readSFFile");
+            }
+
+            if (!attachmentPathExists || !thumbnailPathExists) {
+                result.success = false;
+                result.results = { "error_message": errorMessage };
+            } else {
+                if (returnPath) {
+                    // return paths
+                    result.success = true;
+                    result.results = { "finalPath":Utils.makeRelativeUrl(attachmentFilePath), "previewPath": Utils.makeRelativeUrl(thumbnailFilePath) };
+                } else {
+                    // return data
+                    const buffer = fs.readFileSync(attachmentFilePath, { encoding: "base64" });
+                    result.success = true;
+                    result.results = { "content": buffer, "checksum": md5(buffer) };
+                }
+            }
+        } catch (e) {
+            result.success = false;
+            result.results = { "error_message": getGenericErrorMessage("readSFFile", e.message) };
+        }
+
+        return result;
+    };
+
+    this.renameSFFile = (oldId, fileType, newId) => {
+        const result = { success: false, results: {} };
+
+        try {
+
+            if (!Utils.isValidParamString(oldId) || !Utils.isValidParamString(fileType) || !Utils.isValidParamString(newId)) {
+                return getInvalidInputErrorResponse("renameSFFile");
+            }
+
+            // get attachment & thumbnail paths
+            let oldFilePath = Utils.getSFFilePath(oldId, fileType);
+            let oldThumbnailFilePath = Utils.getSFFileThumbnailPath(oldId, fileType);
+
+            let newFilePath = Utils.getSFFilePath(newId, fileType);
+            let newThumbnailFilePath = Utils.getSFFileThumbnailPath(newId, fileType);
+            let errorMessage = "", oldFilePathExists = true, oldThumbnailFilePathExists = true;
+
+            if (!fs.existsSync(oldFilePath)) {
+                oldFilePathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(oldId, fileType) + " attachment", "renameSFFile");
+            }
+
+            if (!fs.existsSync(oldThumbnailFilePath)) {
+                oldThumbnailFilePathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(oldId, fileType) + " thumbnail", "renameSFFile");
+            }
+
+            if (oldFilePathExists && oldThumbnailFilePathExists) {
+                // rename the attachment and thumbnail file
+                fs.renameSync(oldFilePath, newFilePath);
+                fs.renameSync(oldThumbnailFilePath, newThumbnailFilePath);
+                result.success = true;
+                result.results = { "success": true };
+            } else {
+                result.success = false;
+                result.results = { "success": false, "error_message": errorMessage };
+            }
+        } catch (e) {
+            result.success = false;
+            result.results = { "success": false, "error_message": getGenericErrorMessage("renameSFFile", e.message) };
+        }
+
+        return result;
+    };
+
+    this.deleteSFFile = (id, fileType) => {
+        const result = { success: false, results: {} };
+
+        try {
+
+            if (!Utils.isValidParamString(id) || !Utils.isValidParamString(fileType)) {
+                return getInvalidInputErrorResponse("deleteSFFile");
+            }
+
+            // get attachment & thumbnail paths
+            let filePath = Utils.getSFFilePath(id, fileType);
+            let thumbnailFilePath = Utils.getSFFileThumbnailPath(id, fileType);
+            let errorMessage = "", filePathExists = true, thumbnailFilePathExists = true;
+
+            if (!fs.existsSync(filePath)) {
+                filePathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(id, fileType) + " attachment", "deleteSFFile");
+            }
+
+            if (!fs.existsSync(thumbnailFilePath)) {
+                thumbnailFilePathExists = false;
+                errorMessage += getFilePathNotFoundErrorMessage(Utils.getSFFileName(id, fileType) + " thumbnail", "deleteSFFile");
+            }
+
+            if (filePathExists && thumbnailFilePathExists) {
+                // deleting attachment & thumbnail file
+                fs.unlinkSync(filePath);
+                fs.unlinkSync(thumbnailFilePath);
+                result.success = true;
+                result.results = { "success": true };
+            } else {
+                result.success = false;
+                result.results = { "success": false, "error_message": errorMessage };
+            }
+        } catch (e) {
+            result.success = false;
+            result.results = { "success": false, "error_message": getGenericErrorMessage("deleteSFFile", e.message) };
+        }
+
+        return result;
+    };
+}();
+
+module.exports = SFAttachmentsHandler;

package/src/utils.js

@@ -0,0 +1,91 @@
+/*
+ * FILE_HEADER
+ */
+
+"use strict";
+const _ = require('lodash');
+const path = require("path");
+const GlobalConfig = require("./globalConfig");
+
+function Utils() {
+    this.fallbackThumbnailImageData = "iVBORw0KGgoAAAANSUhEUgAAAEwAAABMCAYAAADHl1ErAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAABWZJREFUeNrsXNtOE0EYnlYEagst0KQ1hLTGRC+4kMQXwCegvAF9gvIGwhvIE8gbAE9gb70gqRfGQEJoRaEcUqpFQUXjfO1ss7R7mJndKbvb/ZPJym734DffP/83/xwICU3IIvf14tbPmzw9LLCSoyVvc0uVlhotFZSJR+PVQANGAUrRQ4GWJVoWaUk5fGSTljItO7RsUwCbgQCMArXCQCooftU2wKPAbfoOMMamVVpKLjBJhnkbtLxRwbpIgIAaCHARF8GCy731AFBGwBUpaNueAIyxaos15F42BIhlp2yLusCqQx+ARdg3HrJvHjxg9MVrjFkp4h9rewP79sG5JH0h2qoVn4v2TeqeReWABQQsadAiQwyWFGiRIQdLGLQoJ1hrAQYLtsIbCCIcYBVYNBwGW7YTuBEOUXroM+ngtFfwxErc2rnk1hCB1dVpUm0Yc8VFvyNwdf2LNK+u20feHoFVbyASVFcEQB+rdXLz+0/33PjoQzKfz5JEbEzaNc0Ytup3sD4cfL0DFgx/4zwH27Q0lb1LMnaV/OyGtdMGuf37z/AazuM6h5UYFrYM8zW7YBfffji6bsUyI8B8zS6XrWQJGBuwUM6uj9UT2p7cKnv+yIOoo+t6ljFMTBm2pBqsL+fNtkvsHZ0qe0d2etLRdStMoj2NvdKhMLBKa3ChjVBUWC4zbSodcB7XBaygb/z1DFM9bkgOjs/vRK+9ozNlLvny2RzJZ6dJKhHr+BY94m+cF3DJPmxGBuWOcMPe6ARdBMYJ1rgQ03IZVx4FbDZ7GaasGwRWHRxfmLZpZprJQ7Z4xyXZxBBl0REs6lXdPGB6qVPOMOoybEFZvoQ27GCRldUb30U6x/dlCwMBjJc9p5ctXwGWU+WKvMyJj495HbCcHrC8Cs1l54p6SyfjXgcsb5XecWxQ8rzRD2JSQht120jOzrQrpgQw/AdEVDzctt5oSbk88lvom8rcLyWKVWgumX4i7hkfHekqczt3B0j69hH3J2KjPNlUbzHMKnnHk8WwCxJoF3f3Pxv+jjOb6h3AeDSXPTvPTAEHoJApVtlUq/s9B5gbnenO4MWJo/vBNM8DZtX9kWGqEfgzkwlu0FRlQjTAqk41V7XecPXD0F3qjXwiWg33cw528FpVD1jNqeZSpeX08gRaTQQ0VKKLcqOmB6wiz4SWssypUeTMTE0Kg+5S5KzodZgUYJ3UzLkrwEA/IRvK04UC00QiIYLAi6ezTjVapcswttBJWA9YhXiZ6Mab2UgnE8IV61BuNLXFYPooWRaNZGhY3TRoOB73npmMS1WIA7lRNpIVO6I1pqrN0piA6Is2sncMU3NLGdAkv7uLTXf2DhtKuuTVXG7LiF5A5vOP2/9+/6nW1neYeYN+ZjIeax/xDbIMx+iR4MDLlDaT5850JwoaJpMV7Gppd/9IeVbg+VyGZKcnlFWO9nwOw1rMZTOlb+uWgxqwQPSFK86mU8qezyk3dky7RmxxZtNpo+xWmgjtGdoqwaF97ud35pDd2kXHTbu+5IbZ3YMeqAAD4JKz6aTSSrGwPiz6pmxaTddEbbjVweY1MAyCUxWztecbsYsYTNvsy7jiBxQ0IPu69xoyoij3YTyZWJdtw2iOa2AnBTvNMBGRScHsh0UyvFY0W9xgtxLkHQnAXH3RbhAF65XZxXDpDKcrWrrkELtm0W4RvW0Plq3uWh8CsNZ5tmoIF5h2jHuBabiEWdUS5oCCpnaRfMBAk9qGQWogl73Iz4FgXQYsaYbpmObVDYqsdBbWdZdlHxBuVjRowHzANm9th2XAtnDDNZ8B558t/UzAg/wIN42UZF24LakDAPPEhxvfhiZo/wUYAL/8G5LiHq3BAAAAAElFTkSuQmCC";
+    this.fallbackThumbnailImageFileType = "png";
+    this.internalServerError = "Internal Server Error";
+
+    this.isDefined = value => typeof value !== "undefined" && value !== null;
+
+    this.isEmptyString = (x) => {
+        // returns true if x is null, undefined or a string containing only whitespace
+        return x === null || (_.isString(x) && x.trim() === "");
+    };
+
+    this.getThumbnailImageFormat = (fileType) => {
+        if (fileType.toUpperCase() === "PNG")
+            return "png";
+        else if (fileType.toUpperCase() === "JPG")
+            return "jpeg";
+
+        return null;
+    };
+
+    this.getAttachmentFolderName = () => {
+        return GlobalConfig.AttachmentsFolder;
+    };
+
+    this.getSFFileName = (id, fileType) => {
+        return id + "." + fileType;
+    };
+
+    this.getSFFilePath = (id, fileType) => {
+        return path.join(GlobalConfig.AttachmentsFolder, GlobalConfig.SFFilesBlobFolder, this.getSFFileName(id, fileType));
+    };
+
+    this.getSFFileThumbnailPath = (id, fileType) => {
+        if (fileType.toUpperCase() === "PNG" || fileType.toUpperCase() === "JPG") {
+            // return custom thumbnail image path
+            return path.join(GlobalConfig.AttachmentsFolder, GlobalConfig.ThumbnailsFolder, GlobalConfig.SFFilesBlobFolder, this.getSFFileName(id, this.getThumbnailImageFormat(fileType)));
+        } else {
+            // return fallback thumbnail image path
+            return path.join(GlobalConfig.AttachmentsFolder, GlobalConfig.ThumbnailsFolder, GlobalConfig.SFFilesBlobFolder, this.getSFFileName(id, this.fallbackThumbnailImageFileType));
+        }
+    };
+
+    this.getParamsMissingErrorMessage = (operation) => {
+        return `Some required parameters are missing in the request for the ${operation} operation. Enter values for all the required parameters and try again.`;
+    };
+
+    this.isValidString = (string) => {
+        return this.isDefined(string) && _.isString(string) && !this.isEmptyString(string);
+    };
+
+    this.isValidParamString = (string) => {
+        return this.isValidString(string) && string.length <= GlobalConfig.MAX_PARAM_STRING_LENGTH;
+    };
+
+    this.isFilePathValid = (string) => {
+        return this.isValidString(string) && string.length <= GlobalConfig.MAX_FILE_PATH_LENGTH;
+    };
+   
+    // makeRelativeUrl is only needed for Windows filePath to URL conversion
+    this.makeRelativeUrl = (filePath) => {
+        return filePath.replace(/\\/g, "/");
+    };
+
+    this.sanitizeQuery = (queryStr) => {
+        let sanitizeParamsArray = [];
+        let params = queryStr.parameters;
+        if (_.isArray(params)) {
+            params.forEach(param => {
+                let evilPattern = /[;/*@]/g;
+                if (_.isString(param)) {
+                    param = param.replace(evilPattern, '');
+                }
+                sanitizeParamsArray.push(param);
+            });
+            queryStr.parameters = sanitizeParamsArray;
+        }
+        return queryStr;
+    };
+}
+
+module.exports = new Utils();

package/src/zipHandler.js

@@ -0,0 +1,153 @@
+/*
+ * FILE_HEADER
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const GlobalConfig = require('./globalConfig');
+const JSZip = require('jszip');
+
+const ZipHandler = new function(){
+    this.readSFZipFileFromFolder = (filenameId, folder) => {
+        const filename = filenameId + '.zip';
+        const targetFolder = path.join(folder, GlobalConfig.SFFilesBlobFolder);
+        const filePath = path.join(targetFolder, filename);
+        let result;
+        if (!fs.existsSync(filePath)) {
+            // Required file is not in the system
+            throw new Error(`Theme attachment with ID ${filenameId} not found.`);
+        }
+        const stats = fs.statSync(filePath);
+        if (stats.size > 10240000){
+            // Required file size is bigger than 10 MB
+            throw new Error(`Theme attachment with ID ${filenameId} exceeds size.`);
+        } else {
+            result = fs.readFileSync(filePath, { encoding: 'base64' });
+        }
+        return result;
+    };
+
+    this.extractZipFiles = (filenameId) => {
+        let data;
+        try{
+            data = this.readSFZipFileFromFolder(filenameId, GlobalConfig.AttachmentsFolder);
+        } catch (e) {
+            // Not able to read file from folder
+            return Promise.reject(e.message);
+        }
+        const zip = new JSZip();
+        return zip.loadAsync(data, { base64: true })
+            .then((extractedZip) => extractedZip, () => {
+                // Required file is not a zip file
+                return Promise.reject(`Theme attachment with ID ${filenameId} is not a valid zip.`);
+            });
+    };
+
+    this.createZipFile = (filename, content) => {      
+        const zip = new JSZip();
+        
+        return zip.file(filename, content).generateAsync({type:"nodebuffer"}).then(fileContent => fileContent, () => { 
+            return Promise.reject("The zip contains invalid content. Review the zip contents and try again.");
+        });
+    };
+
+    this.serializeZipAsJSON = (zip) => {
+        const folderFiles = Object.keys(zip.files).map((item) => item.split('/'));
+        const fileCache = folderFiles.reduce((result, item) => {
+            if (!Object.keys(result).includes(item[0])) result[item[0]] = {};
+            return result;
+        }, {});
+        folderFiles.filter((folderFile) => folderFile.length < 3 && folderFile[1] !== '')
+            .forEach((folderFile) => fileCache[folderFile[0]][folderFile[1]] = folderFile[1]);
+        return fileCache;
+    };
+
+    this.validateThemeZip = (attachmentId, zip) => {
+        const validationResult = { isOk: true };
+        const flattenedZip = Object.keys(zip.files).map((item) => item.split('/'));
+        const serializedZip = this.serializeZipAsJSON(zip);
+        const flattenedFiles = Object.keys(serializedZip).reduce((result, key) => {
+            result.push(...Object.keys(serializedZip[key]));
+            return result;
+        }, []);
+
+        const zipFailsByStructure = () => {
+            return flattenedZip.some((fileRoute) => fileRoute.length > 2) || // Subfolders were found
+                !Object.keys(serializedZip).every((key) => GlobalConfig.validThemeFolders.includes(key)) || // Additional top level folders were found
+                !GlobalConfig.validThemeFolders.every((key) => Object.keys(serializedZip).includes(key)); // 'Application' or 'Framework' were not found
+        };
+
+        const zipFailsByEmpty = () => {
+            const containsValidFiles = flattenedFiles.some((fileItem) => {
+                const splittedItem = fileItem.split('.');
+                return GlobalConfig.validFileTypesForThemes.includes(splittedItem[1]);
+            });
+            return Object.keys(serializedZip).every((key) => Object.keys(key).length < 1) || // No Files were found
+                !containsValidFiles; // Not valid types were found
+        };
+
+        const zipFailsByInvalidFileTypes = () => flattenedFiles.some((fileItem) => { // Every file in zip should be *.svg, *.png or *.gif
+            const splittedItem = fileItem.split('.');
+            return !GlobalConfig.validFileTypesForThemes.includes(splittedItem[1]);
+        });
+
+        const zipFailsByRepeatedFileNames = () => { // The file names cannot be repeated using different extensions
+            const filesBackup = {};
+            return flattenedFiles.some((fileItem) => {
+                const splittedItem = fileItem.split('.');
+                if (!Object.keys(filesBackup).includes(splittedItem[0])) { // File is not in the backup
+                    filesBackup[splittedItem[0]] = splittedItem[1];
+                    return false;
+                } else {
+                    return Object.keys(filesBackup).includes(splittedItem[0]) && filesBackup[splittedItem[0]] !== splittedItem[1]; // File is in the backup, so we check the extension
+                }
+            });
+        };
+
+        if (zipFailsByStructure()) {
+            // Occurs when the mandatory folders "Application" or "Framework" are missing.
+            // Or when an additional toplevel folder was found. Or when inside of Application or Framework subfolders were found.
+            validationResult.isOk = false;
+            validationResult.details = `Theme attachment with ID ${attachmentId} has wrong folder structure.`;
+        } else if (zipFailsByEmpty()) {
+            // No files in theme zip
+            validationResult.isOk = false;
+            validationResult.details = `Theme attachment with ID ${attachmentId} is empty.`;
+        } else if (zipFailsByInvalidFileTypes()) {
+            // Found files other than *.svg, *.png or *.gif
+            validationResult.isOk = false;
+            validationResult.details = `Theme attachment with ID ${attachmentId} has unsupported file content.`;
+        } else if (zipFailsByRepeatedFileNames()) {
+            // Found a *.png and *.svg file with the same name e.g. myPic.png and myPic.svg
+            validationResult.isOk = false;
+            validationResult.details = `Theme attachment with ID ${attachmentId} has files with the same name but different file ending.`;
+        }
+        return validationResult;
+    };
+
+    this.writeZipFilesOnMemory = (zip) => {
+        const promiseResult = [];
+        // Remove previous theme zip extraction
+        if (fs.existsSync(GlobalConfig.ThemeImagesFolder)) {
+            fs.rmdirSync(GlobalConfig.ThemeImagesFolder, { recursive: true, force: true });
+        }
+        fs.mkdirSync(GlobalConfig.ThemeImagesFolder);
+        GlobalConfig.validThemeFolders.forEach((folder) => {
+            fs.mkdirSync(path.join(GlobalConfig.ThemeImagesFolder, folder));
+            Object.keys(zip.files).filter((entry) => entry.includes(`${folder}/`))
+                .forEach((fileRoute) => {
+                    if(!zip.files[fileRoute].dir) {
+                        promiseResult.push(zip.files[fileRoute].async('uint8array').then((fileContent) => {
+                            fs.writeFileSync(path.join(GlobalConfig.ThemeImagesFolder, fileRoute), fileContent);
+                            return fileContent;
+                        }));
+                    }
+                });
+        });
+        return Promise.all(promiseResult);
+    };
+}();
+
+module.exports = ZipHandler;