@mojaloop/central-ledger 17.7.8 → 17.8.0-orb.1

package/src/domain/participant/index.js

@@ -42,6 +42,7 @@ const KafkaProducer = require('@mojaloop/central-services-stream').Util.Producer
 const { randomUUID } = require('crypto')
 const Enum = require('@mojaloop/central-services-shared').Enum
 const Enums = require('../../lib/enumCached')
+const { logger } = require('../../shared/logger')
 
 // Alphabetically ordered list of error texts used below
 const AccountInactiveErrorText = 'Account is currently set inactive'
@@ -58,9 +59,12 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const { destroyParticipantEndpointByParticipantId } = require('../../models/participant/participant')
 
 const create = async (payload) => {
+  const log = logger.child({ payload })
   try {
-    return ParticipantModel.create({ name: payload.name })
+    log.info('creating participant with payload')
+    return ParticipantModel.create({ name: payload.name, isProxy: !!payload.isProxy })
   } catch (err) {
+    log.error('error creating participant', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -71,13 +75,16 @@ const getAll = async () => {
     await Promise.all(all.map(async (participant) => {
       participant.currencyList = await ParticipantCurrencyModel.getByParticipantId(participant.participantId)
     }))
+    logger.debug('getAll participants', { participants: all })
     return all
   } catch (err) {
+    logger.error('error getting all participants', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getById = async (id) => {
+  logger.debug('getting participant by id', { id })
   const participant = await ParticipantModel.getById(id)
   if (participant) {
     participant.currencyList = await ParticipantCurrencyModel.getByParticipantId(participant.participantId)
@@ -86,6 +93,7 @@ const getById = async (id) => {
 }
 
 const getByName = async (name) => {
+  logger.debug('getting participant by name', { name })
   const participant = await ParticipantModel.getByName(name)
   if (participant) {
     participant.currencyList = await ParticipantCurrencyModel.getByParticipantId(participant.participantId)
@@ -94,17 +102,23 @@ const getByName = async (name) => {
 }
 
 const participantExists = (participant, checkIsActive = false) => {
+  const log = logger.child({ participant, checkIsActive })
+  log.debug('checking if participant exists')
   if (participant) {
     if (!checkIsActive || participant.isActive) {
       return participant
     }
+    log.warn('participant is inactive')
     throw ErrorHandler.Factory.createInternalServerFSPIOPError(ParticipantInactiveText)
   }
+  log.warn('participant not found')
   throw ErrorHandler.Factory.createInternalServerFSPIOPError(ParticipantNotFoundText)
 }
 
 const update = async (name, payload) => {
+  const log = logger.child({ name, payload })
   try {
+    log.info('updating participant')
     const participant = await ParticipantModel.getByName(name)
     participantExists(participant)
     await ParticipantModel.update(participant, payload.isActive)
@@ -112,38 +126,50 @@ const update = async (name, payload) => {
     participant.currencyList = await ParticipantCurrencyModel.getByParticipantId(participant.participantId)
     return participant
   } catch (err) {
+    log.error('error updating participant', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const createParticipantCurrency = async (participantId, currencyId, ledgerAccountTypeId, isActive = true) => {
+  const log = logger.child({ participantId, currencyId, ledgerAccountTypeId, isActive })
   try {
+    log.info('creating participant currency')
     const participantCurrency = await ParticipantCurrencyModel.create(participantId, currencyId, ledgerAccountTypeId, isActive)
     return participantCurrency
   } catch (err) {
+    log.error('error creating participant currency', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const createHubAccount = async (participantId, currencyId, ledgerAccountTypeId) => {
+  const log = logger.child({ participantId, currencyId, ledgerAccountTypeId })
   try {
+    log.info('creating hub account')
     const participantCurrency = await ParticipantFacade.addHubAccountAndInitPosition(participantId, currencyId, ledgerAccountTypeId)
     return participantCurrency
   } catch (err) {
+    log.error('error creating hub account', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getParticipantCurrencyById = async (participantCurrencyId) => {
+  const log = logger.child({ participantCurrencyId })
   try {
+    log.debug('getting participant currency by id')
     return await ParticipantCurrencyModel.getById(participantCurrencyId)
   } catch (err) {
+    log.error('error getting participant currency by id', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const destroyByName = async (name) => {
+  const log = logger.child({ name })
   try {
+    log.debug('destroying participant by name')
     const participant = await ParticipantModel.getByName(name)
     await ParticipantLimitModel.destroyByParticipantId(participant.participantId)
     await ParticipantPositionModel.destroyByParticipantId(participant.participantId)
@@ -151,6 +177,7 @@ const destroyByName = async (name) => {
     await destroyParticipantEndpointByParticipantId(participant.participantId)
     return await ParticipantModel.destroyByName(name)
   } catch (err) {
+    log.error('error destroying participant by name', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -174,11 +201,15 @@ const destroyByName = async (name) => {
  */
 
 const addEndpoint = async (name, payload) => {
+  const log = logger.child({ name, payload })
   try {
+    log.info('adding endpoint')
     const participant = await ParticipantModel.getByName(name)
     participantExists(participant)
+    log.info('adding endpoint for participant', { participant })
     return ParticipantFacade.addEndpoint(participant.participantId, payload)
   } catch (err) {
+    log.error('error adding endpoint', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -199,11 +230,15 @@ const addEndpoint = async (name, payload) => {
  */
 
 const getEndpoint = async (name, type) => {
+  const log = logger.child({ name, type })
   try {
+    log.debug('getting endpoint')
     const participant = await ParticipantModel.getByName(name)
     participantExists(participant)
+    log.debug('getting endpoint for participant', { participant })
     return ParticipantFacade.getEndpoint(participant.participantId, type)
   } catch (err) {
+    log.error('error getting endpoint', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -223,11 +258,15 @@ const getEndpoint = async (name, type) => {
  */
 
 const getAllEndpoints = async (name) => {
+  const log = logger.child({ name })
   try {
+    log.debug('getting all endpoints for participant name')
     const participant = await ParticipantModel.getByName(name)
     participantExists(participant)
+    log.debug('getting all endpoints for participant', { participant })
     return ParticipantFacade.getAllEndpoints(participant.participantId)
   } catch (err) {
+    log.error('error getting all endpoints', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -245,11 +284,15 @@ const getAllEndpoints = async (name) => {
  */
 
 const destroyParticipantEndpointByName = async (name) => {
+  const log = logger.child({ name })
   try {
+    log.debug('destroying participant endpoint by name')
     const participant = await ParticipantModel.getByName(name)
     participantExists(participant)
+    log.debug('destroying participant endpoint for participant', { participant })
     return ParticipantModel.destroyParticipantEndpointByParticipantId(participant.participantId)
   } catch (err) {
+    log.error('error destroying participant endpoint by name', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -278,14 +321,18 @@ const destroyParticipantEndpointByName = async (name) => {
  */
 
 const addLimitAndInitialPosition = async (participantName, limitAndInitialPositionObj) => {
+  const log = logger.child({ participantName, limitAndInitialPositionObj })
   try {
+    log.debug('adding limit and initial position', { participantName, limitAndInitialPositionObj })
     const participant = await ParticipantFacade.getByNameAndCurrency(participantName, limitAndInitialPositionObj.currency, Enum.Accounts.LedgerAccountType.POSITION)
     participantExists(participant)
+    log.debug('adding limit and initial position for participant', { participant })
     const settlementAccount = await ParticipantFacade.getByNameAndCurrency(participantName, limitAndInitialPositionObj.currency, Enum.Accounts.LedgerAccountType.SETTLEMENT)
     const existingLimit = await ParticipantLimitModel.getByParticipantCurrencyId(participant.participantCurrencyId)
     const existingPosition = await ParticipantPositionModel.getByParticipantCurrencyId(participant.participantCurrencyId)
     const existingSettlementPosition = await ParticipantPositionModel.getByParticipantCurrencyId(settlementAccount.participantCurrencyId)
     if (existingLimit || existingPosition || existingSettlementPosition) {
+      log.warn('participant limit or initial position already set')
       throw ErrorHandler.Factory.createInternalServerFSPIOPError(ParticipantInitialPositionExistsText)
     }
     const limitAndInitialPosition = Object.assign({}, limitAndInitialPositionObj, { name: participantName })
@@ -296,6 +343,7 @@ const addLimitAndInitialPosition = async (participantName, limitAndInitialPositi
     await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, KafkaProducer, Enum.Events.Event.Type.NOTIFICATION, Enum.Transfers.AdminNotificationActions.LIMIT_ADJUSTMENT, createLimitAdjustmentMessageProtocol(payload), Enum.Events.EventStatus.SUCCESS)
     return ParticipantFacade.addLimitAndInitialPosition(participant.participantCurrencyId, settlementAccount.participantCurrencyId, limitAndInitialPosition, true)
   } catch (err) {
+    log.error('error adding limit and initial position', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -313,9 +361,12 @@ const addLimitAndInitialPosition = async (participantName, limitAndInitialPositi
  */
 
 const getPositionByParticipantCurrencyId = async (participantCurrencyId) => {
+  const log = logger.child({ participantCurrencyId })
   try {
+    log.debug('getting position by participant currency id')
     return ParticipantPositionModel.getByParticipantCurrencyId(participantCurrencyId)
   } catch (err) {
+    log.error('error getting position by participant currency id', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -333,9 +384,12 @@ const getPositionByParticipantCurrencyId = async (participantCurrencyId) => {
  */
 
 const getPositionChangeByParticipantPositionId = async (participantPositionId) => {
+  const log = logger.child({ participantPositionId })
   try {
+    log.debug('getting position change by participant position id')
     return ParticipantPositionChangeModel.getByParticipantPositionId(participantPositionId)
   } catch (err) {
+    log.error('error getting position change by participant position id', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -353,11 +407,15 @@ const getPositionChangeByParticipantPositionId = async (participantPositionId) =
  */
 
 const destroyParticipantPositionByNameAndCurrency = async (name, currencyId) => {
+  const log = logger.child({ name, currencyId })
   try {
+    log.debug('destroying participant position by participant name and currency')
     const participant = await ParticipantFacade.getByNameAndCurrency(name, currencyId, Enum.Accounts.LedgerAccountType.POSITION)
+    log.debug('destroying participant position for participant', { participant })
     participantExists(participant)
     return ParticipantPositionModel.destroyByParticipantCurrencyId(participant.participantCurrencyId)
   } catch (err) {
+    log.error('error destroying participant position by name and currency', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -376,11 +434,15 @@ const destroyParticipantPositionByNameAndCurrency = async (name, currencyId) =>
  */
 
 const destroyParticipantLimitByNameAndCurrency = async (name, currencyId) => {
+  const log = logger.child({ name, currencyId })
   try {
+    log.debug('destroying participant limit by participant name and currency')
     const participant = await ParticipantFacade.getByNameAndCurrency(name, currencyId, Enum.Accounts.LedgerAccountType.POSITION)
+    log.debug('destroying participant limit for participant', { participant })
     participantExists(participant)
     return ParticipantLimitModel.destroyByParticipantCurrencyId(participant.participantCurrencyId)
   } catch (err) {
+    log.error('error destroying participant limit by name and currency', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -403,18 +465,24 @@ const destroyParticipantLimitByNameAndCurrency = async (name, currencyId) => {
  */
 
 const getLimits = async (name, { currency = null, type = null }) => {
+  const log = logger.child({ name, currency, type })
   try {
     let participant
     if (currency != null) {
+      log.debug('getting limits by name and currency')
       participant = await ParticipantFacade.getByNameAndCurrency(name, currency, Enum.Accounts.LedgerAccountType.POSITION)
+      log.debug('getting limits for participant', { participant })
       participantExists(participant)
       return ParticipantFacade.getParticipantLimitsByCurrencyId(participant.participantCurrencyId, type)
     } else {
+      log.debug('getting limits by name')
       participant = await ParticipantModel.getByName(name)
+      log.debug('getting limits for participant', { participant })
       participantExists(participant)
       return ParticipantFacade.getParticipantLimitsByParticipantId(participant.participantId, type, Enum.Accounts.LedgerAccountType.POSITION)
     }
   } catch (err) {
+    log.error('error getting limits', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -434,9 +502,12 @@ const getLimits = async (name, { currency = null, type = null }) => {
  */
 
 const getLimitsForAllParticipants = async ({ currency = null, type = null }) => {
+  const log = logger.child({ currency, type })
   try {
+    log.debug('getting limits for all participants', { currency, type })
     return ParticipantFacade.getLimitsForAllParticipants(currency, type, Enum.Accounts.LedgerAccountType.POSITION)
   } catch (err) {
+    log.error('error getting limits for all participants', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -465,15 +536,19 @@ const getLimitsForAllParticipants = async ({ currency = null, type = null }) =>
  */
 
 const adjustLimits = async (name, payload) => {
+  const log = logger.child({ name, payload })
   try {
+    log.debug('adjusting limits')
     const { limit, currency } = payload
     const participant = await ParticipantFacade.getByNameAndCurrency(name, currency, Enum.Accounts.LedgerAccountType.POSITION)
+    log.debug('adjusting limits for participant', { participant })
     participantExists(participant)
     const result = await ParticipantFacade.adjustLimits(participant.participantCurrencyId, limit)
     payload.name = name
     await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, KafkaProducer, Enum.Events.Event.Type.NOTIFICATION, Enum.Transfers.AdminNotificationActions.LIMIT_ADJUSTMENT, createLimitAdjustmentMessageProtocol(payload), Enum.Events.EventStatus.SUCCESS)
     return result
   } catch (err) {
+    log.error('error adjusting limits', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -546,9 +621,12 @@ const createLimitAdjustmentMessageProtocol = (payload, action = Enum.Transfers.A
  */
 
 const getPositions = async (name, query) => {
+  const log = logger.child({ name, query })
   try {
+    log.debug('getting positions')
     if (query.currency) {
       const participant = await ParticipantFacade.getByNameAndCurrency(name, query.currency, Enum.Accounts.LedgerAccountType.POSITION)
+      log.debug('getting positions for participant', { participant })
       participantExists(participant)
       const result = await PositionFacade.getByNameAndCurrency(name, Enum.Accounts.LedgerAccountType.POSITION, query.currency) // TODO this function only takes a max of 3 params, this has 4
       let position = {}
@@ -559,9 +637,11 @@ const getPositions = async (name, query) => {
           changedDate: result[0].changedDate
         }
       }
+      log.debug('found positions for participant', { participant, position })
       return position
     } else {
       const participant = await ParticipantModel.getByName(name)
+      log.debug('getting positions for participant', { participant })
       participantExists(participant)
       const result = await await PositionFacade.getByNameAndCurrency(name, Enum.Accounts.LedgerAccountType.POSITION)
       const positions = []
@@ -574,16 +654,21 @@ const getPositions = async (name, query) => {
           })
         })
       }
+      log.debug('found positions for participant', { participant, positions })
       return positions
     }
   } catch (err) {
+    log.error('error getting positions', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getAccounts = async (name, query) => {
+  const log = logger.child({ name, query })
   try {
+    log.debug('getting accounts')
     const participant = await ParticipantModel.getByName(name)
+    log.debug('getting accounts for participant', { participant })
     participantExists(participant)
     const result = await PositionFacade.getAllByNameAndCurrency(name, query.currency)
     const positions = []
@@ -600,18 +685,24 @@ const getAccounts = async (name, query) => {
         })
       })
     }
+    log.debug('found accounts for participant', { participant, positions })
     return positions
   } catch (err) {
+    log.error('error getting accounts', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const updateAccount = async (payload, params, enums) => {
+  const log = logger.child({ payload, params, enums })
   try {
+    log.debug('updating account')
     const { name, id } = params
     const participant = await ParticipantModel.getByName(name)
+    log.debug('updating account for participant', { participant })
     participantExists(participant)
     const account = await ParticipantCurrencyModel.getById(id)
+    log.debug('updating account for participant', { participant, account })
     if (!account) {
       throw ErrorHandler.Factory.createInternalServerFSPIOPError(AccountNotFoundErrorText)
     } else if (account.participantId !== participant.participantId) {
@@ -621,22 +712,29 @@ const updateAccount = async (payload, params, enums) => {
     }
     return await ParticipantCurrencyModel.update(id, payload.isActive)
   } catch (err) {
+    log.error('error updating account', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getLedgerAccountTypeName = async (name) => {
+  const log = logger.child({ name })
   try {
+    log.debug('getting ledger account type by name')
     return await LedgerAccountTypeModel.getLedgerAccountByName(name)
   } catch (err) {
+    log.error('error getting ledger account type by name', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getParticipantAccount = async (accountParams) => {
+  const log = logger.child({ accountParams })
   try {
+    log.debug('getting participant account by params')
     return await ParticipantCurrencyModel.findOneByParams(accountParams)
   } catch (err) {
+    log.error('error getting participant account by params', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -690,7 +788,9 @@ const setPayerPayeeFundsInOut = (fspName, payload, enums) => {
 }
 
 const recordFundsInOut = async (payload, params, enums) => {
+  const log = logger.child({ payload, params, enums })
   try {
+    log.debug('recording funds in/out')
     const { name, id, transferId } = params
     const participant = await ParticipantModel.getByName(name)
     const currency = (payload.amount && payload.amount.currency) || null
@@ -699,6 +799,7 @@ const recordFundsInOut = async (payload, params, enums) => {
     participantExists(participant, checkIsActive)
     const accounts = await ParticipantFacade.getAllAccountsByNameAndCurrency(name, currency, isAccountActive)
     const accountMatched = accounts[accounts.map(account => account.participantCurrencyId).findIndex(i => i === id)]
+    log.debug('recording funds in/out for participant account', { participant, accountMatched })
     if (!accountMatched) {
       throw ErrorHandler.Factory.createInternalServerFSPIOPError(ParticipantAccountCurrencyMismatchText)
     } else if (!accountMatched.accountIsActive) {
@@ -714,6 +815,7 @@ const recordFundsInOut = async (payload, params, enums) => {
     }
     return await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, KafkaProducer, Enum.Events.Event.Type.ADMIN, Enum.Events.Event.Action.TRANSFER, messageProtocol, Enum.Events.EventStatus.SUCCESS)
   } catch (err) {
+    log.error('error recording funds in/out', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -722,17 +824,21 @@ const validateHubAccounts = async (currency) => {
   const ledgerAccountTypes = await Enums.getEnums('ledgerAccountType')
   const hubReconciliationAccountExists = await ParticipantCurrencyModel.hubAccountExists(currency, ledgerAccountTypes.HUB_RECONCILIATION)
   if (!hubReconciliationAccountExists) {
+    logger.error('Hub reconciliation account for the specified currency does not exist')
     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, 'Hub reconciliation account for the specified currency does not exist')
   }
   const hubMlnsAccountExists = await ParticipantCurrencyModel.hubAccountExists(currency, ledgerAccountTypes.HUB_MULTILATERAL_SETTLEMENT)
   if (!hubMlnsAccountExists) {
+    logger.error('Hub multilateral net settlement account for the specified currency does not exist')
     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, 'Hub multilateral net settlement account for the specified currency does not exist')
   }
   return true
 }
 
 const createAssociatedParticipantAccounts = async (currency, ledgerAccountTypeId, trx) => {
+  const log = logger.child({ currency, ledgerAccountTypeId })
   try {
+    log.info('creating associated participant accounts')
     const nonHubParticipantWithCurrencies = await ParticipantFacade.getAllNonHubParticipantsWithCurrencies(trx)
 
     const participantCurrencies = nonHubParticipantWithCurrencies.map(item => ({
@@ -760,6 +866,7 @@ const createAssociatedParticipantAccounts = async (currency, ledgerAccountTypeId
     }
     await ParticipantPositionModel.createParticipantPositionRecords(participantPositionRecords, trx)
   } catch (err) {
+    log.error('error creating associated participant accounts', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }