registry-org.controller.js

const mongoose = require('mongoose')
const logger = require('../../middleware/logger')
const { getConstants } = require('../../constants')
const _ = require('lodash')
const errors = require('./error')
const error = new errors.RegistryOrgControllerError()
const conversationErrors = require('../conversation.controller/error')
const convoError = new conversationErrors.ConversationControllerError()
const validateUUID = require('uuid').validate
const authContext = require('../../utils/authContext')

/**
 * Retrieves information about all registry organizations.
 *
 * @async
 * @function getAllOrgs
 * @param {object} req - The Express request object.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description This endpoint is accessible to Secretariat only. It retrieves a list of all registry organizations.
 *              Called by GET /api/registryOrg
 */
async function getAllOrgs (req, res, next) {
  try {
    const repo = req.ctx.repositories.getBaseOrgRepository()
    const conversationRepo = req.ctx.repositories.getConversationRepository()
    const isSecretariat = await authContext.isRequesterSecretariat(req, repo)
    const CONSTANTS = getConstants()
    let returnValue

    // temporary measure to allow tests to work after fixing #920
    // tests required changing the global limit to force pagination
    if (req.TEST_PAGINATOR_LIMIT) {
      CONSTANTS.PAGINATOR_OPTIONS.limit = req.TEST_PAGINATOR_LIMIT
    }

    const options = CONSTANTS.PAGINATOR_OPTIONS
    options.sort = { short_name: 'asc' }
    options.page = req.ctx.query.page ? parseInt(req.ctx.query.page) : CONSTANTS.PAGINATOR_PAGE // if 'page' query parameter is not defined, set 'page' to the default page value

    try {
      returnValue = await repo.getAllOrgs({ ...options }, false, isSecretariat)
      // fetch conversations
      for (let i = 0; i < returnValue.organizations.length; i++) {
        const conversation = await conversationRepo.getAllByTargetUUID(returnValue.organizations[i].UUID, isSecretariat)
        returnValue.organizations[i].conversation = conversation?.length ? conversation : undefined
      }
    } catch (error) {
      // Handle the specific error thrown by BaseOrgRepository.createOrg
      if (error.message && error.message.includes('Unknown Org type requested')) {
        return res.status(400).json({ message: error.message })
      }
      return res.status(500).json({ message: 'Error fetching orgs' })
    }

    logger.info({ uuid: req.ctx.uuid, message: 'The orgs were sent to the user.' })
    return res.status(200).json(returnValue)
  } catch (err) {
    next(err)
  }
}

/**
 * Retrieves information about a specific registry organization.
 *
 * @async
 * @function getOrg
 * @param {object} req - The Express request object, containing the organization identifier in `req.ctx.params.identifier`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description All authenticated users can access this endpoint. It retrieves information about the specified registry organization.
 *              Called by GET /api/registryOrg/:identifier
 */
