review-object.controller.js

const validateUUID = require('uuid').validate
const mongoose = require('mongoose')
const { getConstants } = require('../../constants')
const errors = require('./error')
const error = new errors.ReviewObjectControllerError()
const _ = require('lodash')

/**
 * Retrieves the PENDING review object for an organization by identifier (short_name or UUID).
 * Returns only review objects with status='pending'.
 */
async function getReviewObjectByOrgIdentifier (req, res, next) {
  const repo = req.ctx.repositories.getReviewObjectRepository()
  const orgRepo = req.ctx.repositories.getBaseOrgRepository()
  const isSecretariat = await orgRepo.isSecretariatByShortName(req.ctx.org)
  const identifier = req.params.identifier
  const identifierIsUUID = validateUUID(identifier)
  if (!identifier) {
    return res.status(400).json({ message: 'Missing identifier parameter' })
  }
  let value
  // We may want this to be something different, but for now we are just testing
  if (identifierIsUUID) {
    value = await repo.getOrgReviewObjectByOrgUUID(identifier, isSecretariat, {})
  } else {
    value = await repo.getOrgReviewObjectByOrgShortname(identifier, isSecretariat, {})
  }
  if (!value) {
    return res.status(404).json({ message: 'No pending review object exists for this organization' })
  }
  return res.status(200).json(value)
}

async function getReviewObjectByUUID (req, res, next) {
  const repo = req.ctx.repositories.getReviewObjectRepository()
  const orgRepo = req.ctx.repositories.getBaseOrgRepository()
  const isSecretariat = await orgRepo.isSecretariatByShortName(req.ctx.org)
  const UUID = req.params.uuid
  const value = await repo.findOneByUUIDWithConversation(UUID, isSecretariat)
  return res.status(200).json(value)
}

async function getAllReviewObjects (req, res, next) {
  const repo = req.ctx.repositories.getReviewObjectRepository()
  const CONSTANTS = getConstants()
  const status = req.query?.status || null

  if (req.TEST_PAGINATOR_LIMIT) {
    CONSTANTS.PAGINATOR_OPTIONS.limit = req.TEST_PAGINATOR_LIMIT
  }

  const options = CONSTANTS.PAGINATOR_OPTIONS
  options.page = req.query?.page ? parseInt(req.query?.page) : CONSTANTS.PAGINATOR_PAGE

  const response = await repo.getAllReviewObjectsPaginated(options, status)
  return res.status(200).json(response)
}

async function approveReviewObject (req, res, next) {
  const reviewRepo = req.ctx.repositories.getReviewObjectRepository()
  const baseOrgRepo = req.ctx.repositories.getBaseOrgRepository()
  const userRepo = req.ctx.repositories.getBaseUserRepository()
  const isSecretariat = await baseOrgRepo.isSecretariatByShortName(req.ctx.org)
  const isPendingReview = true
  const UUID = req.params.uuid
  const body = req.body
  const session = await mongoose.startSession({ causalConsistency: false })
  let updatedOrgObj

  try {
    session.startTransaction()

    const bodyValidation = (body && Object.keys(body).length) ? baseOrgRepo.validateOrg(body) : { isValid: true }
    if (!bodyValidation.isValid) {
      await session.abortTransaction()
      return res.status(400).json({ message: 'Invalid body parameters', errors: bodyValidation.errors })
    }

    const reviewObject = await reviewRepo.findOneByUUIDWithConversation(UUID, isSecretariat, isPendingReview, { session })
    if (!reviewObject) {
      await session.abortTransaction()
      return res.status(404).json({ message: `No pending review object found with UUID ${UUID}` })
    }

    const org = await baseOrgRepo.findOneByUUID(reviewObject.target_object_uuid, { session })
    if (!org) {
      await session.abortTransaction()
      return res.status(404).json({ message: 'Organization not found for this review object' })
    }

    const dataToUpdate = (body && Object.keys(body).length)
      ? _.merge({}, org.toObject(), body)
      : reviewObject.new_review_data

    const requestingUserUUID = await userRepo.getUserUUID(req.ctx.user, req.ctx.org, { session })

    const reviewObj = await reviewRepo.approveReviewOrgObject(UUID, req.ctx.user, { session })
    if (!reviewObj) {
      await session.abortTransaction()
      return res.status(404).json({ message: `Review object not approved with UUID ${UUID}` })
    }
    updatedOrgObj = await baseOrgRepo.updateOrgFull(org.short_name, dataToUpdate, { session }, false, requestingUserUUID, false, true)
    if (!updatedOrgObj) {
      await session.abortTransaction()
      return res.status(404).json({ message: `Org Object not updated with UUID ${UUID}` })
    }

    await session.commitTransaction()
  } catch (updateErr) {
    await session.abortTransaction()
    return res.status(500).json({ message: updateErr.message || 'Failed to approve review object' })
  } finally {
    await session.endSession()
  }
  _.unset(updatedOrgObj, 'joint_approval_required')
  return res.status(200).json(updatedOrgObj)
}

