grnsight 6.0.4 → 7.1.1

package/server/dals/protein-dal.js

@@ -0,0 +1,106 @@
+const Sequelize = require("sequelize");
+require("dotenv").config();
+var env = process.env.NODE_ENV || "development";
+var config = require("../config/config")[env];
+var sequelize = new Sequelize(
+    config.databaseName,
+    process.env.EXPRESSION_DB_USERNAME,
+    process.env.EXPRESSION_DB_PASSWORD,
+    {
+        host: config.databaseHost,
+        dialect: config.databaseDialect,
+        pool: {
+            max: 5,
+            min: 0,
+            idle: 10000
+        }
+    }
+);
+
+const buildNetworkSourceQuery = function () {
+    return "SELECT * FROM protein_protein_interactions.source ORDER BY time_stamp DESC;";
+};
+
+const buildNetworkFromGeneProteinQuery = function (geneProtein) {
+    return `SELECT DISTINCT gene_id, display_gene_id, standard_name, length, molecular_weight, PI FROM
+ protein_protein_interactions.gene, protein_protein_interactions.protein WHERE
+ (LOWER(gene.gene_id)=LOWER('${geneProtein}') OR LOWER(gene.display_gene_id)=LOWER('${geneProtein}') 
+ OR LOWER(protein.standard_name) =LOWER('${geneProtein}')) AND
+ LOWER(gene.gene_id) = LOWER(protein.gene_systematic_name);`;
+};
+
+const buildNetworkProteinsQuery = function (proteinString) {
+    let proteins = "(";
+    let proteinList = proteinString.split(",");
+    proteinList.forEach(x => proteins += ( `(physical_interactions.protein1 =\'${x}\') OR `));
+    proteins = `${proteins.substring(0, proteins.length - 4)}) AND (`;
+    proteinList.forEach(x => proteins += ( `(physical_interactions.protein2 =\'${x}\') OR `));
+    return `${proteins.substring(0, proteins.length - 4)})`;
+
+};
+
+const buildGenerateProteinNetworkQuery = function (proteins, timestamp, source) {
+    return `SELECT DISTINCT protein1, protein2 FROM
+ protein_protein_interactions.physical_interactions WHERE
+ physical_interactions.time_stamp='${timestamp}' AND physical_interactions.source='${source}' AND
+ ${buildNetworkProteinsQuery(proteins)} ORDER BY protein1 DESC;`;
+};
+
+const buildQueryByType = function (query) {
+    const networkQueries = {
+        "NetworkSource": () => buildNetworkSourceQuery(),
+        "NetworkFromGeneProtein": () => buildNetworkFromGeneProteinQuery(query.geneProtein),
+        "GenerateProteinNetwork": () => buildGenerateProteinNetworkQuery(query.proteins, query.timestamp, query.source)
+    };
+    if (Object.keys(networkQueries).includes(query.type)) {
+        return networkQueries[query.type]();
+    }
+};
+
+const convertResponseToJSON = function (queryType, totalOutput) {
+    let JSONOutput = {};
+    switch (queryType) {
+    case "NetworkSource":
+        JSONOutput.sources = {};
+        totalOutput.forEach(function (x) {
+            const timestamp = x.time_stamp;
+            const source = x.source;
+            const displayName = x.display_name;
+            JSONOutput.sources[`${displayName}: ${timestamp.toISOString().split("T")[0]}`] = {timestamp, source};
+        });
+        return JSONOutput;
+    case "NetworkFromGeneProtein":
+        if (totalOutput.length > 0) {
+            JSONOutput.standardName = totalOutput[0].standard_name;
+            JSONOutput.displayGeneId = totalOutput[0].display_gene_id;
+            JSONOutput.geneId = totalOutput[0].gene_id;
+            JSONOutput.length = totalOutput[0].length;
+            JSONOutput.molecularWeight = totalOutput[0].molecular_weight;
+            JSONOutput.PI = totalOutput[0].PI;
+        }
+        return JSONOutput;
+    case "GenerateProteinNetwork":
+        JSONOutput.links = {};
+        for (let connection of totalOutput) {
+            if (JSONOutput.links[connection.protein1] === undefined) {
+                JSONOutput.links[connection.protein1] = [connection.protein2];
+            } else {
+                JSONOutput.links[connection.protein1].push(connection.protein2);
+            }
+        }
+        return JSONOutput;
+    default:
+        return JSONOutput;
+    }
+
+};
+
+module.exports = {
+    queryProteinDatabase: function (req, res) {
+        sequelize.query(buildQueryByType(req.query), { type: sequelize.QueryTypes.SELECT })
+            .then(function (stdname) {
+                const response = convertResponseToJSON(req.query.type, stdname);
+                return res.send(response);
+            });
+    }
+};