async function getOrg (req, res, next) {
  try {
    const repo = req.ctx.repositories.getBaseOrgRepository()
    const conversationRepo = req.ctx.repositories.getConversationRepository()
    // User passed in parameter to filter for
    const identifier = req.ctx.params.identifier
    const identifierIsUUID = validateUUID(identifier)
    let returnValue

    try {
      const requesterOrg = await authContext.getRequesterOrg(req, repo)
      const isSecretariat = await authContext.isRequesterSecretariat(req, repo)
      const isRequesterSameOrg = identifierIsUUID
        ? requesterOrg.UUID === identifier
        : await authContext.isRequesterSameOrg(req, repo, identifier)

      if (!isRequesterSameOrg && !isSecretariat) {
        logger.info({ uuid: req.ctx.uuid, message: identifier + ' organization can only be viewed by the users of the same organization or the Secretariat.' })
        return res.status(403).json(error.notSameOrgOrSecretariat())
      }
      returnValue = await repo.getOrg(identifier, identifierIsUUID, {}, false, isSecretariat)

      if (returnValue) {
        // fetch conversation
        const conversation = await conversationRepo.getAllByTargetUUID(returnValue.UUID, isSecretariat)
        if (isSecretariat) {
          returnValue.conversation = conversation?.length ? _.map(conversation, c => _.omit(c, ['__v', '_id', 'previous_conversation_uuid', 'next_conversation_uuid', 'target_uuid'])) : undefined
        } else {
          returnValue.conversation = conversation?.length ? _.map(conversation, c => _.omit(c, ['__v', '_id', 'UUID', 'previous_conversation_uuid', 'next_conversation_uuid', 'target_uuid', 'visibility'])) : undefined
        }
      }
    } catch (error) {
      // Handle the specific error thrown by BaseOrgRepository.createOrg
      if (error.message && error.message.includes('Unknown Org type requested')) {
        return res.status(400).json({ message: error.message })
      }
      throw error
    }
    if (!returnValue) { // an empty result can only happen if the requestor is the Secretariat
      logger.info({ uuid: req.ctx.uuid, message: identifier + ' organization does not exist.' })
      return res.status(404).json(error.orgDne(identifier, 'identifier', 'path'))
    }

    logger.info({ uuid: req.ctx.uuid, message: identifier + ' organization was sent to the user.', org: returnValue })
    return res.status(200).json(returnValue)
  } catch (err) {
    next(err)
  }
}

/**
 * Creates a new registry organization.
 *
 * @async
 * @function createOrg
 * @param {object} req - The Express request object, containing the organization details in `req.ctx.body`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description This endpoint is accessible to Secretariat only. It creates a new registry organization.
 *              Called by POST /api/registryOrg
 */
async function createOrg (req, res, next) {
  try {
    const session = await mongoose.startSession({ causalConsistency: false })
    const repo = req.ctx.repositories.getBaseOrgRepository()
    const body = req.ctx.body
    const isSecretariat = await authContext.isRequesterSecretariat(req, repo, { session })
    let createdOrg

    // Do not allow the user to pass in a UUID
    if ((body?.UUID ?? null) || (body?.uuid ?? null)) {
      return res.status(400).json(error.uuidProvided('org'))
    }

    if (!isSecretariat) {
      const secretariatOnlyFields = getConstants().SECRETARIAT_ONLY_FIELDS
      const restrictedFieldsSent = secretariatOnlyFields.filter(field => _.has(body, field))
      if (restrictedFieldsSent.length > 0) {
        logger.info({ uuid: req.ctx.uuid, message: `Non-secretariat attempted to edit restricted fields: ${restrictedFieldsSent.join(', ')}` })
        return res.status(403).json(error.secretariatOnlyEditing(restrictedFieldsSent))
      }
    }

    try {
      session.startTransaction()
      const result = repo.validateOrg(body, { session })
      if (!result.isValid) {
        logger.error(JSON.stringify({ uuid: req.ctx.uuid, message: 'CVE JSON schema validation FAILED.' }))
        await session.abortTransaction()
        if (!Array.isArray(body?.authority) || body?.authority.some(item => typeof item !== 'string')) {
          return res.status(400).json({ error: 'BAD_INPUT', message: 'Parameters were invalid', details: [{ param: 'authority', msg: 'Parameter must be a one-dimensional array of strings' }] })
        }
        return res.status(400).json({ error: 'BAD_INPUT', message: 'Parameters were invalid', errors: result.errors })
      }

      // Check for duplicate short_name
      if (await repo.orgExists(body?.short_name, { session })) {
        logger.info({
          uuid: req.ctx.uuid,
          message: `${body?.short_name} organization was not created because it already exists.`
        })
        await session.abortTransaction()
        return res.status(400).json(error.orgExists(body?.short_name))
      }

      // Check for alias collisions
      const collisionString = await repo.checkAliasCollisions(body?.short_name, body?.name, body?.aliases, null, { session })
      if (collisionString) {
        logger.info({
          uuid: req.ctx.uuid,
          message: `${body?.short_name} organization was not created because the string '${collisionString}' collides with another organization's short_name, name, or alias.`
        })
        await session.abortTransaction()
        return res.status(400).json(error.aliasCollision(collisionString))
      }

      const userRepo = req.ctx.repositories.getBaseUserRepository()
      const requestingUserUUID = await authContext.getRequesterUserUUID(req, userRepo, repo, { session })
      // Create the org – repo.createOrg will handle field mapping
      createdOrg = await repo.createOrg(body, { session, upsert: true }, false, requestingUserUUID, isSecretariat)

      await session.commitTransaction()
    } catch (createErr) {
      await session.abortTransaction()
      if (createErr.message && createErr.message.includes('Unknown Org type requested')) {
        return res.status(400).json({ message: createErr.message })
      }
      throw createErr
    } finally {
      await session.endSession()
    }

    let responseMessage
    let payload
    if (isSecretariat) {
      responseMessage = {
        message: `${body?.short_name} organization was successfully created.`,
        created: createdOrg
      }

      payload = {
        action: 'create_org',
        change: `${body?.short_name} organization was successfully created.`,
        req_UUID: req.ctx.uuid,
        org_UUID: createdOrg.UUID,
        org: createdOrg
      }
    } else {
      payload = {
        action: 'create_review_org',
        change: body?.short_name + ' was successfully requested to be Reviewed.',
        req_UUID: req.ctx.uuid
      }

      responseMessage = {
        message: body?.short_name + ' was successfully received to be reviewed. By using Load ReviewObject data, you can check for a reply from the Secretariat about Joint Approval items.',
        created: body?.shortName
      }
    }

    logger.info(JSON.stringify(payload))
    return res.status(200).json(responseMessage)
  } catch (err) {
    next(err)
  }
}

