post.js

const logger = require('@pubsweet/logger')

const {
  Team,
  User,
  services,
  Collection,
  Invitation,
  authsome: authsomeHelper,
} = require('pubsweet-component-helper-service')

const emailInvitations = require('./emails/invitations')

module.exports = models => async (req, res) => {
  const { email, role } = req.body

  if (!services.checkForUndefinedParams(email, role)) {
    res.status(400).json({ error: 'Email and role are required.' })
    logger.error('User ID and role are missing')
    return
  }

  if (role !== 'reviewer')
    return res
      .status(400)
      .json({ error: `Role ${role} is invalid. Only reviewer is accepted.` })

  const UserModel = models.User
  const reqUser = await UserModel.find(req.user)

  if (email === reqUser.email && !reqUser.admin)
    return res.status(400).json({ error: 'Cannot invite yourself.' })

  const { collectionId, fragmentId } = req.params
  let collection, fragment

  try {
    collection = await models.Collection.find(collectionId)
    if (!collection.fragments.includes(fragmentId))
      return res.status(400).json({
        error: `Fragment ${fragmentId} does not match collection ${collectionId}.`,
      })
    fragment = await models.Fragment.find(fragmentId)
  } catch (e) {
    const notFoundError = await services.handleNotFoundError(e, 'item')
    return res.status(notFoundError.status).json({
      error: notFoundError.message,
    })
  }
  const { path } = req.route
  const authsome = authsomeHelper.getAuthsome(models)
  const target = {
    collection,
    path,
  }
  const canPost = await authsome.can(req.user, 'POST', target)
  if (!canPost)
    return res.status(403).json({
      error: 'Unauthorized.',
    })

  const collectionHelper = new Collection({ collection })

  const baseUrl = services.getBaseUrl(req)

  const teamHelper = new Team({
    TeamModel: models.Team,
    collectionId,
    fragmentId,
  })
  const invitationHelper = new Invitation({ role })

  try {
    const user = await UserModel.findByEmail(email)

    const canInvite = await authsome.can(req.user, '', {
      targetUser: user,
    })
    if (!canInvite) {
      return res.status(400).json({ error: 'Invited user is inactive.' })
    }

    await teamHelper.setupTeam({ user, role, objectType: 'fragment' })
    invitationHelper.userId = user.id

    let invitation = invitationHelper.getInvitation({
      invitations: fragment.invitations,
    })
    let resend = false

    if (invitation) {
      if (invitation.hasAnswer) {
        return res
          .status(400)
          .json({ error: 'User has already replied to a previous invitation.' })
      }

      invitation.invitedOn = Date.now()
      await fragment.save()
      resend = true
    } else {
      invitation = await invitationHelper.createInvitation({
        parentObject: fragment,
      })
    }

    if (collection.status === 'heAssigned') {
      collectionHelper.updateStatus({ newStatus: 'reviewersInvited' })
    }

    emailInvitations.sendInvitations({
      resend,
      baseUrl,
      fragment,
      collection,
      invitation,
      invitedUser: user,
      UserModel: models.User,
      timestamp: invitation.invitedOn,
    })

    return res.status(200).json(invitation)
  } catch (e) {
    const userHelper = new User({ UserModel })

    const userData = req.body
    const { firstName, lastName, isPublons } = userData
    if (!services.checkForUndefinedParams(firstName, lastName)) {
      return res
        .status(400)
        .json({ error: 'First name and last name are required.' })
    }

    if (isPublons && process.env.PUBLONS_MOCK_EMAIL) {
      const mockEmail = process.env.PUBLONS_MOCK_EMAIL
      userData.email = mockEmail.replace('__NAME__', `${firstName}.${lastName}`)
    }

    const newUser = await userHelper.createUser({
      role,
      body: userData,
    })

    if (collection.status === 'heAssigned')
      await collectionHelper.updateStatus({ newStatus: 'reviewersInvited' })

    await teamHelper.setupTeam({ user: newUser, role, objectType: 'fragment' })

    invitationHelper.userId = newUser.id

    const invitation = await invitationHelper.createInvitation({
      parentObject: fragment,
    })

    emailInvitations.sendInvitations({
      baseUrl,
      fragment,
      collection,
      invitation,
      invitedUser: newUser,
      UserModel: models.User,
      timestamp: invitation.invitedOn,
    })

    return res.status(200).json(invitation)
  }
}