notification.js

const config = require('config')
const { get, isEmpty, chain } = require('lodash')
const Email = require('@pubsweet/component-email-templating')
const {
  User,
  services,
  Fragment,
  Collection,
} = require('pubsweet-component-helper-service')

const helpers = require('./helpers')
const { getEmailCopy } = require('./emailCopy')

const { name: journalName, staffEmail } = config.get('journal')
const unsubscribeSlug = config.get('unsubscribe.url')

class Notification {
  constructor({
    baseUrl = '',
    fragment = {},
    UserModel = {},
    collection = {},
    newRecommendation = {},
  }) {
    this.baseUrl = baseUrl
    this.fragment = fragment
    this.UserModel = UserModel
    this.collection = collection
    this.newRecommendation = newRecommendation
  }

  async notifyHEWhenReviewerSubmitsReport(reviewerLastName) {
    const { eicName, titleText } = await this.getNotificationProperties()

    const handlingEditorId = get(this.collection, 'handlingEditor.id')
    const heUser = await this.UserModel.find(handlingEditorId)

    const email = new Email({
      type: 'user',
      toUser: {
        email: heUser.email,
        name: heUser.lastName,
      },
      fromEmail: `${eicName} <${staffEmail}>`,
      content: {
        signatureName: eicName,
        ctaText: 'MANUSCRIPT DETAILS',
        subject: `${this.collection.customId}: A review has been submitted`,
        unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
          id: heUser.id,
          token: heUser.accessTokens.unsubscribe,
        }),
        ctaLink: services.createUrl(
          this.baseUrl,
          `/projects/${this.collection.id}/versions/${
            this.fragment.id
          }/details`,
        ),
      },
    })

    helpers.sendHandlingEditorEmail({
      email,
      titleText,
      targetUserName: reviewerLastName,
      emailType: 'he-review-submitted',
    })
  }

  // EiC decided to either publish or reject the manuscript
  async notifyHEWhenEiCMakesDecision() {
    const {
      eicName,
      titleText,
      recommendation,
    } = await this.getNotificationProperties()

    const handlingEditorId = get(this.collection, 'handlingEditor.id')
    const heUser = await this.UserModel.find(handlingEditorId)

    const email = new Email({
      type: 'user',
      toUser: {
        email: heUser.email,
      },
      fromEmail: `${journalName} <${staffEmail}>`,
      content: {
        ctaText: 'MANUSCRIPT DETAILS',
        subject: `${this.collection.customId}: Editorial decision confirmed`,
        unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
          id: heUser.id,
          token: heUser.accessTokens.unsubscribe,
        }),
        ctaLink: services.createUrl(
          this.baseUrl,
          `/projects/${this.collection.id}/versions/${
            this.fragment.id
          }/details`,
        ),
      },
    })
    delete email.content.signatureJournal

    helpers.sendHandlingEditorEmail({
      email,
      titleText,
      targetUserName: eicName,
      emailType:
        recommendation === 'publish'
          ? 'he-manuscript-published'
          : 'he-manuscript-rejected',
    })
  }

  async notifyHEWhenEiCReturnsToHE() {
    const { eicName, titleText } = await this.getNotificationProperties()

    const handlingEditorId = get(this.collection, 'handlingEditor.id')
    const heUser = await this.UserModel.find(handlingEditorId)

    const email = new Email({
      type: 'user',
      toUser: {
        email: heUser.email,
        name: heUser.lastName,
      },
      fromEmail: `${eicName} <${staffEmail}>`,
      content: {
        subject: `${
          this.collection.customId
        }: Editorial decision returned with comments`,
        signatureName: eicName,
        ctaText: 'MANUSCRIPT DETAILS',
        unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
          id: heUser.id,
          token: heUser.accessTokens.unsubscribe,
        }),
        ctaLink: services.createUrl(
          this.baseUrl,
          `/projects/${this.collection.id}/versions/${
            this.fragment.id
          }/details`,
        ),
      },
    })
    delete email.content.signatureJournal

    const eicComments = chain(this.newRecommendation)
      .get('comments')
      .find(comm => !comm.public)
      .get('content')
      .value()

    helpers.sendHandlingEditorEmail({
      email,
      titleText,
      comments: eicComments,
      targetUserName: eicName,
      emailType: 'he-manuscript-return-with-comments',
    })
  }

  async notifyEAWhenEiCMakesFinalDecision() {
    const { eicName, titleText } = await this.getNotificationProperties()
    const subjectBaseText = `${this.collection.customId}: Manuscript`

    const email = new Email({
      type: 'system',
      toUser: {
        email: staffEmail,
      },
      fromEmail: `${journalName} <${staffEmail}>`,
      content: {
        subject: `${subjectBaseText} decision finalized`,
        unsubscribeLink: this.baseUrl,
      },
    })

    const { html, text } = email.getNotificationBody({
      emailBodyProps: getEmailCopy({
        eicName,
        titleText,
        emailType: 'eqa-manuscript-published',
      }),
    })
    email.sendEmail({ html, text })
  }

  async notifyEAWhenEiCRequestsEQAApproval() {
    const { eicName } = await this.getNotificationProperties()
    const subjectBaseText = `${this.collection.customId}: Manuscript`

    const email = new Email({
      type: 'system',
      toUser: {
        email: staffEmail,
      },
      fromEmail: `${journalName} <${staffEmail}>`,
      content: {
        subject: `${subjectBaseText} Request for EQA approval`,
        unsubscribeLink: this.baseUrl,
        ctaText: 'MAKE DECISION',
        ctaLink: services.createUrl(
          this.baseUrl,
          config.get('eqa-decision.url'),
          {
            collectionId: this.collection.id,
            customId: this.collection.customId,
            token: this.collection.technicalChecks.token,
          },
        ),
      },
    })

    const { html, text } = email.getNotificationBody({
      emailBodyProps: getEmailCopy({
        eicName,
        customId: this.collection.customId,
        emailType: 'eqa-manuscript-request-for-approval',
      }),
    })
    email.sendEmail({ html, text })
  }

  async notifyAuthorsWhenEiCMakesDecision() {
    const {
      eicName,
      titleText,
      activeAuthors,
      recommendation,
      parsedFragment,
    } = await this.getNotificationProperties()

    const subjectOpts = {
      publish: `${this.collection.customId}: Manuscript accepted`,
      reject: `${this.collection.customId}: Manuscript rejected`,
    }
    const subject = subjectOpts[recommendation]

    if (isEmpty(subject)) {
      throw new Error(`Undefined recommendation: ${recommendation}`)
    }

    const hasPeerReview = !isEmpty(this.collection.handlingEditor)
    const emailType = helpers.getEmailTypeByRecommendationForAuthors({
      recommendation,
      hasPeerReview,
    })
    const comments = hasPeerReview
      ? helpers.getHEComments({
          heRecommendation: parsedFragment.heRecommendation,
        })
      : this.newRecommendation.comments[0].content

    activeAuthors.forEach(async author => {
      const email = new Email({
        type: 'user',
        toUser: {
          email: author.email,
          name: author.lastName,
        },
        fromEmail: `${eicName} <${staffEmail}>`,
        content: {
          signatureName: eicName,
          ctaText: 'MANUSCRIPT DETAILS',
          subject,
          unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
            id: author.id,
            token: author.accessTokens.unsubscribe,
          }),
          ctaLink: services.createUrl(
            this.baseUrl,
            `/projects/${this.collection.id}/versions/${
              this.fragment.id
            }/details`,
          ),
          signatureJournal: journalName,
        },
      })

      const { html, text } = email.getNotificationBody({
        emailBodyProps: getEmailCopy({
          titleText,
          emailType,
          comments,
        }),
      })

      email.sendEmail({ html, text })
    })
  }

  async notifyReviewersWhenEiCMakesDecision() {
    const {
      eicName,
      titleText,
      recommendation,
      fragmentHelper,
    } = await this.getNotificationProperties()

    const emailType =
      recommendation === 'publish'
        ? 'submitted-reviewers-after-publish'
        : 'submitted-reviewers-after-reject'

    const subject =
      recommendation === 'publish'
        ? 'A manuscript you reviewed has been accepted'
        : 'A manuscript you reviewed has been rejected'

    const reviewers = await fragmentHelper.getReviewers({
      UserModel: this.UserModel,
      type: 'submitted',
    })

    const emailBodyProps = getEmailCopy({
      emailType,
      titleText,
    })

    reviewers.forEach(reviewer => {
      const email = new Email({
        type: 'user',
        toUser: {
          email: reviewer.email,
          name: reviewer.lastName,
        },
        fromEmail: `${eicName} <${staffEmail}>`,
        content: {
          signatureName: eicName,
          ctaText: 'MANUSCRIPT DETAILS',
          subject: `${this.collection.customId}: ${subject}`,
          unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
            id: reviewer.id,
            token: reviewer.accessTokens.unsubscribe,
          }),
          ctaLink: services.createUrl(
            this.baseUrl,
            `/projects/${this.collection.id}/versions/${
              this.fragment.id
            }/details`,
          ),
          signatureJournal: journalName,
        },
      })

      const { html, text } = email.getNotificationBody({ emailBodyProps })
      email.sendEmail({ html, text })
    })
  }

  async notifySAWhenHERequestsRevision() {
    const {
      eicName,
      submittingAuthor,
      parsedFragment: { title },
    } = await this.getNotificationProperties()

    const authorNoteText = helpers.getPrivateNoteTextForAuthor({
      newRecommendation: this.newRecommendation,
    })
    const author = {
      ...submittingAuthor,
      ...getEmailCopy({
        emailType: 'author-request-to-revision',
        titleText: `your submission "${title}" to ${journalName}`,
        comments: authorNoteText,
      }),
    }

    const signatureName = get(this.collection, 'handlingEditor.name', eicName)

    const email = new Email({
      type: 'user',
      toUser: {
        email: author.email,
        name: author.lastName,
      },
      fromEmail: `${signatureName} <${staffEmail}>`,
      content: {
        signatureName,
        ctaText: 'MANUSCRIPT DETAILS',
        signatureJournal: journalName,
        subject: `${this.collection.customId}: Revision requested`,
        unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
          id: author.id,
          token: author.accessTokens.unsubscribe,
        }),
        ctaLink: services.createUrl(
          this.baseUrl,
          `/projects/${this.collection.id}/versions/${
            this.fragment.id
          }/details`,
        ),
      },
    })

    const { html, text } = email.getNotificationBody({
      emailBodyProps: {
        paragraph: author.paragraph,
        hasLink: author.hasLink,
        hasIntro: author.hasIntro,
        hasSignature: author.hasSignature,
      },
    })
    email.sendEmail({ html, text })
  }

  async notifyReviewersWhenHEMakesRecommendation() {
    const {
      eicName,
      titleText,
      fragmentHelper,
    } = await this.getNotificationProperties()

    const signatureName = get(this.collection, 'handlingEditor.name', eicName)

    const acceptedReviewers = await fragmentHelper.getReviewers({
      UserModel: this.UserModel,
      type: 'accepted',
    })
    const acceptedReviewersEmailBody = getEmailCopy({
      emailType: 'accepted-reviewers-after-recommendation',
      titleText,
    })

    const pendingReviewers = await fragmentHelper.getReviewers({
      UserModel: this.UserModel,
      type: 'pending',
    })
    const pendingReviewersEmailBody = getEmailCopy({
      emailType: 'pending-reviewers-after-recommendation',
      titleText,
    })

    const buildSendEmailFunction = emailBodyProps => reviewer => {
      const email = new Email({
        type: 'user',
        toUser: {
          email: reviewer.email,
          name: reviewer.lastName,
        },
        fromEmail: `${signatureName} <${staffEmail}>`,
        content: {
          signatureName,
          ctaText: 'MANUSCRIPT DETAILS',
          subject: `${this.collection.customId}: Review no longer required`,
          unsubscribeLink: services.createUrl(this.baseUrl, unsubscribeSlug, {
            id: reviewer.id,
            token: reviewer.accessTokens.unsubscribe,
          }),
          ctaLink: services.createUrl(
            this.baseUrl,
            `/projects/${this.collection.id}/versions/${
              this.fragment.id
            }/details`,
          ),
          signatureJournal: journalName,
        },
      })

      const { html, text } = email.getNotificationBody({ emailBodyProps })
      email.sendEmail({ html, text })
    }

    acceptedReviewers.forEach(
      buildSendEmailFunction(acceptedReviewersEmailBody),
    )
    pendingReviewers.forEach(buildSendEmailFunction(pendingReviewersEmailBody))
  }

  async notifyEiCWhenHEMakesRecommendation() {
    const {
      eicName,
      titleText,
      recommendation,
    } = await this.getNotificationProperties()

    let emailType, subject
    switch (recommendation) {
      case 'minor':
      case 'major':
        emailType = 'eic-request-revision-from-he'
        subject = `${this.collection.customId}: Revision requested`
        break
      case 'publish':
        emailType = 'eic-recommend-to-publish-from-he'
        subject = `${this.collection.customId}: Recommendation to publish`
        break
      case 'reject':
        emailType = 'eic-recommend-to-reject-from-he'
        subject = `${this.collection.customId}: Recommendation to reject`
        break
      default:
        throw new Error(`undefined recommendation: ${recommendation} `)
    }

    const privateNote = this.newRecommendation.comments.find(
      comm => !comm.public,
    )
    const content = get(privateNote, 'content')
    const comments = content
      ? `The editor provided the following comments: "${content}"`
      : ''

    const collHelper = new Collection({ collection: this.collection })
    const targetUserName = collHelper.getHELastName()

    const userHelper = new User({ UserModel: this.UserModel })
    const editors = await userHelper.getEditorsInChief()

    const emailBodyProps = getEmailCopy({
      comments,
      emailType,
      titleText,
      targetUserName,
    })

    editors.forEach(eic => {
      const email = new Email({
        type: 'user',
        toUser: {
          email: eic.email,
          name: `${eic.firstName} ${eic.lastName}`,
        },
        fromEmail: `${journalName} <${staffEmail}>`,
        content: {
          signatureName: eicName,
          subject,
          ctaText: 'MANUSCRIPT DETAILS',
          unsubscribeLink: this.baseUrl,
          ctaLink: services.createUrl(
            this.baseUrl,
            `/projects/${this.collection.id}/versions/${
              this.fragment.id
            }/details`,
          ),
        },
      })

      const { html, text } = email.getNotificationBody({ emailBodyProps })
      email.sendEmail({ html, text })
    })
  }

  async getNotificationProperties() {
    const fragmentHelper = new Fragment({ fragment: this.fragment })
    const parsedFragment = await fragmentHelper.getFragmentData({
      handlingEditor: this.collection.handlingEditor,
    })
    const {
      submittingAuthor,
      activeAuthors,
    } = await fragmentHelper.getAuthorData({
      UserModel: this.UserModel,
    })

    const userHelper = new User({ UserModel: this.UserModel })
    const eicName = await userHelper.getEiCName()

    const titleText = `the manuscript titled "${parsedFragment.title}" by ${
      submittingAuthor.firstName
    } ${submittingAuthor.lastName}`

    const { recommendation, recommendationType } = this.newRecommendation

    return {
      recommendation,
      recommendationType,
      eicName,
      titleText,
      submittingAuthor,
      activeAuthors,
      parsedFragment,
      fragmentHelper,
    }
  }
}

module.exports = Notification