async function validateRequestedShortName (req, repo, body, shortName, session) {
  const requestedShortName = body?.new_short_name || body?.short_name || shortName

  if (_.has(body, 'short_name') && _.has(body, 'new_short_name') && body.short_name !== shortName && body.short_name !== body.new_short_name) {
    logger.info({
      uuid: req.ctx.uuid,
      message: `${shortName} organization could not be updated because short_name and new_short_name identify different requested short names.`
    })
    return {
      status: 400,
      response: {
        message: 'Parameters were invalid',
        errors: [{
          instancePath: '/short_name',
          message: 'short_name must match the path shortname or new_short_name when new_short_name is provided'
        }]
      }
    }
  }

  if (requestedShortName !== shortName && await repo.orgExists(requestedShortName, { session })) {
    logger.info({
      uuid: req.ctx.uuid,
      message: `${shortName} organization could not be updated because new short name ${requestedShortName} already exists.`
    })
    return {
      status: 400,
      response: error.duplicateShortname(requestedShortName)
    }
  }

  const collisionString = await repo.checkAliasCollisions(requestedShortName, body?.name, body?.aliases, shortName, { session })
  if (collisionString) {
    logger.info({
      uuid: req.ctx.uuid,
      message: `${shortName} organization could not be updated because the string '${collisionString}' collides with another organization's short_name, name, or alias.`
    })
    return {
      status: 400,
      response: error.aliasCollision(collisionString)
    }
  }

  return { requestedShortName }
}

/**
 * Updates an existing registry organization.
 *
 * @async
 * @function updateOrg
 * @param {object} req - The Express request object, containing the organization shortname in `req.ctx.params.shortname` and update details in `req.ctx.query`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description This endpoint is accessible to Secretariat only. It updates an existing registry organization.
 *              Called by PUT /api/registryOrg/:shortname
 */
