grnsight 3.0.0 → 5.1.0

package/encryption/server.cert

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDcjCCAloCCQCH8V5lU4wTmDANBgkqhkiG9w0BAQsFADB7MQswCQYDVQQGEwJV
+UzETMBEGA1UECAwKQ2FsaWZvcm5pYTEUMBIGA1UEBwwLTG9zIEFuZ2VsZXMxJDAi
+BgNVBAoMG0xveW9sYSBNYXJ5bW91bnQgVW5pdmVyc2l0eTEbMBkGA1UEAwwSZ3Ju
+c2lnaHQubG9jYWxob3N0MB4XDTE5MDYwMjIyMjUxNVoXDTE5MDcwMjIyMjUxNVow
+ezELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFDASBgNVBAcMC0xv
+cyBBbmdlbGVzMSQwIgYDVQQKDBtMb3lvbGEgTWFyeW1vdW50IFVuaXZlcnNpdHkx
+GzAZBgNVBAMMEmdybnNpZ2h0LmxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQAD
+ggEPADCCAQoCggEBAL+DUWtN2tbIJzI1HvvQ9bf/WJfW4cIp/vaFvmd5XhVH3O8+
+/uRsqHF6IOyMV8xQPzC3TeUZLxFa1QZhgSZAayugALKf74dUOEk4TekedJIrDLLl
+xOqRpn+r14zNVxyO+/4iEeozXkCjVSG5DcBtG/LYmb6Hlf3DAA/nn2qMcW7OxR/E
+So9SXNQLH32PzRzF9q5MtULYWaCv4IVj0itrf8lvsCkmiDX/tbCSxSMNwqlWs7ip
+12hGzPjyYcrBbmsPxsMPmhcorwGw8bOMwJVBr0QAGWYXwXD9KYlOAERq39/XeQ5p
+MfefBNaJHd9RsqkzQ1kzG9lqypiWyTuppJhhvb8CAwEAATANBgkqhkiG9w0BAQsF
+AAOCAQEAusVE7Anl9seWn3okeuvZlo+Fso9RfGroMWkoyLDyzyeQvh1CgzRqMyi9
+I3AEIPPbNDBBEO8yAkUMwt0aCFa5KEjfTgIOMqqHpf4voRFqdK/Tmt3GT71vwqLD
+EGzEK4YsbprJ2xqXxxpajTebn8EvZJrw6zJzLxRils78tALL9keaD13XHQwe3NhE
+JSbRVi0hytruXR/XcxNU4hHriRT0rh22I0w8kLIeuwoDWBAjFiIvqKIifxI6KWDV
+vezkw7AB8oANJr6/n7XMADIwnANU7lSOXHTMfsqwtIyL9qZBNwWE2gOcvSLBmHud
+XZouhmNnLs9UdZEBEocrxmHzXwtVIg==
+-----END CERTIFICATE-----

