- Update legend model and file structure to be standalone table not belonging to a report

- Legend records include default value that is enforced by unique index and util functions to ensure only 1 record can have True value
- Update uploadLegendImage middleware function
- Update legend router and routes
- Update legend unit tests
- Update model associations

Author: bnguyen-bcgsc

app/models/index.js

@@ -134,14 +134,7 @@ summary.therapeuticTargets = require('./reports/genomic/summary/therapeuticTarge
 summary.microbial = require('./reports/genomic/summary/microbial')(sequelize, Sq);
 
 // Pathway Analysis Legends
-const pathwayAnalysisLegends = require('./reports/legend')(sequelize, Sq);
-
-pathwayAnalysisLegends.belongsTo(analysisReports, {
-  as: 'report', foreignKey: 'reportId', targetKey: 'id', onDelete: 'CASCADE', constraints: true,
-});
-analysisReports.hasMany(pathwayAnalysisLegends, {
-  as: 'legends', foreignKey: 'reportId', onDelete: 'CASCADE', constraints: true,
-});
+const pathwayAnalysisLegends = require('./legend/legend')(sequelize, Sq);
 
 summary.pathwayAnalysis.belongsTo(pathwayAnalysisLegends, {
   as: 'legend', foreignKey: 'legendId', targetKey: 'id', onDelete: 'SET NULL', constraints: true,

app/models/legend/legend.js

@@ -0,0 +1,107 @@
+const { DEFAULT_COLUMNS } = require('../base');
+
+module.exports = (sequelize, Sq) => {
+  const legend = sequelize.define(
+    'legend',
+    {
+      ...DEFAULT_COLUMNS,
+      format: {
+        type: Sq.ENUM('PNG', 'JPG'),
+        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,
+      },
+    },
+    {
+      tableName: 'pathway_analysis_legends',
+      indexes: [
+        {
+          unique: true,
+          fields: [],
+          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: {id: {[sequelize.Sequelize.Op.ne]: instance.id}},
+                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: {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.prototype.ensureDefaultExists = async function () {
+    const hasDefault = await sequelize.models.legend.findOne({
+      where: {default: true},
+    });
+
+    if (!hasDefault) {
+      const mostRecent = await sequelize.models.legend.findOne({
+        order: [['createdAt', 'DESC']],
+      });
+
+      if (mostRecent) {
+        await mostRecent.update({default: true});
+      }
+    }
+  };
+
+  return legend;
+};

app/models/reports/legend.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/index.js

@@ -0,0 +1,104 @@
+const HTTP_STATUS = require('http-status-codes');
+const express = require('express');
+
+const db = require('../../models');
+const logger = require('../../log');
+const {uploadLegendImage} = 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}`);
+    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) => {
+    try {
+      await req.legend.update(req.body, {userId: req.user.id});
+      await req.legend.ensureDefaultExists();
+      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) => {
+    // Whether to hard or soft delete legend
+    const force = (req.query.force === 'true');
+
+    // Delete legend image
+    try {
+      await req.legend.destroy({force});
+      await req.legend.ensureDefaultExists();
+      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 adding a legend image
+router.route('/')
+  .get(async (req, res) => {
+    try {
+      const legends = await db.models.legend.findAll();
+      return res.json(legends.map((legend) => legend.view('public')));
+    } catch (error) {
+      logger.error(`Error while retrieving legend images ${error}`);
+      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 = await Promise.all(Object.entries(req.files).map(async ([key, image]) => {
+        try {
+          // Set options (value or undefined)
+          const options = {
+            filename: image.name.trim(),
+            name: req.body.name || image.name.trim(),
+            default: req.body.default === undefined ? false : req.body.default,
+          };
+
+          // Load image
+          const createdLegend = await uploadLegendImage(image.data, options);
+          await createdLegend.ensureDefaultExists();
+          // Return that this image was uploaded successfully
+          return {name: key, upload: 'successful'};
+        } catch (error) {
+          return {name: key, upload: 'failed', error};
+        }
+      }));
+      return res.status(HTTP_STATUS.MULTI_STATUS).json(results);
+    } catch (error) {
+      logger.error(`Error while uploading images ${error}`);
+      return res.status(HTTP_STATUS.BAD_REQUEST).json({error: {message: `Error while uploading images ${error}`}});
+    }
+  });
+
+module.exports = router;

app/routes/legend/index.js

@@ -56,33 +56,27 @@ const uploadReportImage = async (reportId, key, image, options = {}) => {
  * @param {object} options - An object containing additional image upload options
  *
  * @property {string} options.filename - An optional filename for the image
- * @property {string} options.caption - An optional caption for the image
- * @property {string} options.title - An optional title for the image
- * @property {string} options.category - An optional category for the image
+ * @property {string} options.name - An optional name for the legend
+ * @property {boolean|string} options.default - Whether this legend is the default
  * @property {object} options.transaction - An optional transaction to run the create under
  *
  * @returns {Promise<object>} - Returns the created legend db entry
  * @throws {Promise<Error>} - Something goes wrong with image processing and saving entry
  */
-const uploadLegendImage = async (reportId, version, image, options = {}) => {
-  logger.verbose(`Loading legend (${version}) image`);
+const uploadLegendImage = async (image, options = {}) => {
+  logger.verbose('Loading legend image');
 
   const config = {format: DEFAULT_FORMAT, size: IMAGE_SIZE_LIMIT};
 
   try {
     const imageData = await processImage(image, config.size, config.format);
 
     return db.models.legend.create({
-      reportId,
       format: config.format,
       filename: options.filename,
-      version,
+      name: options.name || options.filename,
       data: imageData,
-      caption: options.caption,
-      title: options.title,
-      width: config.width,
-      height: config.height,
-      category: options.category,
+      default: options.default === true || options.default === 'true',
     }, {transaction: options.transaction});
   } catch (error) {
     logger.error(`Error processing legend image ${options.filename} ${error}`);