async function updateOrg (req, res, next) {
  try {
    const session = await mongoose.startSession({ causalConsistency: false })
    const shortName = req.ctx.params.shortname
    const repo = req.ctx.repositories.getBaseOrgRepository()
    const userRepo = req.ctx.repositories.getBaseUserRepository()
    const conversationRepo = req.ctx.repositories.getConversationRepository()
    const { conversation, ...body } = req.ctx.body
    let updatedOrg
    let jointApprovalRequired

    try {
      session.startTransaction()
      const requester = await authContext.getRequesterContext(req, { orgRepo: repo, userRepo }, { session })
      const isSecretariat = requester.isSecretariat
      const isAdmin = requester.isAdmin
      const requestingUser = requester.user
      const org = await repo.findOneByShortName(shortName, { session })
      const requesterSameOrg = org
        ? await authContext.isRequesterSameOrg(req, repo, org, { session })
        : await authContext.isRequesterSameOrg(req, repo, shortName, { session })

      if (!isSecretariat && !requesterSameOrg) {
        logger.info({ uuid: req.ctx.uuid, message: shortName + ' organization can only be updated by the users of the same organization or the Secretariat.' })
        await session.abortTransaction()
        return res.status(403).json(error.notSameOrgOrSecretariat())
      }

      if (!isSecretariat && !isAdmin) {
        logger.info({ uuid: req.ctx.uuid, message: shortName + ' organization can only be updated by the Secretariat or an Org Admin.' })
        await session.abortTransaction()
        return res.status(403).json(error.notOrgAdminOrSecretariatUpdate())
      }

      if (!isSecretariat) {
        const secretariatOnlyFields = getConstants().SECRETARIAT_ONLY_FIELDS
        const restrictedFieldsSent = secretariatOnlyFields.filter(field => _.has(body, field))
        if (restrictedFieldsSent.length > 0) {
          logger.info({ uuid: req.ctx.uuid, message: `Non-secretariat attempted to edit restricted fields: ${restrictedFieldsSent.join(', ')}` })
          await session.abortTransaction()
          return res.status(403).json(error.secretariatOnlyEditing(restrictedFieldsSent))
        }
      }

      // Edge Case: if a user has requested an org, but it is not approved yet, then we need to check to see if if there is a review org for the shortname request.

      if (!org) {
        // resolve edge case
        const reviewRepo = req.ctx.repositories.getReviewObjectRepository()
        const reviewOrg = await reviewRepo.getOrgReviewObjectByOrgShortname(shortName, isSecretariat, { session })

        // Eventually we should validate this, but this is a bit tricky.
        if (reviewOrg) {
          // For review objects, verify the provided UUID matches the target review object's UUID
          const providedUUID = body?.UUID || body?.uuid
          if (providedUUID && providedUUID !== reviewOrg.uuid) {
            await session.abortTransaction()
            return res.status(400).json(error.uuidProvided('org'))
          }

          const updateResult = await reviewRepo.updateReviewOrgObject(body, reviewOrg.uuid, { session })
          if (updateResult) {
            updatedOrg = reviewOrg
            await session.commitTransaction()
            return res.status(200).json({ message: 'Review object updated successfully' })
          }
        } else {
          logger.info({ uuid: req.ctx.uuid, message: shortName + ' organization could not be updated because it does not exist.' })
          await session.abortTransaction()
          return res.status(404).json(error.orgDnePathParam(shortName))
        }
      }

      // Verify that the provided UUID matches the existing organization's immutable database UUID
      if (org) {
        const providedUUID = body?.UUID || body?.uuid
        if (providedUUID && providedUUID !== org.UUID) {
          await session.abortTransaction()
          return res.status(400).json(error.uuidProvided('org'))
        }
      }

      // Validate org
      const result = repo.validateOrg(body, { session })
      if (!result.isValid) {
        logger.error(JSON.stringify({ uuid: req.ctx.uuid, message: 'CVE JSON schema validation FAILED.' }))
        await session.abortTransaction()
        return res.status(400).json({ message: 'Parameters were invalid', errors: result.errors })
      }

      // Validate conversation (if it exists)
      if (conversation) {
        if (
          typeof conversation !== 'object' ||
          !conversation.body ||
          !conversationRepo.validateConversation(conversation)
        ) {
          logger.error(JSON.stringify({ uuid: req.ctx.uuid, message: 'Invalid conversation object.' }))
          await session.abortTransaction()
          return res.status(400).json(convoError.invalidConversationObject())
        }
      }

      const shortNameValidation = await validateRequestedShortName(req, repo, body, shortName, session)
      if (shortNameValidation.status) {
        await session.abortTransaction()
        return res.status(shortNameValidation.status).json(shortNameValidation.response)
      }

      // Handle secretariat "stomping" of pending review objects
      if (isSecretariat) {
        const reviewRepo = req.ctx.repositories.getReviewObjectRepository()
        const pendingReview = await reviewRepo.getOrgReviewObjectByOrgShortname(shortName, isSecretariat, { session })

        if (pendingReview) {
          const pendingReviewData = pendingReview.new_review_data

          // Merge to get full expected state from pending review vs incoming
          const pendingFullState = _.merge({}, org.toObject(), pendingReviewData)
          const incomingFullState = _.merge({}, org.toObject(), body)

          // Clean for comparison (remove metadata)
          const cleanPending = _.omit(pendingFullState, ['_id', '__v', '__t', 'createdAt', 'updatedAt', 'created', 'last_updated'])
          const cleanIncoming = _.omit(incomingFullState, ['_id', '__v', '__t', 'createdAt', 'updatedAt', 'created', 'last_updated'])

          // Compare and set status accordingly
          if (_.isEqual(cleanPending, cleanIncoming)) {
            await reviewRepo.approveReviewOrgObject(pendingReview.uuid, req.ctx.user, { session })
          } else {
            await reviewRepo.rejectReviewOrgObject(pendingReview.uuid, req.ctx.user, { session })
          }
        }
      }

      // Update Org full will cause a write to the Conversations collection, to avoid a read-after-write issue, we need to get the previous conversation data first
      const previousConversation = await conversationRepo.getAllByTargetUUID(await repo.getOrgUUID(shortName, { session }), isSecretariat, { session }) || []

      updatedOrg = await repo.updateOrgFull(shortName, req.ctx.body, { session }, false, requestingUser.UUID, isAdmin, isSecretariat)
      jointApprovalRequired = _.get(updatedOrg, 'joint_approval_required', false)
      _.unset(updatedOrg, 'joint_approval_required')
      // append previous conversations to any conversations that are in the org already
      const currentConversations = Array.isArray(updatedOrg?.conversation) ? updatedOrg.conversation : []
      const prevConversations = Array.isArray(previousConversation) ? previousConversation : []
      if (updatedOrg) {
        updatedOrg.conversation = [...currentConversations, ...prevConversations].map(c => _.omit(c, ['__v', '_id', 'previous_conversation_uuid', 'next_conversation_uuid']))
      }

      await session.commitTransaction()
    } catch (updateErr) {
      await session.abortTransaction()
      throw updateErr
    } finally {
      await session.endSession()
    }

    if (jointApprovalRequired) {
      const responseMessage = {
        message: `${body?.short_name} organization was successfully updated, but joint approval is required for some fields. Check the ReviewObject for your org to check for a reply from the Secretariat about Joint Approval items.`,
        updated: updatedOrg
      }

      const payload = {
        action: 'update_registry_org',
        change: body?.short_name + 'organization was successfully updated, but joint approval is required for some fields. Check the ReviewObject for your org to check for a reply from the Secretariat about Joint Approval items.',
        req_UUID: req.ctx.uuid,
        org_UUID: updatedOrg.UUID,
        org: updatedOrg
      }

      logger.info(JSON.stringify(payload))
      return res.status(200).json(responseMessage)
    } else {
      const responseMessage = {
        message: `${body?.short_name} organization was successfully updated.`,
        updated: updatedOrg
      }

      const payload = {
        action: 'update_registry_org',
        change: body?.short_name + ' was successfully updated.',
        req_UUID: req.ctx.uuid,
        org_UUID: updatedOrg.UUID,
        org: updatedOrg
      }
      logger.info(JSON.stringify(payload))
      return res.status(200).json(responseMessage)
    }
  } catch (err) {
    next(err)
  }
}

