@ind-rcg/backend 246.1008.0

package/src/local.js

@@ -0,0 +1,546 @@
+/*
+ * FILE_HEADER
+ */
+
+"use strict";
+
+const sqlite3 = require("sqlite3");
+const TransactionDatabase = require("sqlite3-transactions").TransactionDatabase;
+const fs = require("fs");
+const path = require("path");
+
+const log = require('log4js').getLogger("local");
+const _ = require('lodash');
+let db;
+const mobileNativeCode = require('bindings')('mobileNativeCode.node');
+const GlobalConfig = require('./globalConfig');
+const os = require('os');
+const SFAttachmentsHandler = require("./sfAttachmentsHandler");
+const ZipHandler = require('./zipHandler');
+const Utils = require("./utils");
+
+let priceEngine;
+
+const loadExtensionAsync = (distanceDatabaseExtension) => {
+    return new Promise(function(resolve, reject) {
+        db.loadExtension(distanceDatabaseExtension, function (status) {
+            if (_.isNil(status)) {
+                resolve();
+            } else {
+                reject(status);
+            }
+        });
+    });
+};
+
+let initialize = (webServerConfig) => {
+    // get db file (path) from config
+    let file = webServerConfig.database;
+    priceEngine = new mobileNativeCode.PriceEngineWrap();
+
+    if (!fs.existsSync(file)) {
+        log.error("DB file", file, "does not exist!");
+        return Promise.reject(false);
+    } 
+
+    const openDBResponse = priceEngine.openDbConnection(file);
+
+    //failed to open db connection
+    if(!openDBResponse.success) {
+        log.error(`We couldn’t complete the openDbConnection operation. Try again or contact Salesforce Support and provide the error details: ${JSON.stringify(openDBResponse?.results?.messages)}`);
+        return Promise.reject(false);
+    }
+
+    // console.log("before " + file);
+    db = new sqlite3.Database(file, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE);
+    //console.log("after " + file);
+    log.info("The local database", file, "started successfully.");
+
+    //retrieves the path to the node module in each case (sfdx plugin / local development)
+    let sqlLiteExtensionModulePath = path.join(path.dirname(__filename), '..', 'bin');
+
+    let distanceDatabaseExtension = os.type() === "Darwin" ?
+        path.join(sqlLiteExtensionModulePath, "libsqliteExtension.dylib"):
+        path.join(sqlLiteExtensionModulePath, "libsqliteExtension.dll");
+
+    if (!fs.existsSync(distanceDatabaseExtension)) {
+        log.error("DB extension", distanceDatabaseExtension, "not found. SQL distance() function will not be available.");
+        return Promise.resolve(true);
+    }
+
+    return loadExtensionAsync(distanceDatabaseExtension)
+        .then(() => {
+            log.info("The database extension loaded successfully. The SQL operator DISTANCE() is ready for use in the server.");
+            return Promise.resolve(true);
+        })
+        .catch((err) => {
+            log.error("Couldn't load the database extension. The SQL operator DISTANCE() is unavailable for use in the server. "+
+                "Try again or contact Salesforce Support with the status code:", err);
+            return Promise.resolve(true);
+        });
+};
+
+
+
+let closeDBConnection = () => {
+    //closing the db connection
+    const closeDBResponse = priceEngine.closeDbConnection();
+
+    //failure occurred
+    if(!closeDBResponse.success) {
+        log.error(`We couldn’t complete the closeDbConnection operation. Try again or contact Salesforce Support and provide the error details: ${JSON.stringify(closeDBResponse?.results?.messages)}`);
+    }
+    
+    return closeDBResponse.success;
+};
+
+let sendResponse = (startTime, resultSet, res) => {
+    log.debug("OVERALL EXECUTION TIME:", new Date() - startTime, "ms");
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(resultSet));
+};
+
+let execCall = (payload, res) => {
+    const queries = payload.workload instanceof Array ? payload.workload : [payload.workload];
+    log.debug(`/exec REQUEST WITH ${queries.length} `);
+    const startTime = new Date();
+    let exec = function (dbRef, queriesRef, execCb) {
+        let results = [],
+            querysLength = queries.length;
+        return queriesRef.forEach(function (queryEle, i) {
+            let query = Utils.sanitizeQuery(queryEle);
+            let qid;
+            let params;
+            if (_.isObject(query)) {
+                params = query.parameters;
+                qid = query.qid;
+                query = query.query;
+            }
+            log.debug("QUERY", i, ":", JSON.stringify(query));
+            if (!query) return;
+            query = query.trim();
+            let cb = function(err){
+                let result = {
+                    "result": true
+                };
+                if(!_.isUndefined(qid))
+                    result.qid = qid;
+                if(err){
+                    result.result = false;
+                    result.rowsAffected = 0;
+                }else{
+                    result.rowsAffected = this.changes;
+                }
+                if(results.push(result) === querysLength)
+                    execCb(results);
+            };
+            if (params) {
+                let stmt = dbRef.prepare(query);
+                stmt.run(params, cb);
+            } else {
+                dbRef.run(query, cb);
+            }
+        });
+    };
+    if (_.isEmpty(queries)) {
+        log.debug("The request is empty. Provide a valid request and try again.");
+        sendResponse(startTime, { success: true, results: [] }, res);
+    } else if (payload.transaction === "1") {
+        log.debug("OPENING A TRANSACTION...");
+        let tranDb = new TransactionDatabase(db);
+        tranDb.beginTransaction(function (err, T) {
+            if (err) log.error("Error opening transaction!", err);
+            else {
+                exec(T, queries, results => {
+                    T.commit(function (error) {
+                        if (error) {
+                            log.error("Transaction commit failed!", error);
+                            T.rollback();
+                            sendResponse(startTime, { success: false, results: error.message }, res);
+                            return;
+                        } else {
+                            log.debug("Transaction committed successfully!");
+                            sendResponse(startTime, { success: true, results: results }, res);
+                        }
+                    });
+                });
+            }
+        });
+    } else {
+        exec(db, queries, results => {
+            sendResponse(startTime, { success: true, results: results }, res);
+        });
+    }
+};
+
+let queryCall = (payload, res) => {
+    const query = payload.workload;
+    if (!query) return;
+
+    const anchor_id = payload.anchor_id;
+
+    const result = {
+        "anchor_id": anchor_id,
+        "success": true
+    };
+
+    log.debug("/query", "REQUEST RECEIVED");
+    const startTime = new Date();
+    
+    let getQueryFn = queryRef => {
+        if (queryRef.parameters) {
+            const params = queryRef.parameters;
+            queryRef = queryRef.query.trim();
+            
+            return cb => {
+                let stmt = db.prepare(queryRef, (resInner)=>{
+                    if(resInner !== null){
+                        //prepare failed
+                        cb(resInner, []);
+                    } else {
+                        stmt.all(params, cb);
+                    } 
+                } );
+            };
+        } else {
+            queryRef = queryRef.trim();
+            return cb => db.all(queryRef, cb);
+        }
+    };
+
+    let fn;
+    if (_.isArray(query)) {
+        result.results = [];
+        const iterator = queryRef => {
+            if(queryRef.length > 0){
+                let currentQuery = queryRef.shift();
+                fn = getQueryFn(currentQuery);
+                fn(function (err, rows) {
+                    log.debug("QUERY:", JSON.stringify(currentQuery));
+                    if (err) {
+                        result.success = false;
+                        log.error("ERROR:", err);
+                        result.results.push({
+                            "qid": currentQuery.qid,
+                            "result": err.message});
+                    } else {
+                        log.debug("ROWS RETURNED:", rows.length);
+                        result.results.push({
+                            "qid": currentQuery.qid,
+                            "result": rows});
+                    }
+                    iterator(queryRef);
+                });
+            }else{
+                log.debug(JSON.stringify(result));
+                sendResponse(startTime, result, res);
+            }
+        };
+        iterator(query);
+    } else {
+        fn = getQueryFn(query);
+        fn(function (err, rows) {
+            log.debug("QUERY:", JSON.stringify(query));
+            if (err) {
+                result.success = false;
+                log.error("ERROR:", err);
+                result.results = err.message;
+                sendResponse(startTime, result, res);
+            } else {
+                log.debug("ROWS RETURNED:", rows.length);
+                result.results = rows;
+                log.debug(JSON.stringify(rows));
+                sendResponse(startTime, result, res);
+            }
+        });
+    }
+};
+
+let __mimeTypeToExtension = (mimeType) => {
+    const knownTypes = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/svg+xml": "svg",
+        "application/pdf": "pdf",
+        "application/zip": "zip"
+
+    };
+    return knownTypes[mimeType];
+};
+
+
+let __composeResponse = (targetFolder, newfileName, content, payload, res) => {
+    if (!fs.existsSync(targetFolder)) {
+        fs.mkdirSync(targetFolder);
+    }
+    fs.writeFileSync(path.join(targetFolder, newfileName), content);
+    sendResponse(new Date().getTime(), {
+        success: true,
+        performance: 0,
+        anchor_id: payload.anchor_id,
+        results: path.join(GlobalConfig.hesaFolder, newfileName)
+    }, res);
+};
+
+module.exports.performCall = (req, res) => {
+        
+    // Checkmarx False Positive
+    // This function is only used on a developer machine to improve implementation speed. The data which will be retrieved by that 
+    // function can be accessed over the developers file system anyway. This part of the application is only for internal developer 
+    // purpose and not live outside.
+    let payload = req.body;
+    
+    if (req.headers['content-type'] === 'application/octet-stream') {
+        payload = JSON.parse(req.body);
+    }
+
+    log.debug(`Executing operation : ${payload.operation}`);
+    log.debug(`Payload : ${JSON.stringify(payload)}`);
+
+    if (payload.operation === 'executeBatch' || payload.operation === 'executeParameterized'  || payload.operation === 'execute' ) {
+        execCall(payload, res);
+    } else if (payload.operation === 'select' || payload.operation === 'selectParameterized') {
+        queryCall(payload, res);
+    } else if (payload.operation === 'savePrintingData') {
+        log.debug('saving printing data for print:', payload.workload);     
+        let printId = payload.workload[0];
+        let printData = payload.workload[1];
+        let printingDataFolder = 'Printing';
+        if (!fs.existsSync(printingDataFolder)) {
+            fs.mkdirSync(printingDataFolder);
+        }
+        let dataFile = path.join(printingDataFolder, (printId + '.json'));
+        fs.writeFileSync(dataFile, printData);
+        sendResponse(new Date().getTime(), {success: true, anchor_id: payload.anchor_id, results: []}, res);
+    } else if(payload.operation === 'saveDatasourceToggles') {
+        let toggleData = payload.workload[0];
+        let DataSourceGenerationFolder = 'DataSourceGeneration';
+        if (!fs.existsSync(DataSourceGenerationFolder)) {
+            fs.mkdirSync(DataSourceGenerationFolder);
+        }
+        let dataFile = path.join(DataSourceGenerationFolder, ('Toggles.json'));
+        let hasSucceeded = false;
+        try {
+            //Reparse to write the data in pretty print format
+            let toggleDataJSON = JSON.parse(toggleData);
+            fs.writeFileSync(dataFile, JSON.stringify(toggleDataJSON, null, 4));
+            hasSucceeded = true;
+        } catch (e) {
+            log.error("The saveDatasourceToggles operation failed. Review the exception details to fix the issue, or contact Salesforce Support for help.", e);
+        }
+        sendResponse(new Date().getTime(), {success: hasSucceeded, anchor_id: payload.anchor_id, results: []}, res);
+    } else if(payload.operation === 'saveDatasourceParameters') {
+        let boName = payload.workload[0];
+        let paramsData = payload.workload[1];
+        let DataSourceGenerationFolder = 'DataSourceGeneration';
+        if (!fs.existsSync(DataSourceGenerationFolder)) {
+            fs.mkdirSync(DataSourceGenerationFolder);
+        }
+        let dataFile = path.join(DataSourceGenerationFolder, (boName + '.json'));
+        let hasSucceeded = false;
+        try {
+            //Reparse to write the data in pretty print format
+            let paramsDataJSON = JSON.parse(paramsData);
+            fs.writeFileSync(dataFile, JSON.stringify(paramsDataJSON, null, 4));
+            hasSucceeded = true;
+        } catch (e) {
+            log.error("The saveDatasourceParameters operation failed. Review the exception details to fix the issue, or contact Salesforce Support for help.", e);
+        }
+        sendResponse(new Date().getTime(), {success: hasSucceeded, anchor_id: payload.anchor_id, results: []}, res);
+    } else if (payload.operation === 'saveAttachment') {
+        const dataUrl = payload.workload[0];
+        const blobPKey = payload.workload[2];
+
+        if (!Utils.isValidParamString(blobPKey) || !Utils.isValidParamString(payload.workload[1]) || !Utils.isValidString(dataUrl)) {
+            const invalidParamErrorMessage = "Invalid input parameters for saveAttachment. Check the input parameters and try again.";
+            log.error(invalidParamErrorMessage);
+            sendResponse(new Date().getTime(), { success: false, performance: 0, anchor_id: payload.anchor_id, results: false, error_message: invalidParamErrorMessage }, res);
+        }
+
+        const regex = /^data:(\w+\/[\w+]+);base64,(.+)$/;
+        const matches = dataUrl.match(regex);
+        const extension = __mimeTypeToExtension(matches[1]);
+
+        if (!Utils.isValidParamString(extension)) {
+            const errorMessage = "This isn’t a supported file extension. Specify a valid file extension and try again.";
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), { success: false, performance: 0, anchor_id: payload.anchor_id, results: false, error_message: errorMessage }, res);
+        }
+
+        const tableName = payload.workload[1] + GlobalConfig.BlobFolder;
+        const targetFolder = path.join(GlobalConfig.AttachmentsFolder, tableName);
+        const data = matches[2];
+        const buffer = Buffer.from(data, 'base64');
+
+        if (!fs.existsSync(targetFolder)) {
+            fs.mkdirSync(targetFolder);
+        }
+
+        const filename = Utils.getSFFileName(blobPKey, extension);
+        fs.writeFileSync(path.join(targetFolder, filename), buffer);
+        sendResponse(new Date().getTime(), { success: true, performance: 0, anchor_id: payload.anchor_id, results: true }, res);
+
+    } else if(payload.operation === 'validateThemeZip') {
+        log.debug('validateThemeZip:', payload.workload);
+        ZipHandler.extractZipFiles(payload.workload[0])
+            .then((zip) => {
+                const results = ZipHandler.validateThemeZip(payload.workload[0], zip);
+                if (!results.isOk){
+                    sendResponse(new Date().getTime(), { success: true, anchor_id: payload.anchor_id, results }, res);
+                } else {
+                    sendResponse(new Date().getTime(), { success: true, anchor_id: payload.anchor_id, results }, res);
+                }
+            }, (details) => {
+                sendResponse(new Date().getTime(), {success: true, anchor_id: payload.anchor_id, results: { isOk: false, details }}, res);
+            });
+    } else if(payload.operation === 'extractThemeZip') {
+        log.debug('extractThemeZip:', payload.workload);
+        ZipHandler.extractZipFiles(payload.workload[0])
+            .then((zip) => {
+                ZipHandler.writeZipFilesOnMemory(zip).then(() => {
+                    sendResponse(new Date().getTime(), {success: true, anchor_id: payload.anchor_id, results: { success: true, fileCache: ZipHandler.serializeZipAsJSON(zip) }}, res);
+                });
+            }, (details) => {
+                sendResponse(new Date().getTime(), {success: true, anchor_id: payload.anchor_id, results: { success: false, details }}, res);
+            });
+    } else if(payload.operation === 'saveSFFile') {
+        if (req && req.body && req.body.workload && req.body.workload.length === 4) {
+            SFAttachmentsHandler.saveSFFile(req.body.workload[0], req.body.workload[1], req.body.workload[2], req.body.workload[3])
+                .then((result) => {
+                    sendResponse(new Date().getTime(), {
+                        success: true,
+                        performance: 0,
+                        anchor_id: payload.anchor_id,
+                        results: result
+                    }, res);
+                })
+                .catch((errorMessage) => {
+                    log.error("error saving SFFile! " + errorMessage);
+                    sendResponse(new Date().getTime(), {success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage}}, res);
+                });
+        } else {
+            const errorMessage = Utils.getParamsMissingErrorMessage(payload.operation);
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), {success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage }}, res);
+        }
+
+    } else if (payload.operation === 'readSFFile') {
+        if (req && req.body && req.body.workload && req.body.workload.length >= 2 && req.body.workload.length <= 3) {
+            const result = SFAttachmentsHandler.readSFFile(req.body.workload[0], req.body.workload[1], req.body.workload[2] ? req.body.workload[2] : false);
+            sendResponse(new Date().getTime(), {
+                success: result.success,
+                performance: 0,
+                anchor_id: payload.anchor_id,
+                results: result.results
+            }, res);
+        } else {
+            const errorMessage = Utils.getParamsMissingErrorMessage(payload.operation);
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), {success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage }}, res);
+        }
+
+    } else if (payload.operation === 'renameSFFile') {
+        if (req && req.body && req.body.workload && req.body.workload.length >= 3) {
+            let oldId = req.body.workload[0];
+            let fileType = req.body.workload[1];
+            let newId = req.body.workload[2];
+
+            const result = SFAttachmentsHandler.renameSFFile(oldId, fileType, newId);
+            sendResponse(new Date().getTime(), {
+                success: result.success,
+                performance: 0,
+                anchor_id: payload.anchor_id,
+                results: result.results
+            }, res);
+        } else {
+            const errorMessage = Utils.getParamsMissingErrorMessage(payload.operation);
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), {success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage }}, res);
+        }
+    } else if (payload.operation === 'deleteSFFile') {
+        if (req && req.body && req.body.workload && req.body.workload.length >= 2) {
+            let id = req.body.workload[0];
+            let fileType = req.body.workload[1];
+
+            const result = SFAttachmentsHandler.deleteSFFile(id, fileType);
+            sendResponse(new Date().getTime(), {
+                success: result.success,
+                performance: 0,
+                anchor_id: payload.anchor_id,
+                results: result.results
+            }, res);
+
+        } else {
+            const errorMessage = Utils.getParamsMissingErrorMessage(payload.operation);
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), { success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage } }, res);
+        }
+    } else if (payload.operation === 'conditionSearch') {
+        if (req && req.body && req.body.workload) {
+
+            const workload = req.body.workload;
+            if (!Array.isArray(workload)) {
+                log.error(`Invalid input parameters for conditionSearch. Check the input parameters and try again.`);
+                sendResponse(new Date().getTime(), { success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": Utils.internalServerError } }, res);
+            }
+
+            let conditionJSON = JSON.stringify(req.body.workload);
+
+            //search for conditions
+            const response = priceEngine.conditionSearch(conditionJSON);
+
+            if (!response.success) {
+                //failure case
+                const errorMessage = response.results.messages.toString();
+                log.error(`We couldn’t complete the conditionSearch operation. Try again or contact Salesforce Support and provide the error details: ${errorMessage}`);
+                sendResponse(new Date().getTime(), {
+                    success: false,
+                    performance: 0,
+                    anchor_id: payload.anchor_id,
+                    results: { "error_message": errorMessage }
+                }, res);
+            } else {
+                sendResponse(new Date().getTime(), {
+                    success: response.success,
+                    performance: 0,
+                    anchor_id: payload.anchor_id,
+                    results: JSON.parse(response.results.conditions)
+                }, res);
+            }
+        } else {
+            const errorMessage = Utils.getParamsMissingErrorMessage(payload.operation);
+            log.error(errorMessage);
+            sendResponse(new Date().getTime(), {success: false, performance: 0, anchor_id: payload.anchor_id, results: { "error_message": errorMessage }}, res);
+        }
+    } else if (payload.operation === 'saveFile') {
+        const data = payload.workload[0];
+        const type = payload.workload[1];
+        const compress = payload.workload[2];
+
+        if (!Utils.isValidString(data) || !Utils.isValidParamString(type) || !_.isBoolean(compress)) {
+            const errorMessage = "Invalid input parameters for saveFile. Check the input parameters and try again.";
+            sendResponse(new Date().getTime(), {
+                success: false,
+                performance: 0,
+                anchor_id: payload.anchor_id,
+                results: { "error_message": errorMessage }
+            }, res);
+        }
+        const targetFolder = path.join(GlobalConfig.AttachmentsFolder, GlobalConfig.hesaFolder);
+        const filename = Utils.getSFFileName(new Date().getTime().toString(), type);
+        if(compress) {
+            ZipHandler.createZipFile(filename, data).then(content => {
+                let newfileName = filename.substring(0, filename.indexOf(".")) + ".zip";
+                __composeResponse(targetFolder, newfileName, content, payload, res);
+            });
+        } else {
+            __composeResponse(targetFolder, filename, data, payload, res);
+        }
+    } else {
+        log.error("Probably UNKNOWN operation detected :: " + payload.operation + " -->  " + payload.action);
+        sendResponse(new Date().getTime(), { success: true, anchor_id: payload.anchor_id, results: [] }, res);
+    }
+};
+
+module.exports.initialize = initialize;
+module.exports.closeDBConnection = closeDBConnection;

package/src/server.js

@@ -0,0 +1,64 @@
+/*
+ * FILE_HEADER
+ */
+
+"use strict";
+
+const log4js = require('log4js');
+
+const bootstrap = require('./bootstrap');
+const argsParser = require('./argsParser');
+const fsHelper = require('./fsHelper');
+
+let result = argsParser.run(process.argv);
+if (result && result.success) {
+   
+    let settings = result.data;
+
+    // configure logging
+    log4js.configure(settings.loggingConfig);
+    const log = log4js.getLogger('server');
+
+    // load web server configuration file
+    let webServerConfig = fsHelper.readJsonFile(settings.webServerConfig);
+    if (webServerConfig) {
+
+        // configure, setup and start web server
+        bootstrap.setup(webServerConfig)
+            .then((app) => {
+                // take port from webServerConfig or take fallback/default port 3000
+                let webServerPort = webServerConfig.port || 3000;
+
+                const server = app.listen(webServerPort, "localhost", function () {
+                    const port = server.address().port;
+                    log.info('Backend server has started. Use the URL http://localhost:' +
+                        port +
+                        '/framework/index.html?desktop to perform any testing activities. ' +
+                        'It is recommended to execute the application in incognito window of your browser ' +
+                        'and take care only one incognito window is opened to avoid influences.');
+                    log.info('Use CTRL+C to stop the backend server.');
+                });
+
+                server.on('close', function () {
+                    bootstrap.closeConnection();
+                    log.info('The server closed successfully.');
+                });
+
+                // listen for SIGINT signal
+                process.on('SIGINT', function () {
+                    server.close();
+                });
+            })
+            .catch(() => {
+                log.error("Couldn't start the backend server and the web application setup failed. Verify that the TCP port is available and you have the required permissions to perform this task. If the issue persists, contact Salesforce Support for help.");
+                process.exit(1);
+            });
+    } else {
+        log.error("The backend server failed to start and the web server configuration file couldn't be loaded. Make sure the appropriate access permissions are configured and that the configuration file format is valid. If the issue persists, contact Salesforce Support for help.");
+        process.exit(1);
+    }
+
+} else {
+    console.error('The backend server failed to start. Review the error details to fix the issue, and if the issue persists, contact Salesforce Support for help:', result.error ? result.error : '');
+    process.exit(1);
+}