package/test/export-tests.js

@@ -2,6 +2,7 @@ var expect = require("chai").expect;
 var extend = require("jquery-extend");
 var xlsx = require("node-xlsx");
 var test = require("./test");
+const { CELL_A1_PPI, CELL_A1_GRN } = require("../server/controllers/constants");
 
 var exportController = require(__dirname + "/../server/controllers/export-controller")();
 var constants = require(__dirname + "/../server/controllers/constants");
@@ -20,7 +21,8 @@ var unweightedTestWorkbook = {
     ],
     errors: [],
     warnings: [],
-    sheetType: "unweighted"
+    sheetType: "unweighted",
+    workbookType: constants.NETWORK_GRN_MODE
 };
 
 var weightedTestWorkbook = {
@@ -37,7 +39,8 @@ var weightedTestWorkbook = {
     ],
     errors: [],
     warnings: [],
-    sheetType: "weighted"
+    sheetType: "weighted",
+    workbookType: constants.NETWORK_GRN_MODE
 };
 
 var unweightedTestWorkbookWithCycle = {
@@ -57,7 +60,8 @@ var unweightedTestWorkbookWithCycle = {
     ],
     errors: [],
     warnings: [],
-    sheetType: "unweighted"
+    sheetType: "unweighted",
+    workbookType: "constants.NETWORK_GRN_MODE"
 };
 
 var weightedTestWorkbookWithCycle = {
@@ -77,7 +81,8 @@ var weightedTestWorkbookWithCycle = {
     ],
     errors: [],
     warnings: [],
-    sheetType: "weighted"
+    sheetType: "weighted",
+    workbookType: constants.NETWORK_GRN_MODE
 };
 
 describe("Export to SIF", function () {
@@ -407,6 +412,100 @@ describe("Export to GraphML", function () {
     });
 });
 