/**
 * Deletes an existing registry organization.
 *
 * @async
 * @function deleteOrg
 * @param {object} req - The Express request object, containing the organization identifier in `req.ctx.params.identifier`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description This endpoint is accessible to Secretariat only. It deletes an existing registry organization.
 *              Called by DELETE /api/registryOrg/:identifier
 */
async function deleteOrg (req, res, next) {
  try {
    const session = await mongoose.startSession({ causalConsistency: false })
    const repo = req.ctx.repositories.getBaseOrgRepository()
    const shortName = req.ctx.params.identifier
    let targetOrgUUID

    try {
      session.startTransaction()
      const org = await repo.findOneByShortName(shortName)
      if (!org) {
        logger.info({ uuid: req.ctx.uuid, message: shortName + ' organization could not be deleted because it does not exist.' })
        await session.abortTransaction()
        return res.status(404).json(error.orgDnePathParam(shortName))
      }

      targetOrgUUID = org.UUID
      await repo.deleteOrg(shortName, { session })
      await session.commitTransaction()
    } catch (deleteErr) {
      await session.abortTransaction()
      throw deleteErr
    } finally {
      await session.endSession()
    }

    const responseMessage = {
      message: `${shortName} organization was successfully deleted.`
    }

    const payload = {
      action: 'delete_registry_org',
      change: shortName + ' was successfully deleted.',
      req_UUID: req.ctx.uuid,
      org_UUID: targetOrgUUID
    }
    logger.info(JSON.stringify(payload))
    return res.status(200).json(responseMessage)
  } catch (err) {
    next(err)
  }
}

