Release/v8.6.0

app/middleware/acl.js

@@ -117,13 +117,16 @@ module.exports = async (req, res, next) => {
   try {
     // Update last time the user logged in, limit to once a day
     const currentDate = new Date().toDateString();
-    let userMetadata = await db.models.userMetadata.findOrCreate({where: {userId: req.user.id}});
+    let userMetadata = await db.models.userMetadata.findOrCreate({
+      where: {userId: req.user.id},
+      defaults: {updatedBy: req.user.id},
+    });
     userMetadata = userMetadata[0];
     const userLastLogin = userMetadata.lastLoginAt
       ? new Date(userMetadata.lastLoginAt).toDateString()
       : '';
     if (userLastLogin !== currentDate) {
-      await userMetadata.update({lastLoginAt: new Date()});
+      await userMetadata.update({lastLoginAt: new Date()}, {userId: req.user.id});
     }
 
     try {

app/models/index.js

@@ -133,6 +133,20 @@ summary.probeResults = require('./reports/probeResults')(sequelize, Sq);
 summary.therapeuticTargets = require('./reports/genomic/summary/therapeuticTargets')(sequelize, Sq);
 summary.microbial = require('./reports/genomic/summary/microbial')(sequelize, Sq);
 
+// Pathway Analysis Legends
+// DEVSU-2310 batch 2: restore `const pathwayAnalysisLegends =` when re-enabling the associations below
+require('./legend/legend')(sequelize, Sq);
+
+// DEVSU-2310 batch 2: re-enable with the update-pathway-analysis-legend-fk migration.
+// These associations define the legendId attribute on pathwayAnalysis, so they must
+// stay commented out alongside the model attribute until legend_id exists.
+// summary.pathwayAnalysis.belongsTo(pathwayAnalysisLegends, {
+//   as: 'legend', foreignKey: 'legendId', targetKey: 'id', onDelete: 'SET NULL', constraints: true,
+// });
+// pathwayAnalysisLegends.hasMany(summary.pathwayAnalysis, {
+//   as: 'pathwayAnalyses', foreignKey: 'legendId', onDelete: 'SET NULL', constraints: true,
+// });
+
 analysisReports.belongsTo(user, {
   as: 'createdBy', foreignKey: 'createdBy_id', targetKey: 'id', onDelete: 'SET NULL', controlled: true,
 });

app/models/legend/legend.js

@@ -0,0 +1,123 @@
+const {DEFAULT_COLUMNS} = require('../base');
+
+module.exports = (sequelize, Sq) => {
+  const legend = sequelize.define(
+    'legend',
+    {
+      ...DEFAULT_COLUMNS,
+      format: {
+        type: Sq.ENUM('PNG', 'JPG', 'SVG'),
+        defaultValue: 'PNG',
+      },
+      filename: {
+        type: Sq.TEXT,
+        allowNull: false,
+      },
+      name: {
+        type: Sq.TEXT,
+        allowNull: false,
+      },
+      data: {
+        type: Sq.TEXT,
+        allowNull: false,
+      },
+      default: {
+        type: Sq.BOOLEAN,
+        defaultValue: false,
+        set(value) {
+          this.setDataValue('default', value === true || value === 'true');
+        },
+      },
+    },
+    {
+      tableName: 'pathway_analysis_legends',
+      indexes: [
+        {
+          unique: true,
+          fields: ['default'],
+          where: {
+            default: true,
+            deleted_at: null,
+          },
+          name: 'idx_one_default_legend',
+        },
+      ],
+      scopes: {
+        public: {
+          attributes: {
+            exclude: ['id', 'deletedAt', 'updatedBy'],
+          },
+        },
+      },
+      hooks: {
+        beforeCreate: async (instance, options) => {
+          // If setting to true, unset all others
+          if (instance.default === true) {
+            await sequelize.models.legend.update(
+              {default: false},
+              {
+                where: {
+                  default: true,
+                },
+                transaction: options.transaction,
+              },
+            );
+          }
+        },
+        beforeUpdate: async (instance, options) => {
+          // If setting to true, unset all others
+          if (instance.changed('default') && instance.default === true) {
+            await sequelize.models.legend.update(
+              {default: false},
+              {
+                where: {
+                  default: true,
+                  id: {[sequelize.Sequelize.Op.ne]: instance.id},
+                },
+                transaction: options.transaction,
+              },
+            );
+          }
+        },
+      },
+    },
+  );
+
+  // set instance methods
+  legend.prototype.view = function (scope) {
+    if (scope === 'public') {
+      const {
+        id, deletedAt, updatedBy, ...publicView
+      } = this.dataValues;
+      return publicView;
+    }
+    return this;
+  };
+
+  // Ensure at least one default exists
+  legend.ensureDefaultExists = async function (options = {}) {
+    const {transaction} = options;
+    const hasDefault = await sequelize.models.legend.findOne({
+      where: {default: true},
+      transaction,
+      lock: transaction ? transaction.LOCK.UPDATE : undefined,
+    });
+
+    if (!hasDefault) {
+      const mostRecent = await sequelize.models.legend.findOne({
+        order: [['createdAt', 'DESC']],
+        transaction,
+        lock: transaction ? transaction.LOCK.UPDATE : undefined,
+      });
+      if (mostRecent) {
+        await mostRecent.update({default: true}, {transaction});
+      }
+    }
+  };
+
+  legend.prototype.ensureDefaultExists = async function (options = {}) {
+    return legend.ensureDefaultExists(options);
+  };
+
+  return legend;
+};

app/models/reports/genomic/summary/pathwayAnalysis.js

@@ -12,6 +12,16 @@ module.exports = (sequelize, Sq) => {
         key: 'id',
       },
     },
+    // DEVSU-2310 batch 2: re-enable with the update-pathway-analysis-legend-fk migration
+    // legendId: {
+    //   name: 'legendId',
+    //   field: 'legend_id',
+    //   type: Sq.INTEGER,
+    //   references: {
+    //     model: 'pathway_analysis_legends',
+    //     key: 'id',
+    //   },
+    // },
     pathway: {
       type: Sq.TEXT,
       allowNull: true,
@@ -20,11 +30,6 @@ module.exports = (sequelize, Sq) => {
         schema: {format: 'svg', type: 'string'},
       },
     },
-    legend: {
-      type: Sq.ENUM(['v1', 'v2', 'v3', 'custom']),
-      allowNull: false,
-      defaultValue: 'v3',
-    },
   }, {
     ...DEFAULT_REPORT_OPTIONS,
     tableName: 'reports_summary_pathway_analysis',

app/models/reports/report.js

@@ -76,20 +76,6 @@ module.exports = (sequelize, Sq) => {
       },
       allowNull: false,
     },
-    seqQc: {
-      name: 'seqQc',
-      field: 'seq_qc',
-      type: Sq.JSONB,
-      jsonSchema: {
-        schema: {
-          type: 'array',
-          items: {
-            type: 'object',
-          },
-          example: [{Reads: '2534M', bioQC: 'passed'}],
-        },
-      },
-    },
     config: {
       type: Sq.TEXT,
     },

app/models/reports/smallMutations.js

@@ -134,6 +134,9 @@ module.exports = (sequelize, Sq) => {
       field: 'tumour_ref_copies',
       type: Sq.INTEGER,
     },
+    exon: {
+      type: Sq.TEXT,
+    },
     library: {
       type: Sq.TEXT,
     },

app/routes/index.js

@@ -19,6 +19,7 @@ const notificationRoute = require('./notification');
 const variantTextRoute = require('./variantText');
 const templateRoute = require('./template');
 const appendixRoute = require('./appendix');
+const legendRoute = require('./legend');
 
 // Get module route files
 const RouterInterface = require('./routingInterface');
@@ -101,6 +102,9 @@ class Routing extends RouterInterface {
     // Get appendix routes
     this.router.use('/appendix', appendixRoute);
 
+    // Global legend routes
+    this.router.use('/legend', legendRoute);
+
     return true;
   }
 }

