refactor(manuscript-manager): separate recommendations into strategies

packages/component-helper-service/src/services/Collection.js

-const { findLast, isEmpty, maxBy, get, flatMap } = require('lodash')
+const config = require('config')
+const { findLast, isEmpty, maxBy, get, flatMap, last } = require('lodash')
+
+const { features = {}, recommendations: configRecommendations } = config
 
 const Fragment = require('./Fragment')
 
@@ -169,6 +172,10 @@ class Collection {
       ),
     )
   }
+
+  isLatestVersion(fragmentId) {
+    return last(this.collection.fragments) === fragmentId
+  }
 }
 
 module.exports = Collection

packages/component-helper-service/src/services/Fragment.js

-const { get, remove, findLast, last } = require('lodash')
+const { get, remove, findLast } = require('lodash')
 const config = require('config')
 const User = require('./User')
 
@@ -150,16 +150,18 @@ class Fragment {
     )
   }
 
-  canHEMakeAnotherRecommendation(currentUserRecommendations) {
-    const lastHERecommendation = last(currentUserRecommendations)
+  canHEMakeAnotherRecommendation(lastHERecommendation) {
     const { fragment: { recommendations = [] } } = this
+
     const returnToHERecommendation = findLast(
       recommendations,
       r => r.recommendation === 'return-to-handling-editor',
     )
+
     if (!returnToHERecommendation) return false
     return returnToHERecommendation.createdOn > lastHERecommendation.createdOn
   }
+
   async getReviewersAndEditorsData({ collection, UserModel }) {
     const {
       invitations = [],

packages/component-manuscript-manager/src/routes/fragmentsRecommendations/post.js

 const uuid = require('uuid')
-const { pick, get, set, has, isEmpty, last, chain } = require('lodash')
+const {
+  pick,
+  get,
+  set,
+  has,
+  isEmpty,
+  last,
+  chain,
+  findLast,
+} = require('lodash')
 const config = require('config')
 const { v4 } = require('uuid')
 const logger = require('@pubsweet/logger')
@@ -14,10 +23,11 @@ const {
 const { features = {}, recommendations } = config
 
 const Notification = require('../../notifications/notification')
+const publishAsHE = require('./strategies/hePublish')
 
 module.exports = models => async (req, res) => {
   const { recommendation, comments, recommendationType } = req.body
-  if (!services.checkForUndefinedParams(recommendationType))
+  if (!services.checkForUndefinedParams(recommendationType, recommendation))
     return res.status(400).json({ error: 'Recommendation type is required.' })
 
   const reqUser = await models.User.find(req.user)
@@ -54,16 +64,6 @@ module.exports = models => async (req, res) => {
       error: notFoundError.message,
     })
   }
-  const currentUserRecommendations = get(
-    fragment,
-    'recommendations',
-    [],
-  ).filter(r => r.userId === req.user)
-
-  const lastFragmentRecommendation = chain(fragment)
-    .get('recommendations', [])
-    .last()
-    .value()
 
   const authsome = authsomeHelper.getAuthsome(models)
   const target = {
@@ -77,41 +77,47 @@ module.exports = models => async (req, res) => {
     })
 
   const fragmentHelper = new Fragment({ fragment })
-  if (
-    recommendationType === recommendations.type.editor &&
-    last(collection.fragments) !== fragmentId
-  ) {
-    return res
-      .status(400)
-      .json({ error: 'Cannot make a recommendation on an older version.' })
-  }
 
-  if (
-    recommendationType === recommendations.type.review &&
-    last(collection.fragments) !== fragmentId
-  ) {
-    return res
-      .status(400)
-      .json({ error: 'Cannot write a review on an older version.' })
+  if (!collectionHelper.isLatestVersion(fragmentId)) {
+    const error =
+      recommendationType === recommendations.type.editor
+        ? 'Cannot make a recommendation on an older version.'
+        : 'Cannot write a review on an older version.'
+    return res.status(400).json({ error })
   }
-  if (
-    last(collection.fragments) === fragmentId &&
-    !isEmpty(currentUserRecommendations)
-  ) {
+
+  // const currentUserRecommendations = get(
+  //   fragment,
+  //   'recommendations',
+  //   [],
+  // ).filter(r => r.userId === req.user)
+
+  const latestUserRecommendation = findLast(
+    fragment.recommendations,
+    r => r.userId === req.user,
+  )
+
+  if (latestUserRecommendation) {
     if (recommendationType === recommendations.type.review) {
       return res
         .status(400)
         .json({ error: 'Cannot write another review on this version.' })
     }
+
     if (
       recommendationType === recommendations.type.editor &&
       !isEditorInChief &&
-      !fragmentHelper.canHEMakeAnotherRecommendation(currentUserRecommendations)
+      !fragmentHelper.canHEMakeAnotherRecommendation(latestUserRecommendation)
     ) {
       return res.status(400).json({
         error: 'Cannot make another recommendation on this version.',
       })
     }
+
+    const lastFragmentRecommendation = chain(fragment)
+      .get('recommendations', [])
+      .last()
+      .value()
     if (
       recommendationType === recommendations.type.editor &&
       isEditorInChief &&
@@ -124,18 +130,34 @@ module.exports = models => async (req, res) => {
     }
   }
 
-  if (
-    recommendation === recommendations.publish &&
-    recommendationType === recommendations.type.editor &&
-    collection.handlingEditor &&
-    collection.handlingEditor.id === req.user
-  ) {
-    if (!collectionHelper.canHEMakeRecommendation(fragments, fragmentHelper)) {
-      return res.status(400).json({
-        error: 'Cannot publish without at least one reviewer report.',
-      })
-    }
+  const strategies = {
+    he: {
+      publish: publishAsHE,
+    },
   }
+  const role = 'he'
+  try {
+    strategies[role][recommendation].execute({
+      collectionHelper,
+      fragments,
+      fragmentHelper,
+    })
+  } catch (e) {
+    return res.status(400).json({ error: e.message })
+  }
+
+  // if (
+  //   recommendation === recommendations.publish &&
+  //   recommendationType === recommendations.type.editor &&
+  //   collection.handlingEditor &&
+  //   collection.handlingEditor.id === req.user
+  // ) {
+  //   if (!collectionHelper.canHEMakeRecommendation(fragments, fragmentHelper)) {
+  //     return res.status(400).json({
+  //       error: 'Cannot publish without at least one reviewer report.',
+  //     })
+  //   }
+  // }
 
   fragment.recommendations = fragment.recommendations || []
   const newRecommendation = {
@@ -146,8 +168,8 @@ module.exports = models => async (req, res) => {
     recommendationType,
   }
 
-  newRecommendation.recommendation = recommendation || undefined
-  newRecommendation.comments = comments || undefined
+  // newRecommendation.recommendation = recommendation || undefined
+  newRecommendation.comments = comments || []
 
   if (recommendationType === 'editorRecommendation') {
     await collectionHelper.updateStatusOnRecommendation({

packages/component-manuscript-manager/src/routes/fragmentsRecommendations/strategies/eicPublish.js

+module.exports = {
+  execute: ({ fragment, collection, recommendation }) => {},
+}

packages/component-manuscript-manager/src/routes/fragmentsRecommendations/strategies/hePublish.js

+module.exports = {
+  execute: ({ collectionHelper, fragments, fragmentHelper }) => {
+    if (!collectionHelper.canHEMakeRecommendation(fragments, fragmentHelper)) {
+      throw new Error('Cannot publish without at least one reviewer report.')
+    }
+  },
+}