/**
 * Retrieves all users for the organization with the specified short name.
 *
 * @async
 * @function getUsers
 * @param {object} req - The Express request object, containing the organization shortname in `req.ctx.params.shortname`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent. Response body includes 'role' field for admins.
 * @description All registered users can access this endpoint. Regular, CNA & Admin Users can retrieve information about users in the same organization.
 *              Secretariat can retrieve all user information for any organization.
 *              Called by GET /api/registryOrg/:shortname/users
 */
async function getUsers (req, res, next) {
  try {
    const CONSTANTS = getConstants()

    // temporary measure to allow tests to work after fixing #920
    // tests required changing the global limit to force pagination
    if (req.TEST_PAGINATOR_LIMIT) {
      CONSTANTS.PAGINATOR_OPTIONS.limit = req.TEST_PAGINATOR_LIMIT
    }

    const options = CONSTANTS.PAGINATOR_OPTIONS
    options.sort = { username: 'asc' }
    options.page = req.ctx.query.page ? parseInt(req.ctx.query.page) : CONSTANTS.PAGINATOR_PAGE // if 'page' query parameter is not defined, set 'page' to the default page value
    const orgShortName = req.ctx.params.shortname
    const orgRepo = req.ctx.repositories.getBaseOrgRepository()
    const userRepo = req.ctx.repositories.getBaseUserRepository()
    const orgUUID = await orgRepo.getOrgUUID(orgShortName)
    const isSecretariat = await authContext.isRequesterSecretariat(req, orgRepo)

    if (!orgUUID) {
      logger.info({ uuid: req.ctx.uuid, message: orgShortName + ' organization does not exist.' })
      return res.status(404).json(error.orgDnePathParam(orgShortName))
    }

    const isSameOrg = await authContext.isRequesterSameOrg(req, orgRepo, { UUID: orgUUID, short_name: orgShortName })
    if (!isSameOrg && !isSecretariat) {
      logger.info({ uuid: req.ctx.uuid, message: orgShortName + ' organization can only be viewed by the users of the same organization or the Secretariat.' })
      return res.status(403).json(error.notSameOrgOrSecretariat())
    }

    // This should always return Registry typed
    const payload = await userRepo.getAllUsersByOrgShortname(orgShortName, options, true)

    // Hydrate the role field
    const org = await orgRepo.findOneByShortName(orgShortName)
    payload.users.forEach(user => {
      user.role = org.admins.includes(user.UUID) ? 'ADMIN' : user.role // Default to existing role if not admin
    })

    logger.info({ uuid: req.ctx.uuid, message: `The users of ${orgShortName} organization were sent to the user.` })
    return res.status(200).json(payload)
  } catch (err) {
    next(err)
  }
}