app/routes/legend/index.js

@@ -0,0 +1,145 @@
+const HTTP_STATUS = require('http-status-codes');
+const express = require('express');
+
+const db = require('../../models');
+const logger = require('../../log');
+const {uploadLegendImage, updateLegendImage} = require('../report/images');
+
+const router = express.Router({mergeParams: true});
+
+// Middleware for legend lookup
+router.param('legend', async (req, res, next, legendIdent) => {
+  let result;
+  try {
+    result = await db.models.legend.findOne({
+      where: {ident: legendIdent},
+    });
+  } catch (error) {
+    logger.error(`Unable to lookup legend error: ${error.message}`);
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({error: {message: 'Unable to lookup legend'}});
+  }
+
+  if (!result) {
+    logger.error(`Unable to find legend ${legendIdent}`);
+    return res.status(HTTP_STATUS.NOT_FOUND).json({error: {message: 'Unable to find the requested legend'}});
+  }
+
+  req.legend = result;
+  return next();
+});
+
+router.route('/:legend([A-z0-9-]{36})')
+  .get((req, res) => {
+    return res.json(req.legend.view('public'));
+  })
+  .put(async (req, res) => {
+    // Use the first uploaded file, if any, to replace the stored image
+    const [image] = req.files ? Object.values(req.files) : [];
+
+    try {
+      await db.transaction(async (transaction) => {
+        if (image) {
+          await updateLegendImage(req.legend, image, {updates: req.body, userId: req.user.id, transaction});
+        } else {
+          await req.legend.update(req.body, {userId: req.user.id, transaction});
+        }
+        await db.models.legend.ensureDefaultExists({transaction});
+      });
+      await req.legend.reload();
+      return res.json(req.legend.view('public'));
+    } catch (error) {
+      logger.error(`Error while updating legend image ${error}`);
+      return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR)
+        .json({error: {message: 'Error while updating legend image'}});
+    }
+  })
+  .delete(async (req, res) => {
+    const force = (req.query.force === 'true');
+    const wasDefault = req.legend.default;
+
+    try {
+      await db.transaction(async (transaction) => {
+        await req.legend.destroy({force, transaction});
+
+        // Only re-evaluate the default if we just removed the default one.
+        if (wasDefault) {
+          await db.models.legend.ensureDefaultExists({transaction});
+        }
+      });
+      return res.status(HTTP_STATUS.NO_CONTENT).send();
+    } catch (error) {
+      logger.error(`Error while deleting legend image ${error}`);
+      return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR)
+        .json({error: {message: 'Error while deleting legend image'}});
+    }
+  });
+
+// Route for querying legend by numeric id
+router.route('/:legendId(\\d+)')
+  .get(async (req, res) => {
+    try {
+      const legend = await db.models.legend.findByPk(req.params.legendId);
+      if (!legend) {
+        logger.error(`Unable to find legend with id ${req.params.legendId}`);
+        const msg = 'Unable to find the requested legend';
+        return res.status(HTTP_STATUS.NOT_FOUND)
+          .json({error: {message: msg}});
+      }
+      return res.json(legend.view('public'));
+    } catch (error) {
+      logger.error(`Unable to lookup legend by id error: ${error.message}`);
+      const msg = 'Unable to lookup legend';
+      return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR)
+        .json({error: {message: msg}});
+    }
+  });
+
+// Route for adding a legend image
+router.route('/')
+  .get(async (req, res) => {
+    try {
+      const legends = await db.models.legend.findAll();
+      return res.json(legends.map((legend) => {return legend.view('public');}));
+    } catch (error) {
+      logger.error(`Error while retrieving legend images ${error.message}`);
+      return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({error: {message: 'Error while retrieving legend images'}});
+    }
+  })
+  .post(async (req, res) => {
+    // Check that image files were uploaded
+    if (!req.files || Object.keys(req.files).length === 0) {
+      logger.error('No attached images to upload');
+      return res.status(HTTP_STATUS.BAD_REQUEST).json({error: {message: 'No attached images to upload'}});
+    }
+
+    try {
+      const results = [];
+      for (const [key, image] of Object.entries(req.files)) {
+        try {
+          // Set options (value or undefined)
+          const options = {
+            filename: image.name.trim(),
+            name: req.body.name || image.name.trim(),
+            default: req.body.default,
+          };
+
+          // Load image
+          await db.transaction(async (transaction) => {
+            await uploadLegendImage(image.data, {...options, transaction});
+            await db.models.legend.ensureDefaultExists({transaction});
+          });
+
+          // Return that this image was uploaded successfully
+          results.push({name: key, upload: 'successful'});
+        } catch (error) {
+          results.push({name: key, upload: 'failed', error: {message: error.message}});
+        }
+      }
+      return res.status(HTTP_STATUS.MULTI_STATUS).json(results);
+    } catch (error) {
+      logger.error(`Error while uploading images ${error.message}`);
+      return res.status(HTTP_STATUS.BAD_REQUEST).json({error: {message: `Error while uploading images ${error.message}`}});
+    }
+  });
+
+module.exports = router;

app/routes/report/appendices.js

@@ -13,7 +13,7 @@ router.route('/')
     try {
       const result = await db.models.report.findOne({
         where: {ident: req.report.ident},
-        attributes: ['seqQc', 'config'],
+        attributes: ['config'],
         include: ['seqQC'],
       });
       return res.json(result);