+const inputPPIWorkbook = {
+    "genes": [
+        { "name": "Aim32p" },
+        { "name": "Ccr4p" },
+        { "name": "Erv1p" }
+    ],
+
+    "links": [
+        {
+            "source": 0,
+            "target": 1,
+            "value": 1,
+            "type": "arrowhead",
+            "stroke": "black"
+        },
+        {
+            "source": 1,
+            "target": 1,
+            "value": 1,
+            "type": "arrowhead",
+            "stroke": "black",
+        },
+        {
+            "source": 0,
+            "target": 2,
+            "value": 1,
+            "type": "arrowhead",
+            "stroke": "black",
+        },
+        {
+            "source": 2,
+            "target": 2,
+            "value": 1,
+            "type": "arrowhead",
+            "stroke": "black",
+        }
+    ],
+
+    network: {
+        "genes": [
+            { "name": "Aim32p" },
+            { "name": "Ccr4p" },
+            { "name": "Erv1p" }
+        ],
+
+        "links": [
+            {
+                "source": 0,
+                "target": 1,
+                "value": 1,
+                "type": "arrowhead",
+                "stroke": "black"
+            },
+            {
+                "source": 1,
+                "target": 1,
+                "value": 1,
+                "type": "arrowhead",
+                "stroke": "black",
+            },
+            {
+                "source": 0,
+                "target": 2,
+                "value": 1,
+                "type": "arrowhead",
+                "stroke": "black",
+            },
+            {
+                "source": 2,
+                "target": 2,
+                "value": 1,
+                "type": "arrowhead",
+                "stroke": "black",
+            }
+        ],
+    },
+    networkWeights: {},
+
+    "meta": {
+        data: {
+            "workbookType": "protein-protein-physical-interaction",
+            "species": "Saccharomyces cerevisiae",
+            "taxon_id": "559292",
+        }
+    },
+};
+
+inputPPIWorkbook.exportSheets = {
+    networks: {
+        "network": inputPPIWorkbook.network
+    },
+    "optimization_parameters": inputPPIWorkbook.meta
+};
+
 const inputWorkbook = {
     "genes": [
         { "name": "ACE2" },
@@ -550,7 +649,8 @@ const inputWorkbook = {
             "production_function": "testMM",
             "simulation_timepoints": [0, 0.1, 0.2],
             "species": "Saccharomyces cerevisiae",
-            "taxon_id": 559292
+            "taxon_id": 559292,
+            "workbookType": constants.NETWORK_GRN_MODE
         }
     },
 
@@ -659,12 +759,12 @@ inputWorkbook.exportSheets = {
 };
 
 describe("Export to spreadsheet", function () {
-    it("should export a workbook to a spreadsheet object properly", function () {
+    it("should export a workbook of gene regulatory network to a spreadsheet object properly", function () {
         const expectedSheet = [
             {
                 name: "network",
                 data: [
-                    ["cols regulators/rows targets", "ACE2", "AFT2", "CIN5"],
+                    [CELL_A1_GRN, "ACE2", "AFT2", "CIN5"],
                     ["ACE2", 1, 0, 0],
                     ["AFT2", 0, 1, 1],
                     ["CIN5", 0, 0, 1]
@@ -674,7 +774,7 @@ describe("Export to spreadsheet", function () {
             {
                 name: "network_weights",
                 data: [
-                    ["cols regulators/rows targets", "ACE2", "AFT2", "CIN5"],
+                    [CELL_A1_GRN, "ACE2", "AFT2", "CIN5"],
                     ["ACE2", 1, 0, 0],
                     ["AFT2", 0, 1, 1],
                     ["CIN5", 0, 0, 1]
@@ -701,7 +801,8 @@ describe("Export to spreadsheet", function () {
                     ["production_function", "testMM"],
                     ["simulation_timepoints", 0, 0.1, 0.2],
                     ["species", "Saccharomyces cerevisiae"],
-                    ["taxon_id", 559292]
+                    ["taxon_id", 559292],
+                    ["workbookType", constants.NETWORK_GRN_MODE]
                 ]
             },
 
@@ -791,6 +892,32 @@ describe("Export to spreadsheet", function () {
         expect(actualSheet).to.deep.equal(xlsx.build(expectedSheet));
     });
 
+    it("should export a workbook of ppi to a spreadsheet object properly", function () {
+        const expectedSheet = [
+            {
+                name: "network",
+                data: [
+                    [CELL_A1_PPI, "Aim32p", "Ccr4p", "Erv1p"],
+                    ["Aim32p", 0, 0, 0],
+                    ["Ccr4p", 1, 1, 0],
+                    ["Erv1p", 1, 0, 1]
+                ]
+            },
+
+            {
+                name: "optimization_parameters",
+                data: [
+                    ["optimization_parameter", "value"],
+                    ["workbookType", constants.NETWORK_PPI_MODE],
+                    ["species", "Saccharomyces cerevisiae"],
+                    ["taxon_id", "559292"]
+                ]
+            }
+        ];
+        const actualSheet = exportController.grnsightToXlsx(inputPPIWorkbook);
+        expect(actualSheet).to.deep.equal(xlsx.build(expectedSheet));
+    });
+
     it("should export a workbook exactly as the import",
         function () {
             // Commented out temporarily while reworking the export of the optimization diagnostics sheet

package/test/import-sif-tests.js

@@ -7,7 +7,7 @@ var importController = require(__dirname + "/../server/controllers" + "/import-c
 var constants = require(__dirname + "/../server/controllers" + "/constants");
 var initWorkbook = require(__dirname + "/../server/controllers" + "/helpers.js").initWorkbook;
 
-var expectedUnweightedWorkbook = initWorkbook({
+let expectedUnweightedGRNWorkbook = initWorkbook({
     genes: [
         { name: "A" },
         { name: "B" },
@@ -27,9 +27,35 @@ var expectedUnweightedWorkbook = initWorkbook({
     negativeWeights: [],
     sheetType: "unweighted",
     meta: {},
-    expression:{}
+    expression:{},
+    workbookType: constants.NETWORK_GRN_MODE
+});
+
+let expectedUnweightedPPIWorkbook = initWorkbook({
+    genes: [
+        { name: "A" },
+        { name: "B" },
+        { name: "C" },
+        { name: "D" }
+    ],
+
+    links: [
+        { source: 1, target: 0 },
+        { source: 1, target: 2 },
+        { source: 2, target: 1 }
+    ],
+
+    errors: [],
+    warnings: [],
+    positiveWeights: [],
+    negativeWeights: [],
+    sheetType: "unweighted",
+    meta: {},
+    expression:{},
+    workbookType: constants.NETWORK_PPI_MODE
 });
 
+
 var expectedWeightedWorkbook = initWorkbook({
     genes: [
         { name: "A" },
@@ -50,6 +76,7 @@ var expectedWeightedWorkbook = initWorkbook({
     negativeWeights: [],
     sheetType: "weighted",
     meta: {},
+    workbookType: constants.NETWORK_GRN_MODE,
     expression:{}
 });
 
@@ -76,7 +103,8 @@ var expectedUnweightedWorkbookWithCycle = initWorkbook({
     negativeWeights: [],
     sheetType: "unweighted",
     meta: {},
-    expression:{}
+    expression:{},
+    workbookType: constants.NETWORK_GRN_MODE
 });
 
 var expectedWeightedWorkbookWithCycle = initWorkbook({
@@ -102,18 +130,26 @@ var expectedWeightedWorkbookWithCycle = initWorkbook({
     negativeWeights: [],
     sheetType: "weighted",
     meta: {},
-    expression:{}
+    expression:{},
+    workbookType: constants.NETWORK_GRN_MODE
 });
 
 // Unweighted SIF
 
-var unweightedTestSif = [
+var unweightedGRNTestSif = [
     "A",
     [ "B", "pd", "A", "C" ].join("\t"),
     [ "C", "pd", "B" ].join("\t"),
     "D"
 ].join("\r\n"); // Mix up linebreak types to test normalization.
 
+var unweightedPPITestSif = [
+    "A",
+    [ "B", "pp", "A", "C" ].join("\t"),
+    [ "C", "pp", "B" ].join("\t"),
+    "D"
+].join("\r\n"); // Mix up linebreak types to test normalization.
+
 var unweightedTestSifWithCycle = [
     [ "A", "pd", "A" ].join("\t"),
     [ "B", "pd", "A", "C" ].join("\t"),
@@ -283,8 +319,11 @@ var sifWithSemanticErrorOnly = [
 describe("Import from SIF", function () {
     it("should import unweighted workbooks from SIF correctly", function () {
         expect(
-            importController.sifToGrnsight(unweightedTestSif)
-        ).to.deep.equal(expectedUnweightedWorkbook);
+            importController.sifToGrnsight(unweightedGRNTestSif)
+        ).to.deep.equal(expectedUnweightedGRNWorkbook);
+        expect(
+            importController.sifToGrnsight(unweightedPPITestSif)
+        ).to.deep.equal(expectedUnweightedPPIWorkbook);
     });
 
     it("should import weighted workbooks from SIF correctly", function () {
@@ -296,7 +335,7 @@ describe("Import from SIF", function () {
     it("should import inconsistently weighted workbooks from SIF as unweighted", function () {
         expect(
             importController.sifToGrnsight(inconsistentlyWeightedTestSif)
-        ).to.deep.equal(extend(true, {}, expectedUnweightedWorkbook, {
+        ).to.deep.equal(extend(true, {}, expectedUnweightedGRNWorkbook, {
             warnings: [
                 constants.warnings.EDGES_WITHOUT_WEIGHTS
             ]
@@ -350,7 +389,8 @@ describe("Import from SIF", function () {
             negativeWeights: [],
             sheetType: "unweighted",
             meta: {},
-            expression:{}
+            expression:{},
+            workbookType: constants.NETWORK_GRN_MODE
         }));
     });
 
@@ -368,7 +408,8 @@ describe("Import from SIF", function () {
             negativeWeights: [],
             sheetType: "weighted",
             meta: {},
-            expression:{}
+            expression:{},
+            workbookType: constants.NETWORK_GRN_MODE
         }));
     });
 
@@ -399,11 +440,11 @@ describe("Import from SIF syntactic checker", function () {
 
     it("should produce no warnings or errors for correct data", function () {
         expect(
-            importController.sifToGrnsight(unweightedTestSif).errors.length
+            importController.sifToGrnsight(unweightedGRNTestSif).errors.length
         ).to.equal(0);
     });
 
-    it("should throw an error for unweighted graphs with relationship types other than 'pd'", function () {
+    it("should throw an error for unweighted graphs with relationship types other than 'pd' and 'pp", function () {
         expect(
             importController.sifToGrnsight(unweightedTestSifWithIncorrectRelationshipType).errors.length
         ).to.equal(1);
@@ -470,7 +511,7 @@ describe("Import from SIF syntactic checker", function () {
     it("should accept trivially tabbed workbooks", function () {
         expect(
             importController.sifToGrnsight(triviallyTabbedUnweightedWorkbook)
-        ).to.deep.equal(expectedUnweightedWorkbook);
+        ).to.deep.equal(expectedUnweightedGRNWorkbook);
     });
 
 });

package/test/test.js

@@ -14,7 +14,7 @@ var exportController = require(__dirname + "/../server/controllers/export-contro
 // changed network parser to preserve all network sheets instead of choosing the best and throwing awway rhe rest
 // this helper method chooses the best network sheet, so prior implemented test behaviour doesn't crash
 var parseNetworkSheet = (sheet) => {
-    var allNetworks = parseAllNetworkSheet(sheet);
+    var allNetworks = parseAllNetworkSheet.networks(sheet);
     if (typeof allNetworks.networkOptimizedWeights === "object" &&
         Object.keys(allNetworks.networkOptimizedWeights).length !== 0) {
         return allNetworks.networkOptimizedWeights;

package/web-client/config/config.js

@@ -14,24 +14,24 @@ module.exports = {
     },
 
     production: {
-        host: "grnsight.cs.lmu.edu",
+        host: "grnsight.lmucs.org",
         port: 3001,
         url: "https://" + this.host + "/client",
         root: rootPath,
         app: {
             name: "GRNsight"
         },
-        serviceRoot: "//grnsight.cs.lmu.edu/server"
+        serviceRoot: "//grnsight.lmucs.org/server"
     },
 
     beta: {
-        host: "grnsight.cs.lmu.edu",
+        host: "grnsight.lmucs.org",
         port: 4001,
         url: "https://" + this.host + "/beta/client",
         root: rootPath,
         app: {
             name: "GRNsight"
         },
-        serviceRoot: "//grnsight.cs.lmu.edu/beta/server"
+        serviceRoot: "//grnsight.lmucs.org/beta/server"
     }
 };