/**
 * Create a user with the provided short name as the owning organization.
 *
 * @async
 * @function createUserByOrg
 * @param {object} req - The Express request object, containing the organization shortname in `req.ctx.params.shortname` and user details in `req.ctx.body`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description User must belong to an organization with the Secretariat role or be an Admin of the organization.
 *              Admin User: Creates a user for the Admin's organization.
 *              Secretariat: Creates a user for any organization.
 *              Called by POST /api/registryOrg/:shortname/user
 */
async function createUserByOrg (req, res, next) {
  const session = await mongoose.startSession({ causalConsistency: false })
  try {
    const body = req.ctx.body
    const userRepo = req.ctx.repositories.getBaseUserRepository()
    const orgRepo = req.ctx.repositories.getBaseOrgRepository()
    const orgShortName = req.ctx.params.shortname
    let returnValue

    // Check to make sure Org Exists first
    const orgUUID = await orgRepo.getOrgUUID(orgShortName, {}, false)
    if (!orgUUID) {
      logger.info({ uuid: req.ctx.uuid, message: 'The user could not be created because ' + orgShortName + ' organization does not exist.' })
      return res.status(404).json(error.orgDnePathParam(orgShortName))
    }

    // Do not allow the user to pass in a UUID
    if ((body?.UUID ?? null) || (body?.uuid ?? null)) {
      return res.status(400).json(error.uuidProvided('user'))
    }

    if ((body?.org_UUID ?? null) || (body?.org_uuid ?? null)) {
      return res.status(400).json(error.uuidProvided('org'))
    }

    try {
      session.startTransaction()
      const result = await userRepo.validateUser(body)
      if (body?.role && typeof body?.role !== 'string') {
        return res.status(400).json({ message: 'Parameters were invalid', details: [{ param: 'role', msg: 'Parameter must be a string' }] })
      }
      if (!result.isValid) {
        logger.error(JSON.stringify({ uuid: req.ctx.uuid, message: 'User JSON schema validation FAILED.' }))
        await session.abortTransaction()
        return res.status(400).json({ message: 'Parameters were invalid', errors: result.errors })
      }

      // Ask repo if user already exists
      if (await userRepo.orgHasUser(orgShortName, body?.username, { session }, true)) {
        logger.info({ uuid: req.ctx.uuid, message: `${body?.username} user was not created because it already exists.` })
        await session.abortTransaction()
        return res.status(400).json(error.userExists(body?.username))
      }

      const isRequesterSecretariat = await authContext.isRequesterSecretariat(req, orgRepo, { session })
      const isRequesterAdminOfTargetOrg = await authContext.isRequesterAdminOfOrg(req, userRepo, orgRepo, orgShortName, { session })
      if (!isRequesterSecretariat && !isRequesterAdminOfTargetOrg) {
        await session.abortTransaction()
        return res.status(403).json(error.notOrgAdminOrSecretariat()) // The Admin user must belong to the new user's organization
      }

      const users = await userRepo.findUsersByOrgShortname(orgShortName, { session })
      if (users.length >= 100) {
        await session.abortTransaction()
        return res.status(400).json(error.userLimitReached())
      }

      const requestingUserUUID = await authContext.getRequesterUserUUID(req, userRepo, orgRepo, { session })
      returnValue = await userRepo.createUser(orgShortName, body, { session, upsert: true }, true, requestingUserUUID)
      await session.commitTransaction()
    } catch (error) {
      await session.abortTransaction()
      throw error
    } finally {
      await session.endSession()
    }

    const secret = returnValue.secret
    delete returnValue.secret

    const payload = {
      action: 'create_user',
      change: `${body?.username} was successfully created.`,
      req_UUID: req.ctx.uuid,
      org_UUID: returnValue.org_UUID,
      user_UUID: returnValue.UUID,
      user: returnValue
    }
    logger.info(JSON.stringify(payload))

    returnValue.secret = secret
    const responseMessage = {
      message: `${body?.username} was successfully created.`,
      created: returnValue
    }

    return res.status(200).json(responseMessage)
  } catch (err) {
    next(err)
  }
}

