grnsight 4.0.0 → 6.0.0

package/server/controllers/export-constants.js

@@ -0,0 +1,78 @@
+module.exports = {
+    warnings: {
+        // GENERAL WARNINGS
+        // If there are warnings in the original graph already add this warning
+        UNSAFE_EXPORT_WARNING: {
+            warningCode: "UNSAFE_EXPORT_WARNING",
+            errorDescription: " GRNsight has detected that there are warnings in the current graph. Your workbook" +
+                " may be exported improperly. We suggest that you ensure that the original uploaded graph has no " +
+                " warnings or errors, and fix any warnings that are displayed."
+        },
+        // NETWORK OR MATRIX WARNINGS
+        // Check that all sheets fit under the appropriate naming conventions
+        INCORRECT_SHEET_NAME_EXPORT_WARNING: {
+            warningCode: "INCORRECT_SHEET_NAME_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that there is an improperly named sheet in your exported" +
+                " workbook. Please look over your exported workbook and ensure that all sheets are named using the" +
+                " proper naming conventions listed at:\nhttps://dondi.github.io/GRNsight/documentation.html."
+        },
+        // Check that the matrix data values are the same in the graph object and the exported matrix
+        INCORRECT_MATRIX_DATA_EXPORT_WARNING: {
+            warningCode: "NCORRECT_MATRIX_DATA_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that the matrix data has been exported incorrectly into your" +
+                "workbook. Please look over your exported workbook and ensure that the 'network' and/or the" +
+                " 'network_optimized_weights' matrix values are correct."
+        },
+        // Make sure network sheets only have 0/1, make sure network optimized weights sheet has only numbers in matrix
+        IMPROPERLY_FORMATTED_MATRIX_DATA_EXPORT_WARNING: {
+            warningCode: "INCORRECT_MATRIX_DATA_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that the matrix data has been exported incorrectly into your" +
+                " workbook. Please ensure that the 'network' sheet only contains '0' and '1' in the matrix data. " +
+                " Please ensure that the 'network_optimized_weights' sheet contains a '0' if there is no regulatory" +
+                " relationship, a number > 0 if there is an activation relationship, or a number < 0 if there is a" +
+                " repression relationship."
+        },
+        // Make sure genes are semantically fine and that cell A1 is correct
+        IMPROPERLY_FORMATTED_NETWORK_SHEET_EXPORT_WARNING: {
+            warningCode: "INCORRECT_NETWORK_SHEET_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that the 'network' sheet or the 'network_optimized_weights'" +
+                " sheet is improperly formattedPlease look over your exported workbook and ensure that network" +
+                " sheets have cell A1 as 'cols regulators/rows targets' exactly, and all gene are using the  naming" +
+                " conventions listed at: \nhttps://dondi.github.io/GRNsight/documentation.html."
+        },
+        // Missing Source Genes
+        MISSING_SOURCE_GENES_EXPORT_WARNING: {
+            warningCode: "MISSING_SOURCE_GENES_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that there are missing source genes in the exported workbook's." +
+                " 'network' or 'network_optimized_weights' sheet. Please ensure that all source genes are present in" +
+                " the exported workbook."
+        },
+        // Missing Target Genes
+        MISSING_TARGET_GENES_EXPORT_WARNING: {
+            warningCode: "MISSING_TARGET_GENES_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that there are missing target genes in the exported workbook's." +
+                " 'network' or 'network_optimized_weights' sheet. Please ensure that all target genes are present in" +
+                " the exported workbook."
+        },
+        // Additional Source Genes
+        ADDITIONAL_SOURCE_GENES_EXPORT_WARNING: {
+            warningCode: "ADDITIONAL_SOURCE_GENES_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that there are additional source genes in the exported" +
+                " 'network' or 'network_optimized_weights' sheet. Please remove any extra source genes present in" +
+                " the exported workbook."
+        },
+        // Missing Target Genes
+        ADDITIONAL_TARGET_GENES_EXPORT_WARNING: {
+            warningCode: "ADDITIONAL_TARGET_GENES_EXPORT_WARNING",
+            errorDescription: "GRNsight has detected that there are additional target genes in the exported" +
+                " 'network' or 'network_optimized_weights' sheet. Please remove any extra target genes present in" +
+                " the exported workbook."
+        },
+        // EXPRESSION SHEET WARNINGS
+
+
+        // ADDITIONAL SHEET WARNINGS
+
+
+    },
+};

package/server/controllers/export-controller.js