async function updateReviewObjectByReviewUUID (req, res, next) {
  const repo = req.ctx.repositories.getReviewObjectRepository()
  const UUID = req.params.uuid
  const orgRepo = req.ctx.repositories.getBaseOrgRepository()
  const body = req.body
  const session = await mongoose.startSession({ causalConsistency: false })
  let updatedReviewObj

  const result = orgRepo.validateOrg(body)
  if (!result.isValid) {
    return res.status(400).json({ message: 'Invalid new_review_data', errors: result.errors })
  }

  try {
    session.startTransaction()
    const reviewObject = await repo.findOneByUUIDWithConversation(UUID, false, true, { session })
    if (!reviewObject) {
      await session.abortTransaction()
      return res.status(404).json({ message: `No pending review object found with UUID ${UUID}` })
    }
    updatedReviewObj = await repo.updateReviewOrgObject(body, UUID, { session })
    await session.commitTransaction()
  } catch (updateErr) {
    await session.abortTransaction()
    return res.status(500).json({ message: updateErr.message || 'Failed to update review object' })
  } finally {
    await session.endSession()
  }

  if (!updatedReviewObj) {
    return res.status(404).json({ message: `No review object found with UUID ${UUID}` })
  }
  return res.status(200).json(updatedReviewObj)
}

async function createReviewObject (req, res, next) {
  const baseOrgRepo = req.ctx.repositories.getBaseOrgRepository()
  const repo = req.ctx.repositories.getReviewObjectRepository()
  const body = req.body
  const session = await mongoose.startSession({ causalConsistency: false })
  let createdReviewObj

  try {
    session.startTransaction()
    const bodyValidation = (body && Object.keys(body).length) ? baseOrgRepo.validateOrg(body, { session }) : { isValid: false }
    if (!bodyValidation.isValid) {
      await session.abortTransaction()
      return res.status(400).json({ message: 'Invalid body parameters', errors: bodyValidation.errors })
    }
    createdReviewObj = await repo.createReviewOrgObject(body, req.ctx.user, { session })
    await session.commitTransaction()
  } catch (createErr) {
    await session.abortTransaction()
    return res.status(500).json({ message: createErr.message || 'Failed to create review object' })
  } finally {
    await session.endSession()
  }

  if (!createdReviewObj) {
    return res.status(500).json({ message: 'Failed to create review object' })
  }
  return res.status(200).json(createdReviewObj)
}

/**
 * Retrieves the review history for an organization.
 */
async function getReviewHistoryByOrgShortNamePaginated (req, res, next) {
  const reviewRepo = req.ctx.repositories.getReviewObjectRepository()
  const orgRepo = req.ctx.repositories.getBaseOrgRepository()
  const orgShortName = req.params.identifier
  const includeConversations = req.query?.include_conversations
  const isSecretariat = await orgRepo.isSecretariatByShortName(req.ctx.org)
  const CONSTANTS = getConstants()

  const orgExists = await orgRepo.orgExists(orgShortName)
  if (!orgExists) {
    return res.status(404).json(error.orgDnePathParam(orgShortName))
  }

  if (req.TEST_PAGINATOR_LIMIT) {
    CONSTANTS.PAGINATOR_OPTIONS.limit = req.TEST_PAGINATOR_LIMIT
  }

  const options = CONSTANTS.PAGINATOR_OPTIONS
  options.page = req.query?.page ? parseInt(req.query?.page) : CONSTANTS.PAGINATOR_PAGE

  const response = await reviewRepo.getReviewHistoryByOrgShortNamePaginated(
    orgShortName,
    options,
    includeConversations,
    isSecretariat
  )
  return res.status(200).json(response)
}

async function rejectReviewObject (req, res, next) {
  const reviewRepo = req.ctx.repositories.getReviewObjectRepository()
  const baseOrgRepo = req.ctx.repositories.getBaseOrgRepository()
  const UUID = req.params.uuid
  const session = await mongoose.startSession({ causalConsistency: false })

  const isSecretariat = await baseOrgRepo.isSecretariatByShortName(req.ctx.org, { session })

  const isPendingReview = true
  let value

  try {
    session.startTransaction()

    const reviewObject = await reviewRepo.findOneByUUIDWithConversation(UUID, isSecretariat, isPendingReview, { session })
    if (!reviewObject) {
      await session.abortTransaction()
      return res.status(404).json({ message: `No pending review object found with UUID ${UUID}` })
    }

    value = await reviewRepo.rejectReviewOrgObject(UUID, req.ctx.user, { session })
    await session.commitTransaction()
  } catch (rejectErr) {
    await session.abortTransaction()
    return res.status(500).json({ message: rejectErr.message || 'Failed to reject review object' })
  } finally {
    await session.endSession()
  }

  if (!value) {
    return res.status(404).json({ message: `No review object found with UUID ${UUID}` })
  }
  return res.status(200).json(value)
}

module.exports = {
  getReviewObjectByOrgIdentifier,
  getReviewObjectByUUID,
  getAllReviewObjects,
  updateReviewObjectByReviewUUID,
  createReviewObject,
  approveReviewObject,
  getReviewHistoryByOrgShortNamePaginated,
  rejectReviewObject
}