/**
 * Updates the conversation at the provided index for the given organization.
 *
 * @async
 * @function editConversationForOrg
 * @param {object} req - The Express request object, containing the organization shortname in `req.ctx.params.shortname` and conversation updates in `req.ctx.body`.
 * @param {object} res - The Express response object.
 * @param {function} next - The next middleware function.
 * @returns {Promise<void>} - A promise that resolves when the response is sent.
 * @description User must be the original author of the conversation or the Secretariat role.
 *              The original author is allowed to update the conversation message body.
 *              Secretariat is allowed to update the conversation message body and visibility.
 *              Called by PUT /api/registry/org/:shortname/conversation/:index
 */
async function editConversationForOrg (req, res, next) {
  const repo = req.ctx.repositories.getBaseOrgRepository()
  const userRepo = req.ctx.repositories.getBaseUserRepository()
  const conversationRepo = req.ctx.repositories.getConversationRepository()

  const orgShortName = req.params.shortname || req.ctx.params.shortname
  const index = parseInt(req.params.index || req.ctx.params.index)
  const incomingParameters = req.ctx.body

  const session = await mongoose.startSession({ causalConsistency: false })

  try {
    const orgUUID = await repo.getOrgUUID(orgShortName, {}, false)
    if (!orgUUID) {
      await session.endSession()
      return res.status(404).json(error.orgDnePathParam(orgShortName))
    }

    await session.startTransaction()

    // Find the conversation by index to get its actual UUID
    const conversation = await conversationRepo.findByTargetUUIDAndIndex(orgUUID, index, { session })
    if (!conversation) {
      await session.abortTransaction()
      await session.endSession()
      return res.status(404).json(convoError.conversationIndexDne(orgShortName, index))
    }

    const isSecretariat = await authContext.isRequesterSecretariat(req, repo, { session })

    // Authorization Logic
    if (!isSecretariat) {
      // Check visibility change attempt
      if (incomingParameters.visibility) {
        await session.abortTransaction()
        await session.endSession()
        return res.status(403).json({ message: 'Only the Secretariat is allowed to change the visibility of a conversation.' })
      }

      const requestingUser = await authContext.getRequesterUser(req, userRepo, repo, { session })
      if (!requestingUser) {
        await session.abortTransaction()
        await session.endSession()
        return res.status(403).json({ message: 'You must be the original author or Secretariat to edit this conversation.' })
      }

      // UUID extraction and comparison
      const userUUID = requestingUser.UUID || requestingUser.uuid
      const authorUUID = conversation.author_uuid || conversation.author_id || conversation.author_UUID

      const isAuthor = String(authorUUID).toLowerCase() === String(userUUID).toLowerCase()
      const isStillInOrg = await authContext.isRequesterSameOrg(req, repo, { UUID: orgUUID, short_name: orgShortName }, { session })

      if (!isAuthor || !isStillInOrg) {
        await session.abortTransaction()
        await session.endSession()
        return res.status(403).json({ message: 'You must be the original author or Secretariat to edit this conversation.' })
      }
    }

    // Prepare Update
    const updatePayload = { body: incomingParameters.body }
    if (isSecretariat && incomingParameters.visibility) {
      updatePayload.visibility = incomingParameters.visibility
    }

    const returnValue = await conversationRepo.editConversation(conversation.UUID, updatePayload, { session })

    await session.commitTransaction()
    await session.endSession()

    return res.status(200).json({
      message: 'The conversation was successfully updated.',
      updated: returnValue
    })
  } catch (err) {
    if (session.inTransaction()) {
      await session.abortTransaction()
    }
    await session.endSession()
    logger.error({ uuid: req.ctx.uuid, message: err.stack })
    next(err)
  }
}

module.exports = {
  ALL_ORGS: getAllOrgs,
  SINGLE_ORG: getOrg,
  CREATE_ORG: createOrg,
  UPDATE_ORG: updateOrg,
  DELETE_ORG: deleteOrg,
  USER_ALL: getUsers,
  USER_CREATE_SINGLE: createUserByOrg,
  EDIT_CONVERSATION: editConversationForOrg
}