@@ -12,11 +12,12 @@ var convertResponse = function (app, req, res, converter) {
 var exportResponse = function (app, req, res, converter) {
     helpers.attachCorsHeader(res, app);
     res.header("Content-Disposition", "attachment;filename=\"" + req.body.filename + "\"");
-    return res.status(200).send(converter(JSON.parse(req.body.network)));
+    return res.status(200).send(converter(JSON.parse(req.body.workbook)));
 };
 
 var generalExportError = function (res, error) {
-    return res.json(400, {
+    // Express deprecated res.json(status, obj): Use res.status(status).json(obj)
+    return res.status(400).json({
         message: "Invalid GRNsight format.",
         details: {
             name: error.name,
@@ -68,7 +69,7 @@ module.exports = function (app) {
         app.post("/convert-to-excel", function (req, res) {
             try {
                 res.header("Content-Type", "text/xlsx");
-                return convertResponse(app, req, res, grnsightToGraphMl);
+                return convertResponse(app, req, res, grnsightToXlsx);
             } catch (error) {
                 return generalExportError(res, error);
             }

package/server/controllers/exporters/graphml.js

@@ -5,8 +5,8 @@ var INTERACTION_ID = "interaction";
 var NAME_ID = "name";
 var WEIGHT_ID = "weight";
 
-var grnsightToGraphMlJson = function (network) {
-    var convertedNetwork = {
+var grnsightToGraphMlJson = function (workbook) {
+    var convertedWorkbook = {
         graphml: {
             "@xmlns": "http://graphml.graphdrawing.org/xmlns",
             "@xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
@@ -42,8 +42,8 @@ var grnsightToGraphMlJson = function (network) {
         }
     };
 
-    if (network.sheetType === constants.WEIGHTED) {
-        convertedNetwork.graphml.key.push({
+    if (workbook.sheetType === constants.WEIGHTED) {
+        convertedWorkbook.graphml.key.push({
             "@id": WEIGHT_ID,
             "@for": "edge",
             "@attr.name": "weight",
@@ -51,10 +51,10 @@ var grnsightToGraphMlJson = function (network) {
         });
     }
 
-    convertedNetwork.graphml.graph = {
+    convertedWorkbook.graphml.graph = {
         "@edgedefault": "directed",
 
-        node: network.genes.map(function (gene) {
+        node: workbook.genes.map(function (gene) {
             return {
                 "@id": gene.name,
                 data: {
@@ -64,9 +64,9 @@ var grnsightToGraphMlJson = function (network) {
             };
         }),
 
-        edge: network.links.map(function (link) {
-            var sourceGeneId = network.genes[link.source].name;
-            var targetGeneId = network.genes[link.target].name;
+        edge: workbook.links.map(function (link) {
+            var sourceGeneId = workbook.genes[link.source].name;
+            var targetGeneId = workbook.genes[link.target].name;
 
             var edge = {
                 "@source": sourceGeneId,
@@ -84,7 +84,7 @@ var grnsightToGraphMlJson = function (network) {
                 ]
             };
 
-            if (network.sheetType === constants.WEIGHTED) {
+            if (workbook.sheetType === constants.WEIGHTED) {
                 edge.data.push({
                     "@key": WEIGHT_ID,
                     "#text": link.value
@@ -95,15 +95,15 @@ var grnsightToGraphMlJson = function (network) {
         })
     };
 
-    if (network.filename) {
-        convertedNetwork.graphml.graph["@id"] = network.filename;
+    if (workbook.filename) {
+        convertedWorkbook.graphml.graph["@id"] = workbook.filename;
     }
 
-    return convertedNetwork;
+    return convertedWorkbook;
 };
 
-module.exports = function (network) {
-    return xmlbuilder.create(grnsightToGraphMlJson(network), {
+module.exports = function (workbook) {
+    return xmlbuilder.create(grnsightToGraphMlJson(workbook), {
         version: "1.0",
         encoding: "UTF-8"
     }).end({

package/server/controllers/exporters/sif.js

@@ -1,14 +1,14 @@
 var constants = require(__dirname + "/../constants");
 
-var exportEdges = function (network, gene, geneIndex) {
+var exportEdges = function (workbook, gene, geneIndex) {
     var result = "";
 
-    network.links.forEach(function (link) {
+    workbook.links.forEach(function (link) {
         if (link.source === geneIndex) {
             result += [
                 gene.name,
-                network.sheetType === constants.UNWEIGHTED ? "pd" : link.value,
-                network.genes[link.target].name
+                workbook.sheetType === constants.UNWEIGHTED ? "pd" : link.value,
+                workbook.genes[link.target].name
             ].join("\t") + "\n";
         }
     });
@@ -16,11 +16,11 @@ var exportEdges = function (network, gene, geneIndex) {
     return result || (gene.name + "\t\t\n");
 };
 
-module.exports = function (network) {
+module.exports = function (workbook) {
     var result = "";
 
-    network.genes.forEach(function (gene, geneIndex) {
-        result += exportEdges(network, gene, geneIndex);
+    workbook.genes.forEach(function (gene, geneIndex) {
+        result += exportEdges(workbook, gene, geneIndex);
     });
 
     return result;

package/server/controllers/exporters/xlsx.js

@@ -1,6 +1,7 @@
+// const { meta } = require("eslint/lib/rules/*");
 const xlsx = require("node-xlsx");
 
-const bulidGeneNameArray = function (genes) {
+const buildGeneNameArray = function (genes) {
     const geneNameArray = genes.map(gene => gene["name"]);
     return geneNameArray;
 };
@@ -10,7 +11,7 @@ const createArrayWithZeroes = function (length) {
 };
 
 const buildNetworkSheet = function (genes, links) {
-    const geneNameArray = bulidGeneNameArray(genes);
+    const geneNameArray = buildGeneNameArray(genes);
     // The +1 to length is because we ALSO add the gene name to each of the network sheet arrays.
     const networkSheet = genes.map(() => createArrayWithZeroes(genes.length + 1));
 
@@ -20,7 +21,7 @@ const buildNetworkSheet = function (genes, links) {
     geneNameArray.unshift("cols regulators/rows targets");
 
     links.forEach((link) => {
-        networkSheet[link.source][link.target + 1] = link.value;
+        networkSheet[link.target][link.source + 1] = link.value;
     });
 
     networkSheet.unshift(geneNameArray);
@@ -30,36 +31,67 @@ const buildNetworkSheet = function (genes, links) {
 
 const convertToSheet = function (name, testSheet) {
     const singularName = name.toLowerCase().endsWith("s") ? name.substring(0, name.length - 1) : name;
+    const header = singularName.includes("optimized_") ? singularName.substring(10) : singularName;
     return {
         name: name,
-        data: [["id", singularName], ...Object.keys(testSheet).map(key => [key, testSheet[key]])]
+        data: [["id", header], ...Object.keys(testSheet).map(key => [key, testSheet[key]])]
     };
 };
 
-const buildTestSheets = function (testSheet) {
-    const productionRateSheet = convertToSheet("production_rates", testSheet["production_rates"]);
-    const degradationRateSheet = convertToSheet("degradation_rates", testSheet["degradation_rates"]);
-    const thresholdBSheet = convertToSheet("threshold_b", testSheet["threshold_b"]);
-    return [productionRateSheet, degradationRateSheet, thresholdBSheet];
+const buildTestSheets = testSheet => ["production_rates",
+    "degradation_rates",
+    "threshold_b",
+    "optimized_production_rates",
+    "optimized_threshold_b"
+]
+    .filter(name => testSheet[name])
+    .map(name => convertToSheet(name, testSheet[name].data));
+
+const buildMeta2Sheet = function (meta2DataContainer) {
+    const meta2 = [];
+    meta2.push(["Parameter", "Value"]);
+    for (let parameter in meta2DataContainer.data.Parameters) {
+        const meta2Data = meta2DataContainer.data.Parameters[parameter];
+        meta2.push([parameter, meta2Data]);
+    }
+    meta2.push([]);
+    meta2.push(["Gene", ...meta2DataContainer.data.MSE["column-headers"]]);
+    for (let gene in meta2DataContainer.data.MSE.Genes) {
+        const meta2GeneData = meta2DataContainer.data.MSE.Genes[gene];
+        meta2.push([gene, ...meta2GeneData]);
+    }
+    return meta2;
 };
 
 const buildMetaSheet = function (metaDataContainer) {
-    const metaSheet = { name: "optimization_parameters", data: [] };
-    metaSheet["data"].push(["optimization_parameter", "value"]);
-    Object.keys(metaDataContainer).forEach((parameter) => {
-        const metaData = metaDataContainer[parameter];
+    const meta = [];
+    meta.push(["optimization_parameter", "value"]);
+    for (let parameter in metaDataContainer.data) {
+        const metaData = metaDataContainer.data[parameter];
         const cleanedUpData = Array.isArray(metaData)
             ? [parameter, ...metaData]
             : [parameter, metaData];
-        metaSheet["data"].push(cleanedUpData);
+        meta.push(cleanedUpData);
+    }
+    return meta;
+};
+
+const EXPRESSION_SHEET_SUFFIXES = ["_expression", "_optimized_expression", "_sigmas"];
+
+const isExpressionSheet = (sheetName) => {
+    return EXPRESSION_SHEET_SUFFIXES.some(function (suffix) {
+        return sheetName.includes(suffix);
     });
-    return metaSheet;
 };
 
 const buildExpressionSheets = function (expressions) {
     const builtExpressionSheets = [];
     Object.keys(expressions).forEach((expression) => {
-        const builtSheet = { name: expression, data: []};
+        let expressionName = expression;
+        if (!isExpressionSheet(expression)) {
+            expressionName = expression + "_expression";
+        }
+        const builtSheet = { name: expressionName, data: [] };
         Object.keys(expressions[expression]["data"]).forEach((key) => {
             const expressionData = expressions[expression]["data"][key];
             builtSheet["data"].push([key, ...expressionData]);
@@ -69,30 +101,74 @@ const buildExpressionSheets = function (expressions) {
     return builtExpressionSheets;
 };
 
-const buildXlsxSheet = function (network) {
+const buildXlsxSheet = function (workbook) {
     const resultSheet = [];
-    resultSheet.push(
-        {
-            "name": "network",
-            "data": buildNetworkSheet(network.genes, network.links)
-        },
-
-        {
-            "name": "network_weights",
-            "data": buildNetworkSheet(network.genes, network.links)
-        }
-    );
+    const exportNetworkType = workbook.exportNetworkType;
 
-    Object.keys(network).forEach((key) => {
+    Object.keys(workbook).forEach((key) => {
         switch (key) {
+        case "network":
+            if (Object.keys(workbook.network).length > 0) {
+                resultSheet.push(
+                    {
+                        "name": "network",
+                        "data": buildNetworkSheet(workbook.network.genes, workbook.network.links)
+                    }
+                );
+            }
+            break;
+        case "networkOptimizedWeights":
+            if (exportNetworkType === "weighted") {
+                if (Object.keys(workbook.networkOptimizedWeights).length > 0) {
+                    resultSheet.push(
+                        {
+                            "name": "network_optimized_weights",
+                            "data": buildNetworkSheet(workbook.networkOptimizedWeights.genes,
+                                workbook.networkOptimizedWeights.links)
+                        }
+                    );
+                }
+            }
+            break;
+        case "networkWeights":
+            if (Object.keys(workbook.networkWeights).length > 0) {
+                resultSheet.push(
+                    {
+                        "name": "network_weights",
+                        "data": buildNetworkSheet(workbook.networkWeights.genes, workbook.networkWeights.links)
+                    }
+                );
+            }
+            break;
         case "meta":
-            resultSheet.push(buildMetaSheet(network[key]));
+            if (Object.keys(workbook.meta).length > 0) {
+                resultSheet.push(
+                    {
+                        "name": "optimization_parameters",
+                        "data": buildMetaSheet(workbook.meta)
+                    }
+                );
+            }
+            break;
+        case "meta2":
+            // Optimization Diagnostics sheet not properly  implemented yet.
+            if (Object.keys(workbook.meta2).length > 0) {
+                resultSheet.push(
+                    {
+                        "name": "optimization_diagnostics",
+                        "data": buildMeta2Sheet(workbook.meta2)
+                    }
+                );
+            }
             break;
         case "test":
-            resultSheet.push(...buildTestSheets(network[key]));
+            resultSheet.push(...buildTestSheets(workbook[key]));
             break;
         case "expression":
-            resultSheet.push(...buildExpressionSheets(network[key]));
+            // resultSheet.push(...buildExpressionSheets(workbook[key]));
+            break;
+        case "exportExpression":
+            resultSheet.push(...buildExpressionSheets(workbook[key]));
             break;
         default:
             break;
@@ -102,6 +178,6 @@ const buildXlsxSheet = function (network) {
     return resultSheet;
 };
 
-module.exports = function (network) {
-    return xlsx.build(buildXlsxSheet(network));
+module.exports = function (workbook) {
+    return xlsx.build(buildXlsxSheet(workbook));
 };

package/server/controllers/expression-database-controller.js

@@ -0,0 +1,19 @@
+
+var expressionDal = require(__dirname + "/../dals/expression-dal");
+
+
+module.exports = function (app) {
+
+    app.get("/expressiondb", function (req, res) {
+        try {
+            return expressionDal.queryExpressionDatabase(req, res);
+        } catch (e) {
+            res.json({error: e.stack});
+            res.json({error: e.name});
+            res.json({error: e.message});
+
+        }
+    });
+
+
+};

package/server/controllers/expression-sheet-parser.js

@@ -0,0 +1,170 @@
+// Parses "optimization_paramters," expression data sheets, and 2-column sheets
+// from GRNmap input or output workbook
+
+var constants = require(__dirname + "/workbook-constants");
+
+const EXPRESSION_SHEET_SUFFIXES = ["_expression", "_optimized_expression", "_sigmas"];
+
+const addExpWarning = (workbook, message) => {
+    let warningsCount;
+    if (!Object.keys(workbook).includes("warnings")) {
+        warningsCount = 0;
+        workbook.warnings = [];
+    } else {
+        warningsCount = workbook.warnings.length;
+    }
+    const MAX_WARNINGS = 75;
+    if (warningsCount < MAX_WARNINGS) {
+        workbook.warnings.push(message);
+    } else {
+        workbook.errors.push(constants.errors.warningsCountError);
+        return false;
+    }
+};
+
+const addExpError = (workbook, message) => {
+    const errorsCount = workbook.errors.length;
+    const MAX_ERRORS = 20;
+    if (errorsCount < MAX_ERRORS) {
+        workbook.errors.push(message);
+    } else {
+        workbook.errors.push(constants.errors.errorsCountError);
+        return false;
+    }
+};
+
+const fillArray = (value, array, length) => { // mutator
+    while (array.length < length) {
+        array.push(value);
+    }
+    return array;
+};
+
+const isExpressionSheet = (sheetName) => {
+    return EXPRESSION_SHEET_SUFFIXES.some(function (suffix) {
+        return sheetName.includes(suffix);
+    });
+};
+
+// Going to continue basing this section off of the parseWorkbookSheet function in spreadsheet-controller.js
+var parseExpressionSheet = function (sheet) {
+
+    var geneData = {};
+    var expressionData = {
+        errors: [],
+        warnings: [],
+        timePoints: [],
+        columnGeneNames: []
+    };
+
+    // Check that id label is correct. Throw error if not.
+    const idLabel = sheet.data[0][0];
+    if (idLabel !== "id") {
+        addExpError(expressionData, constants.errors.idLabelError(sheet.name));
+    }
+    expressionData.timePoints = sheet.data[0].slice(1);
+    const numberOfDataPoints = expressionData.timePoints.length;
+    let compareTimePoint = 0;
+    for (let i = 0; i < numberOfDataPoints; i++) {
+        if (isNaN(expressionData.timePoints[i]) && expressionData.timePoints[i] !== undefined) {
+            addExpError(expressionData, constants.errors.nonNumericalTimePointsError(i + 1, sheet.name));
+        } else if (expressionData.timePoints[i] < 0) {
+            addExpError(expressionData, constants.errors.negativeTimePointError(i + 1, sheet.name));
+        } else if (expressionData.timePoints[i] < compareTimePoint) {
+            addExpError(expressionData, constants.errors.nonMonotonicTimePointsError(i + 1, sheet.name));
+            break;
+        } else {
+            compareTimePoint = expressionData.timePoints[i];
+        }
+
+    }
+    let geneNames = [];
+    sheet.data.forEach(function (sheet) {
+
+        const geneName = sheet[0];
+        if (geneName) {
+            geneNames.push(geneName);
+            const rowData = sheet.slice(1);
+            // Sometimes, missing data is at the end of the row. In this case, pad the
+            // array with nulls
+            if (rowData.length < numberOfDataPoints) {
+                fillArray(null, rowData, numberOfDataPoints);
+            }
+            geneData[geneName] = rowData;
+        }
+    });
+    geneNames = geneNames.slice(1);
+    geneNames.forEach(x => expressionData.columnGeneNames.push(x));
+    expressionData.data = geneData;
+    if (expressionData.data.id) {
+        // Throw warning in case of extraneous data
+        // Need to add a case where it checks the depth of the columns, as well
+        const rowLength = expressionData.data.id.length;
+        let rowCounter = 0;
+        let columnChecker = new Array(rowLength).fill(0);
+        Object.values(expressionData.data).forEach(function (row) {
+            if (row.length !== rowLength) {
+                addExpWarning(expressionData, constants.warnings.extraneousDataWarning(sheet.name, row));
+            }
+            // Check for missing Column Headers
+            if (rowCounter === 0) {
+                for (let i = 0; i < rowLength; i++) {
+                    if (sheet.data[0][i] === undefined) {
+                        addExpError(expressionData, constants.errors.missingColumnHeaderError(sheet.name));
+                    }
+                }
+            } else {
+                for (var i = 0; i < rowLength; i++) {
+                    if (sheet.data[rowCounter][i] !== undefined) {
+                        columnChecker[i]++;
+                    }
+                }
+            }
+
+            let nonnullCount = 0;
+            // check for empty rows
+            for (let i = 0; i <= rowLength; i++) {
+                if (i === rowLength) {
+                    if (nonnullCount === 0) {
+                        addExpError(expressionData, constants.errors.emptyExpressionRowError(i, sheet.name));
+                        break;
+                    }
+                } else {
+                    if (row[i]) {
+                        nonnullCount++;
+                    }
+                }
+            }
+            rowCounter++;
+        });
+        // check for empty columns
+        for (var i = 0; i < columnChecker.length; i++) {
+            if (columnChecker[i] === 0) {
+                addExpError(expressionData, constants.errors.emptyExpressionColumnError(i, sheet.name));
+            }
+        }
+    }
+
+    return expressionData;
+};
+
+module.exports = function (workbook) {
+    const output = {
+        expression: {},
+        warnings: [],
+        errors: []
+    };
+    var expCount = 0;
+
+    workbook.forEach(function (sheet) {
+        if (isExpressionSheet(sheet.name)) {
+            output["expression"][sheet.name] = parseExpressionSheet(sheet);
+            expCount++;
+        }
+    });
+
+    if (expCount <= 0) {
+        addExpWarning(output, constants.warnings.missingExpressionWarning());
+    }
+    return output;
+};

package/server/controllers/graphml-constants.js

@@ -1,19 +1,3 @@
-var graphmlWarnings = {
-    EDGES_WITHOUT_WEIGHTS: {
-        warningCode: "EDGES_WITHOUT_WEIGHTS",
-        errorDescription: "GRNsight has detected that one or more edges in your network are missing numerical" +
-        " weight values. Because the algorithm GRNsight uses for determining the arrowhead type and the" +
-        " color and thickness of the edges requires numerical weight values, your graph will" +
-        " display as an unweighted graph with black edges and pointed arrowheads. If you want to" +
-        " display the network as a weighted graph, please modify your input file to include weight" +
-        " values for all edges."
-    },
-    EDGE_DEFAULT_NOT_DIRECTED: {
-        warningCode: "EDGE_DEFAULT_NOT_DIRECTED",
-        errorDescription: "GRNsight interprets the graph as directed unconditionally."
-    },
-};
-
 var graphmlErrors = {
     GRAPHML_GENERAL_SYNTAX_ERROR: function (error) {
         return {
@@ -166,7 +150,6 @@ var pairError = function (error) {
 
 module.exports = {
     graphmlErrors: graphmlErrors,
-    graphmlWarnings: graphmlWarnings,
     errorMessageToGraphmlError: errorMessageToGraphmlError,
     pairError: pairError,
 };

package/server/controllers/helpers.js

@@ -1,5 +1,26 @@
 var constants = require(__dirname + "/constants");
 
+var createEmptyWorkbook = function () {
+    return {
+        genes: [],
+        links: [],
+        errors: [],
+        warnings: [],
+        positiveWeights: [],
+        negativeWeights: [],
+        sheetType: "",
+        meta: {},
+        expression:{}
+    };
+};
+
+// Outside of module.exports because needs too access createEmptyWorkbook
+var initWorkbook = function (net) {
+    const workbook = createEmptyWorkbook();
+    Object.assign(workbook, net);    // copies fields without overriding empty ones :)
+    return workbook;
+};
+
 module.exports = {
 
     attachCorsHeader: function (res, app) {
@@ -10,6 +31,9 @@ module.exports = {
         res.header("Access-Control-Allow-Methods", "POST, GET");
         res.header("Access-Control-Expose-Headers", constants.GRNSIGHT_FILENAME_HEADER);
         res.header(constants.GRNSIGHT_FILENAME_HEADER, path.split("/").pop());
-    }
+    },
+
+    createEmptyWorkbook: createEmptyWorkbook,
+    initWorkbook: initWorkbook
 
 };