package/encryption/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC/g1FrTdrWyCcy
+NR770PW3/1iX1uHCKf72hb5neV4VR9zvPv7kbKhxeiDsjFfMUD8wt03lGS8RWtUG
+YYEmQGsroACyn++HVDhJOE3pHnSSKwyy5cTqkaZ/q9eMzVccjvv+IhHqM15Ao1Uh
+uQ3AbRvy2Jm+h5X9wwAP559qjHFuzsUfxEqPUlzUCx99j80cxfauTLVC2Fmgr+CF
+Y9Ira3/Jb7ApJog1/7WwksUjDcKpVrO4qddoRsz48mHKwW5rD8bDD5oXKK8BsPGz
+jMCVQa9EABlmF8Fw/SmJTgBEat/f13kOaTH3nwTWiR3fUbKpM0NZMxvZasqYlsk7
+qaSYYb2/AgMBAAECggEBAJ/sgeYQSomG9KxJjckM0tRGp+2L5FQmi6HDR5/Sys0M
+iKNEwMdxMSwppyrBe2PDMzF0MNj6McLVTgSZEacmrhfs8gg35Gbm3mXOXckoxIF2
+75DIrKqQ3C/LCSGsK21OvYGXY8xl/vQNML8LcD9bHbaqR6DCSm9xEjE143qvMt4q
+3GqyVwFCvy44J0ZQ4DvgV3MZEkesMNIIH22nGXgsf0aeNKxjO0S2A6DHf3DL9l8l
+4y1DXYS4CodQFvx/EpQyGvVdwIo/Hb9de2syb/n92/BZ/aP3dCfLbUfTxKtCAptw
+xQVD306GO6Tkb6wF9L201zBG7ELSVmd/46zpE5OPZHECgYEA517amlwnsMZFjf3t
+Im0Ugxm7QelZP9PDmu7T97gdnuK1ieoE0p1sh/DaIIbkDYvYskD8QlSwr+pKEsts
+5OaHWwEmwfwaOUpQ/Kj9Wyo3TMMy/VI1z+0UKfhkm7aE6FdKVsEAU5BIJW/QAPTV
+NGt7UQoCzXwAFiI9QO+7gvTEpxkCgYEA0+ZLQ15ut6s5RnSn7552V3vPncX/7JH0
+jwVONuCHuL38eo5McT12+/blGEL9Iw+UTst/EoUMMD+bfEVN+7gpsNiIVnAliQdO
+sUyjj6pqajhvwDrfDoHD16xDKVQ5FQK0ZaEYaJZv7j92VdGdymH0V3TBWzwQ9M91
+s3pc46RIXpcCgYBVMfREypJC4X9THaFn/8qBy8PMLWSTwCJStoaOvNkLXGeEdQt5
+kkYYeHOZbpIi+s+8M3mv4wd8f0TvTsC2OLy2oeHnpDDzz42qu38vRog+V9I6vT7b
+ZWz7V1+UhszB0QKqlz7LhmFKh7WL5JttRfaOjKUjjPlrLQhpFN1zBzYyYQKBgEDk
+V8wr0TBCKWogM4W4O3mTGwOwLS3fjMt3znoTzLyQwg8uIM7VCekjtQj3Ctp/3OU8
+gI/FWvQzpoQqHTWnMm1MAoSmF3idWkYFuFk40Rnyapat8L1alAUqZe70Mf7zMxek
+e/sbhu+pU634YaAm21MlGEm+XVr7ZYovQN8d4mPFAoGBAMlNevRguVVuFt//iu4z
+nPF/6qzaTXMk97YHPK8A7RXbXamGb6/RELrmbfLnwD4sEJjRl1cMt08EKPpfFZ1n
+xcR7UcbF2m86xLPQgCqgPMyR3xyYFr5G9DvmbgUCgdN69Q0sD3IW5SOjfwNtbtZi
+M1O6nwbvDbHOFQ9PsCxV23hP
+-----END PRIVATE KEY-----

package/package.json

@@ -1,48 +1,72 @@
 {
   "name": "grnsight",
-  "version": "3.0.0",
+  "version": "5.1.0",
   "description": "Web app and service for visualizing models of gene regulatory networks",
   "directories": {
     "test": "test"
   },
   "dependencies": {
-    "body-parser": "^1.18.2",
+    "body-parser": "1.18.2",
+    "canvg": "2.0.0",
     "cors": "2.8.1",
     "cytoscape": "2.7.14",
-    "d3-v4-grid": "^2.0.1",
-    "errorhandler": "^1.5.0",
-    "express": "^4.16.0",
+    "d3-v4-grid": "2.0.1",
+    "dotenv": "^8.2.0",
+    "errorhandler": "1.5.0",
+    "express": "4.16.0",
+    "fs": "0.0.1-security",
     "googleapis": "1.1.5",
-    "jade": "1.11.0",
-    "method-override": "^2.3.10",
-    "moment": "2.17.1",
-    "morgan": "^1.9.0",
-    "multiparty": "4.1.3",
+    "http": "0.0.0",
+    "jspdf": "1.5.3",
+    "method-override": "2.3.10",
+    "moment": "2.24.0",
+    "morgan": "1.9.1",
+    "multiparty": "4.2.2",
     "node-xlsx": "0.7.2",
-    "nodemon": "1.11.0",
-    "parallelshell": "^3.0.1",
-    "serve-static": "^1.13.1",
+    "nodemon": "1.19.1",
+    "parallelshell": "3.0.1",
+    "pg": "^8.0.0",
+    "pg-hstore": "^2.3.3",
+    "pug": "^3.0.2",
+    "querystring": "^0.2.0",
+    "save-svg-as-png": "1.4.14",
+    "sequelize": "^5.21.6",
+    "serve-static": "1.13.1",
     "should": "11.2.0",
-    "stylus": "0.54.5",
+    "stylus": "^0.54.5",
     "supertest": "3.0.0",
-    "webpack": "^4.0.0",
+    "url": "^0.11.0",
+    "webpack": "4.0.0",
     "xml2js": "0.4.17",
     "xmlbuilder": "8.2.2"
   },
   "devDependencies": {
-    "chai": "1.10.0",
-    "coveralls": "^2.13.1",
-    "eslint": "^3.19.0",
+    "browser-env": "^3.3.0",
+    "chai": "4.1.2",
+    "coveralls": "2.13.1",
+    "eslint": "3.19.0",
+    "isomorphic-fetch": "2.2.1",
     "istanbul": "0.4.5",
+    "jquery": "^3.6.0",
     "jquery-extend": "2.0.3",
-    "markdown-pdf": "^8.0.0",
+    "jsdom": "11.11.0",
+    "markdown-pdf": "8.0.0",
     "mocha": "2.5.3",
-    "mocha-lcov-reporter": "^1.3.0",
-    "webpack-cli": "^2.0.14"
+    "mocha-lcov-reporter": "1.3.0",
+    "nock": "10.0.6",
+    "sinon": "5.1.1",
+    "w3c-xmlserializer": "1.0.1",
+    "webpack-cli": "2.0.14",
+    "xmlserializer": "0.6.1"
+  },
+  "babel": {
+    "presets": [
+      "es2015"
+    ]
   },
   "scripts": {
     "webpack-start": "webpack --watch",
-    "test": "mocha --reporter list",
+    "test": "mocha --reporter list --compilers js:babel-core/register",
     "start-dev": "parallelshell --wait \"nodemon web-client/app.js\" \"nodemon server/app.js\" \"webpack --watch --mode=development\"",
     "start-prod": "parallelshell --wait \"nodemon web-client/app.js\" \"nodemon server/app.js\" \"webpack --watch --mode=production\"",
     "coverage": "istanbul cover _mocha",

package/server/app.js

@@ -15,8 +15,10 @@ var app = express();
 app.set("port", process.env.PORT || config.port || 3000);
 app.use(morgan("dev"));
 app.use(express.json());
-app.use(bodyParser.urlencoded({extended: true}));
-app.use(bodyParser.json());
+// app.use(bodyParser.urlencoded({extended: true}));
+// app.use(bodyParser.json());
+app.use(bodyParser.json({limit: "50mb"}));
+app.use(bodyParser.urlencoded({limit: "50mb", extended: true}));
 app.use(methodOverride());
 app.use(cors());
 
@@ -30,6 +32,8 @@ require(__dirname + "/controllers/spreadsheet-controller")(app);
 require(__dirname + "/controllers/export-controller")(app);
 require(__dirname + "/controllers/import-controller")(app);
 require(__dirname + "/controllers/ga-controller")(app);
+require(__dirname + "/controllers/api-controllers")(app);
+require(__dirname + "/controllers/database-controller")(app);
 
 // Don"t start the server if this app is run as a child process.
 if (!module.parent) {

package/server/config/config.js

@@ -10,28 +10,37 @@ module.exports = {
         root: rootPath,
         app: {
             name: "GRNsight"
-        }
+        },
+        databaseHost: "localhost",  // This will most likely stay as localhost due to tunneling.
+        databaseName: "postgres",
+        databaseDialect: "postgres"
     },
 
     production: {
         host: "grnsight.cs.lmu.edu",
         port: 3000,
-        url: "http://" + this.host + "/server",
-        corsOrigin: "http://grnsight.cs.lmu.edu",
+        url: "https://" + this.host + "/server",
+        corsOrigin: "//grnsight.cs.lmu.edu",
         root: rootPath,
         app: {
             name: "GRNsight"
-        }
+        },
+        databaseHost: "grnsight2.cfimp3lu6uob.us-west-1.rds.amazonaws.com",
+        databaseName: "postgres",
+        databaseDialect: "postgres"
     },
 
     beta: {
         host: "grnsight.cs.lmu.edu",
         port: 4000,
-        url: "http://" + this.host + "/beta/server/",
-        corsOrigin: "http://grnsight.cs.lmu.edu",
+        url: "https://" + this.host + "/beta/server/",
+        corsOrigin: "//grnsight.cs.lmu.edu",
         root: rootPath,
         app: {
             name: "GRNsight"
-        }
+        },
+        databaseHost: "grnsight2.cfimp3lu6uob.us-west-1.rds.amazonaws.com",
+        databaseName: "postgres",
+        databaseDialect: "postgres"
     }
 };

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

@@ -1,87 +1,324 @@
-// Parses "optimization_paramters," expression data sheets, and 2-column sheets
+// Parses "optimization_paramters" and 2-column sheets
 // from GRNmap input or output workbook
 
-var TWO_COL_SHEET_NAMES = [
+var constants = require(__dirname + "/workbook-constants");
+
+const getSheetHeader = (sheetName, column, row) => {
+    if (row === 0) {
+        if (sheetName === "production_rates" || sheetName === "optimized_production_rates") {
+            return "production_rate";
+        } else if (sheetName === "degradation_rates") {
+            return "degradation_rate";
+        } else if (sheetName === "threshold_b" || sheetName === "optimized_threshold_b") {
+            return "threshold_b";
+        } else if (sheetName === "optimization_parameters") {
+            return (column === 0) ? "optimization_parameter" : "value";
+        } else if (sheetName === "optimization_diagnostics") {
+            return (column === 0) ? "Parameter" : "Value";
+        }
+    }
+};
+
+const optimizationParametersTypeKey = {
+    alpha: "number", "kk_max": "number", MaxIter: "number", TolFun: "number", MaxFunEval: "number",
+    TolX: "number", "production_function": "string", "L_curve": "number", "estimate_params": "number",
+    "make_graphs": "number", "fix_P": "number", "fix_b": "number", "expression_timepoints": "object",
+    Strain: "object", species: "string", "taxon_id": "number", "simulation_timepoints": "object", "b_or_tau" : "number"
+
+};
+
+const optimizationDiagnosticsParameters = ["LSE", "Penalty", "min LSE", "iteration count"];
+
+const optimizationParametersObectKey = {
+    "expression_timepoints": "number", Strain: "string", "simulation_timepoints": "number"
+};
+
+const addWarning = (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 addError = (output, message) => {
+    const errorsCount = output.errors.length;
+    const MAX_ERRORS = 20;
+    if (errorsCount < MAX_ERRORS) {
+        output.errors.push(message);
+    } else {
+        output.errors.push(constants.errors.errorsCountError);
+        return false;
+    }
+};
+
+const TWO_COL_SHEET_NAMES = [
     "production_rates",
     "degradation_rates",
     "threshold_b",
     "optimized_production_rates",
-    "optimized_threshold_b"];
-
-var EXPRESSION_SHEET_SUFFIXES = ["_expression", "_optimized_expression", "_sigmas"];
-
-var isExpressionSheet = function (sheetName) {
-    return EXPRESSION_SHEET_SUFFIXES.some(function (suffix) {
-        return sheetName.includes(suffix);
-    });
-};
+    "optimized_threshold_b"
+];
 
-var fillArray = function (value, array, length) { // mutator
-    while (array.length < length) {
-        array.push(value);
+const validGeneName = (output, sheetName, gene, row) => {
+    var maxGeneLength = 12;
+    var regex = /[^a-z0-9\_\-]/gi;
+    if (typeof gene !== "string") {
+        addError(output, constants.errors.invalidGeneTypeError(sheetName, gene, row));
+        return false;
+    } else if (gene.length > maxGeneLength) {
+        addError(output, constants.errors.invalidGeneLengthError(sheetName, gene, row));
+        return false;
+    } else if (gene.match(regex) !== null) {
+        addError(output, constants.errors.specialCharacterError(sheetName, gene, row));
+        return false;
     }
-    return array;
+    return true;
 };
+// Optimization Parameters Parser
+const parseMetaDataSheet = (sheet) => {
+    let meta = {
+        data: {},
+        errors: [],
+        warnings: []
+    };
+    let paramType;
+    if (sheet.data[0][0] === undefined) {
+        addError(meta, constants.errors.missingColumnHeaderError(sheet.name, constants.numbersToLetters[0],
+            getSheetHeader(sheet.name, 0, 0)));
+    } else if (sheet.data[0][0] !== getSheetHeader(sheet.name, 0, 0)) {
+        addError(meta, constants.errors.incorrectColumnHeaderError(sheet.name, constants.numbersToLetters[0],
+            getSheetHeader(sheet.name, 0, 0)));
+    }
+    if (sheet.data[0][1] === undefined) {
+        addError(meta, constants.errors.missingColumnHeaderError(sheet.name, constants.numbersToLetters[1],
+            getSheetHeader(sheet.name, 1, 0)));
+    } else if (sheet.data[0][1] !== getSheetHeader(sheet.name, 1, 0)) {
+        addError(meta, constants.errors.incorrectColumnHeaderError(sheet.name, constants.numbersToLetters[1],
+            getSheetHeader(sheet.name, 1, 0)));
+    }
 
-var parseMetaDataSheet = function (sheet) {
-    var meta = {};
     sheet.data.forEach(function (element, index) {
         if (index !== 0) {
-            var value = element.slice(1);
+            const value = element.slice(1);
             // Extract element from array if array contains only 1 value
-            meta[element[0]] = value.length > 1 ? value : value[0];
+            meta.data[element[0]] = value.length > 1 ? value : value[0];
         }
     });
+    for (let key in meta.data) {
+        paramType = optimizationParametersTypeKey[key];
+        if (paramType === "object") {
+            paramType = `list of ${optimizationParametersObectKey[key]}s`;
+        }
+        if (meta.data[key] === undefined) {
+            addWarning(meta, constants.warnings.unknownOptimizationParameter(sheet.name, key));
+        } else if (typeof meta.data[key] !== optimizationParametersTypeKey[key]) {
+            if (optimizationParametersTypeKey[key] !== "object" ||
+                typeof meta.data[key] !== optimizationParametersObectKey[key]) {
+                addWarning(meta, constants.warnings.invalidOptimizationParameter(sheet.name, key, paramType));
+            }
+        } else if (optimizationParametersTypeKey[key] === "object") {
+            for (let val of meta.data[key]) {
+                if (typeof val !== optimizationParametersObectKey[key]) {
+                    // throw error once per object. Makes sure that errors list is not flooded
+                    addWarning(meta, constants.warnings.invalidOptimizationParameter(sheet.name, key, paramType));
+                    break;
+                }
+            }
+        }
+    }
     return meta;
 };
 
-var parseTwoColumnSheet = function (sheet) {
-    var data = {};
-    sheet.data.forEach(function (element, index) {
-        if (index !== 0) {
-            data[element[0]] = element[1];
+const parseOptimizationDiagnosticsSheet = (sheet) => {
+    let output = {
+        data: {
+            Parameters: {},
+            MSE: {
+                "column-headers": [],
+                Genes: {}
+            },
+        },
+        errors: [],
+        warnings: [],
+    };
+    let currentParameter;
+    let currentValue;
+    let currentGene;
+    let currentMSE = [];
+    // Check Headers
+    if (sheet.data[0].length > 1) {
+        if (sheet.data[0][0] !== getSheetHeader(sheet.name, 0, 0)) {
+            addError(output, constants.errors.incorrectColumnHeaderError(sheet.name, constants.numbersToLetters[0],
+                getSheetHeader(sheet.name, 0, 0)));
         }
-    });
-    return data;
+        if (sheet.data[0][1] !== getSheetHeader(sheet.name, 1, 0)) {
+            addError(output, constants.errors.incorrectColumnHeaderError(sheet.name, constants.numbersToLetters[1],
+                getSheetHeader(sheet.name, 1, 0)));
+        }
+    } else {
+        // seems a bit sus, but we'll see if this works properly during testing :\
+        for (let col = 1; col >= sheet.data[0].length; col--) {
+            addError(output, constants.errors.missingColumnHeaderError(sheet.name, constants.numbersToLetters[col],
+                getSheetHeader(sheet.name, col, 0)));
+        }
+    }
+    // Check Parameter Section
+    let row = 1;
+    // a missing row is the indicator to move onto the MSE
+    while (sheet.data[row].length > 0) {
+        currentParameter = sheet.data[row][0];
+        currentValue = sheet.data[row][1];
+        if (currentParameter === undefined || currentParameter.replace(/\s+/g, "") === "") {
+            if (currentValue === undefined || currentValue.replace(/\s+/g, "") === "") {
+                // if there is no parameter or value assume that its time to move on
+                row++;
+                break;
+            }
+        }
+        if (sheet.data[row].length > 2) {
+            addWarning(output, constants.warnings.extraneousDataWarning(sheet.name, row + 1));
+        }
+        if (! optimizationDiagnosticsParameters.includes(currentParameter)) {
+            if (currentParameter === "Gene") {
+                row--;
+                break;
+            }
+            addWarning(output, constants.warnings.unknownOptimizationDiagnosticsParameter(sheet.name,
+                currentParameter));
+        } else if (typeof currentValue !== "number") {
+            addWarning(output, constants.warnings.invalidOptimizationDiagnosticsValue(sheet.name, currentParameter));
+        } else {
+            output.data.Parameters[currentParameter] = currentValue;
+        }
+        row++;
+    }
+    // Skip until Gene section
+    while (sheet.data[row] !== undefined && sheet.data[row].length < 1) {
+        row++;
+    }
+    // Check Gene section MSE's
+    if (sheet.data[row].length > 1) {
+        if (sheet.data[row][0] !== "Gene") {
+            addWarning(output, constants.warnings.incorrectMSEGeneHeaderWarning(sheet.name, row + 1));
+        }
+        for (let col = 1; col < sheet.data[row].length; col++) {
+            if (!sheet.data[row][col].includes("MSE")) {
+                addWarning(output, constants.warnings.incorrectMSEHeaderWarning(sheet.name, sheet.data[row][col],
+                    row + 1, constants.numbersToLetters[col]));
+            }
+            // we still push the header (even tho it's sus) because the gene MSE's are
+            // dependent on the order of the column headers
+            output.data.MSE["column-headers"].push(sheet.data[row][col]);
+        }
+        row++;
+        // on to the actual genes
+        while (row < sheet.data.length) {
+            if (sheet.data[row].length > output.data.MSE["column-headers"].length + 1) {
+                addWarning(output, constants.warnings.extraneousDataWarning(sheet.name, row + 1));
+            }
+            currentGene = sheet.data[row][0];
+            // if it's a valid gene set the key = MSE value
+            if (validGeneName(output, sheet.name, currentGene, row)) {
+                for (let col = 1; col <= output.data.MSE["column-headers"].length; col++) {
+                    if (typeof sheet.data[row][col] === "number") {
+                        currentMSE.push(sheet.data[row][col]);
+                    } else if (sheet.data[row][col] === undefined) {
+                        addWarning(output, constants.warnings.missingMSEDataWarning(sheet.name, row + 1,
+                            constants.numbersToLetters[col]));
+                    } else {
+                        addWarning(output, constants.warnings.invalidMSEDataWarning(sheet.name, row + 1,
+                            constants.numbersToLetters[col]));
+                    }
+                }
+                output.data.MSE.Genes[currentGene] = currentMSE;
+                currentMSE = [];
+            }
+            row++;
+        }
+    }
+    return output;
 };
 
-var parseExpressionSheet = function (sheet) {
-    var expressionData = {};
-    var geneData = {};
-    expressionData["time_points"] = sheet.data[0].slice(1);
-    var numberOfDataPoints = expressionData["time_points"].length;
-    sheet.data.forEach(function (sheet) {
-        var geneName = sheet[0];
-        if (geneName) {
-            var 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);
+const parseTwoColumnSheet = (sheet) => {
+    let output = {
+        data : {},
+        errors: [],
+        warnings: [],
+    };
+
+    let currentGene;
+    let currentValue;
+
+    // check to see if the genes are strings and the values are numbers
+
+    for (let row = 0; row < sheet.data.length; row++) {
+        if (sheet.data[row].length > 2) {
+            addWarning(output, constants.warnings.extraneousDataWarning(sheet.name, row + 1));
+        }
+        if (row === 0) {
+            if (sheet.data[row].length > 0) {
+                if (sheet.data[row][0] !== "id") {
+                    addError(output, constants.errors.idLabelError(sheet.name));
+                }
+            }
+            if (sheet.data[row].length > 1) {
+                if (sheet.data[row][1] !== getSheetHeader(sheet.name, 1, row)) {
+                    addError(output, constants.errors.incorrectColumnHeaderError(sheet.name,
+                        constants.numbersToLetters[1],
+                        getSheetHeader(sheet.name, 1, row)));
+                }
+            } else {
+                addError(output, constants.errors.missingColumnHeaderError(sheet.name, constants.numbersToLetters[1],
+                    getSheetHeader(sheet.name, 1, row)));
+            }
+        } else {
+            currentGene = sheet.data[row][0];
+            currentValue = sheet.data[row][1];
+
+            if (validGeneName(output, sheet.name, currentGene, row + 1)) {
+                if (typeof currentValue === "number") {
+                    output.data[currentGene] = currentValue;
+                } else {
+                    addError(output, constants.errors.invalidValueError(sheet.name, currentValue, row + 1,
+                        getSheetHeader(sheet.name, 1, row)));
+                }
             }
-            geneData[geneName] = rowData;
         }
-    });
-    expressionData["data"] = geneData;
-    return expressionData;
+    }
+
+    return output;
 };
 
-module.exports = function (workbook) {
-    var output = {
-        expression: {}, // expression data
-        meta: {},
-        test: {} // 2-column data
+module.exports = function (workbookFile) {
+    let output = {
+        meta: {
+            data: {},
+            errors: [],
+            warnings: []
+        }, // optimization_parameters only
+        test: {}, // 2-column data
+        meta2: {} // optimation_diagnostics only //temporary until where it goes is decided
     };
-    workbook.forEach(function (sheet) {
+    workbookFile.forEach(function (sheet) {
         if (sheet.name === "optimization_parameters") {
-            output["meta"] = parseMetaDataSheet(sheet);
-        // Parse 2-column sheets
+            output.meta = parseMetaDataSheet(sheet);
+            // above line creates an object from the optimization paramerters sheet
+            // these are part of the "meta" property
         } else if (TWO_COL_SHEET_NAMES.includes(sheet.name)) {
             output["test"][sheet.name] = parseTwoColumnSheet(sheet);
-        // Parse expression sheets
-        } else if (isExpressionSheet(sheet.name)) {
-            output["expression"][sheet.name] = parseExpressionSheet(sheet);
+        } else if (sheet.name === "optimization_diagnostics") {
+            output.meta2 = parseOptimizationDiagnosticsSheet(sheet);
         }
     });
     return output;
-};
+};

package/server/controllers/api-controllers.js

@@ -0,0 +1,36 @@
+module.exports = function (app) {
+    const request = require("request");
+
+    const UNIPROT_HOST = " http://www.uniprot.org";
+    const JASPAR_HOST = "http://jaspar.genereg.net";
+    const YEASTMINE_HOST = "https://www.yeastgenome.org";
+    const NCBI_HOST = "https://eutils.ncbi.nlm.nih.gov";
+    const ENSEMBL_HOST = "http://rest.ensembl.org";
+
+    const relay = (req, res, host) => {
+        const url = host + req.url;
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+        req.pipe(request(url)).pipe(res);
+    };
+
+    app.use("/uniprot/", (req, res) => {
+        relay(req, res, UNIPROT_HOST);
+    });
+
+    app.use("/jaspar/", (req, res) => {
+        relay(req, res, JASPAR_HOST);
+    });
+
+    app.use("/yeastmine/", (req, res) => {
+        relay(req, res, YEASTMINE_HOST);
+    });
+
+    app.use("/ncbi/", (req, res) => {
+        relay(req, res, NCBI_HOST);
+    });
+
+    app.use("/ensembl/", (req, res) => {
+        relay(req, res, ENSEMBL_HOST);
+    });
+};