@mojaloop/central-ledger 9.2.2 → 15.1.3-snapshot.2

package/src/handlers/admin/handler.js

@@ -52,29 +52,20 @@ const createRecordFundsInOut = async (payload, transactionTimestamp, enums) => {
   /** @namespace Db.getKnex **/
   const knex = Db.getKnex()
 
-  Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry`)
+  Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry`)
   // Save the valid transfer into the database
   if (payload.action === Enum.Events.Event.Action.RECORD_FUNDS_IN) {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry::RECORD_FUNDS_IN`)
-    return knex.transaction(async trx => {
-      try {
-        await TransferService.reconciliationTransferPrepare(payload, transactionTimestamp, enums, trx)
-        await TransferService.reconciliationTransferReserve(payload, transactionTimestamp, enums, trx)
-        await TransferService.reconciliationTransferCommit(payload, transactionTimestamp, enums, trx)
-        await trx.commit
-      } catch (err) {
-        await trx.rollback
-        throw ErrorHandler.Factory.reformatFSPIOPError(err)
-      }
-    })
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry::RECORD_FUNDS_IN`)
+    return await TransferService.recordFundsIn(payload, transactionTimestamp, enums)
   } else {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry::RECORD_FUNDS_OUT_PREPARE_RESERVE`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::newEntry::RECORD_FUNDS_OUT_PREPARE_RESERVE`)
     return knex.transaction(async trx => {
       try {
         await TransferService.reconciliationTransferPrepare(payload, transactionTimestamp, enums, trx)
         await TransferService.reconciliationTransferReserve(payload, transactionTimestamp, enums, trx)
         await trx.commit
       } catch (err) {
+        Logger.isErrorEnabled && Logger.error(err)
         await trx.rollback
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
@@ -86,18 +77,18 @@ const changeStatusOfRecordFundsOut = async (payload, transferId, transactionTime
   const existingTransfer = await TransferService.getTransferById(transferId)
   const transferState = await TransferService.getTransferState(transferId)
   if (!existingTransfer) {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::notFound`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::notFound`)
   } else if (transferState.transferStateId !== Enum.Transfers.TransferState.RESERVED) {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::nonReservedState`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::nonReservedState`)
   } else if (new Date(existingTransfer.expirationDate) <= new Date()) {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::transferExpired`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationFailed::transferExpired`)
   } else {
-    Logger.info(`AdminTransferHandler::${payload.action}::validationPassed`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed`)
     if (payload.action === Enum.Events.Event.Action.RECORD_FUNDS_OUT_COMMIT) {
-      Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::RECORD_FUNDS_OUT_COMMIT`)
+      Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::RECORD_FUNDS_OUT_COMMIT`)
       await TransferService.reconciliationTransferCommit(payload, transactionTimestamp, enums)
     } else if (payload.action === Enum.Events.Event.Action.RECORD_FUNDS_OUT_ABORT) {
-      Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::RECORD_FUNDS_OUT_ABORT`)
+      Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::validationPassed::RECORD_FUNDS_OUT_ABORT`)
       payload.amount = {
         amount: existingTransfer.amount,
         currency: existingTransfer.currencyId
@@ -109,16 +100,16 @@ const changeStatusOfRecordFundsOut = async (payload, transferId, transactionTime
 }
 
 const transferExists = async (payload, transferId) => {
-  Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching`)
+  Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching`)
   const currentTransferState = await TransferService.getTransferStateChange(transferId)
   if (!currentTransferState || !currentTransferState.enumeration) {
-    Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::transfer state not found`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::transfer state not found`)
   } else {
     const transferStateEnum = currentTransferState.enumeration
     if (transferStateEnum === Enum.Transfers.TransferState.COMMITTED || transferStateEnum === Enum.Transfers.TransferInternalState.ABORTED_REJECTED) {
-      Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::request already finalized`)
+      Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::request already finalized`)
     } else if (transferStateEnum === Enum.Transfers.TransferInternalState.RECEIVED_PREPARE || transferStateEnum === Enum.Transfers.TransferState.RESERVED) {
-      Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::previous request still in progress do nothing`)
+      Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsMatching::previous request still in progress do nothing`)
     }
   }
   return true
@@ -126,7 +117,7 @@ const transferExists = async (payload, transferId) => {
 
 const transfer = async (error, messages) => {
   if (error) {
-    Logger.error(error)
+    Logger.isErrorEnabled && Logger.error(error)
     throw ErrorHandler.Factory.reformatFSPIOPError(error)
   }
   let message = {}
@@ -141,7 +132,7 @@ const transfer = async (error, messages) => {
     const transferId = message.value.id
 
     if (!payload) {
-      Logger.info('AdminTransferHandler::validationFailed')
+      Logger.isInfoEnabled && Logger.info('AdminTransferHandler::validationFailed')
       // TODO: Cannot be saved because no payload has been provided. What action should be taken?
       return false
     }
@@ -149,21 +140,21 @@ const transfer = async (error, messages) => {
     payload.participantCurrencyId = metadata.request.params.id
     const enums = metadata.request.enums
     const transactionTimestamp = Time.getUTCString(new Date())
-    Logger.info(`AdminTransferHandler::${metadata.event.action}::${transferId}`)
+    Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${metadata.event.action}::${transferId}`)
     const kafkaTopic = message.topic
 
     if (!allowedActions.includes(payload.action)) {
-      Logger.info(`AdminTransferHandler::${payload.action}::invalidPayloadAction`)
+      Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::invalidPayloadAction`)
     }
     if (httpPostRelatedActions.includes(payload.action)) {
       const { hasDuplicateId, hasDuplicateHash } = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferDuplicateCheck, TransferService.saveTransferDuplicateCheck)
       if (!hasDuplicateId) {
-        Logger.info(`AdminTransferHandler::${payload.action}::transfer does not exist`)
+        Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::transfer does not exist`)
         await createRecordFundsInOut(payload, transactionTimestamp, enums)
       } else if (hasDuplicateHash) {
         await transferExists(payload, transferId)
       } else {
-        Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsNotMatching::request exists with different parameters`)
+        Logger.isInfoEnabled && Logger.info(`AdminTransferHandler::${payload.action}::dupcheck::existsNotMatching::request exists with different parameters`)
       }
     } else {
       await changeStatusOfRecordFundsOut(payload, transferId, transactionTimestamp, enums)
@@ -171,7 +162,7 @@ const transfer = async (error, messages) => {
     await Kafka.commitMessageSync(Consumer, kafkaTopic, message)
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -195,7 +186,7 @@ const registerTransferHandler = async () => {
     await Consumer.createHandler(transferHandler.topicName, transferHandler.config, transferHandler.command)
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -213,6 +204,7 @@ const registerAllHandlers = async () => {
     await registerTransferHandler()
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }

package/src/handlers/bulk/fulfil/handler.js

@@ -29,7 +29,6 @@
  ******/
 'use strict'
 
-const AwaitifyStream = require('awaitify-stream')
 const Logger = require('@mojaloop/central-services-logger')
 const BulkTransferService = require('../../../domain/bulkTransfer')
 const Util = require('@mojaloop/central-services-shared').Util
@@ -40,7 +39,7 @@ const Validator = require('../shared/validator')
 const Enum = require('@mojaloop/central-services-shared').Enum
 const Metrics = require('@mojaloop/central-services-metrics')
 const Config = require('../../../lib/config')
-const BulkTransferModels = require('@mojaloop/central-object-store').Models.BulkTransfer
+const BulkTransferModels = require('@mojaloop/object-store-lib').Models.BulkTransfer
 const encodePayload = require('@mojaloop/central-services-shared').Util.StreamingProtocol.encodePayload
 const Comparators = require('@mojaloop/central-services-shared').Util.Comparators
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
@@ -75,6 +74,7 @@ const bulkFulfil = async (error, messages) => {
     ['success', 'fspId']
   ).startTimer()
   if (error) {
+    Logger.isErrorEnabled && Logger.error(error)
     throw error
   }
   let message = {}
@@ -90,20 +90,24 @@ const bulkFulfil = async (error, messages) => {
     const action = message.value.metadata.event.action
     const bulkTransferId = payload.bulkTransferId
     const kafkaTopic = message.topic
-    Logger.info(Util.breadcrumb(location, { method: 'bulkFulfil' }))
-    const actionLetter = action === Enum.Events.Event.Action.BULK_COMMIT ? Enum.Events.ActionLetter.bulkCommit : Enum.Events.ActionLetter.unknown
-    let params = { message, kafkaTopic, decodedPayload: payload, consumer: Consumer, producer: Producer }
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: 'bulkFulfil' }))
+    const actionLetter = action === Enum.Events.Event.Action.BULK_COMMIT
+      ? Enum.Events.ActionLetter.bulkCommit
+      : (action === Enum.Events.Event.Action.BULK_ABORT
+          ? Enum.Events.ActionLetter.bulkAbort
+          : Enum.Events.ActionLetter.unknown)
+    const params = { message, kafkaTopic, decodedPayload: payload, consumer: Consumer, producer: Producer }
 
-    Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
 
     const { hasDuplicateId, hasDuplicateHash } = await Comparators.duplicateCheckComparator(bulkTransferId, payload.hash, BulkTransferService.getBulkTransferFulfilmentDuplicateCheck, BulkTransferService.saveBulkTransferFulfilmentDuplicateCheck)
     if (hasDuplicateId && hasDuplicateHash) { // TODO: handle resend :: GET /bulkTransfer
-      Logger.info(Util.breadcrumb(location, `resend--${actionLetter}1`))
-      Logger.error(Util.breadcrumb(location, 'notImplemented'))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `resend--${actionLetter}1`))
+      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
       return true
     }
     if (hasDuplicateId && !hasDuplicateHash) {
-      Logger.error(Util.breadcrumb(location, `callbackErrorModified--${actionLetter}2`))
+      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, `callbackErrorModified--${actionLetter}2`))
       const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST)
       const eventDetail = { functionality: Enum.Events.Event.Type.NOTIFICATION, action }
       await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
@@ -114,82 +118,111 @@ const bulkFulfil = async (error, messages) => {
     const { isValid, reasons } = await Validator.validateBulkTransferFulfilment(payload, headers)
     if (isValid) {
       let state
-      Logger.info(Util.breadcrumb(location, { path: 'isValid' }))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'isValid' }))
       try {
-        Logger.info(Util.breadcrumb(location, 'saveBulkTransfer'))
-        state = await BulkTransferService.bulkFulfil(payload)
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveBulkTransfer'))
+        if (payload.errorInformation) {
+          state = await BulkTransferService.bulkFulfilError(payload, payload.errorInformation.errorDescription)
+        } else {
+          state = await BulkTransferService.bulkFulfil(payload)
+        }
       } catch (err) { // TODO: handle insert errors
-        Logger.info(Util.breadcrumb(location, `callbackErrorInternal1--${actionLetter}5`))
-        Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInternal1--${actionLetter}5`))
+        Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isErrorEnabled && Logger.error(err)
         return true
       }
       try {
-        Logger.info(Util.breadcrumb(location, 'individualTransferFulfils'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'individualTransferFulfils'))
         // stream initialization
-        const IndividualTransferFulfilModel = BulkTransferModels.getIndividualTransferFulfilModel()
-        const indvidualTransfersFulfilStream = IndividualTransferFulfilModel.find({ messageId }).cursor()
-        // enable async/await operations for the stream
-        const streamReader = AwaitifyStream.createReader(indvidualTransfersFulfilStream)
-        let doc
-        while ((doc = await streamReader.readAsync()) !== null) {
-          const individualTransferFulfil = doc.payload
-          const transferId = individualTransferFulfil.transferId
-          delete individualTransferFulfil.transferId
-          const bulkTransferAssociationRecord = {
-            transferId,
-            bulkTransferId: payload.bulkTransferId,
-            bulkProcessingStateId: Enum.Transfers.BulkProcessingState.PROCESSING
-          }
-          await BulkTransferService.bulkTransferAssociationUpdate(transferId, bulkTransferId, bulkTransferAssociationRecord)
-          if (state === Enum.Transfers.BulkTransferState.INVALID ||
-            individualTransferFulfil.errorInformation ||
-            !individualTransferFulfil.fulfilment) {
-            individualTransferFulfil.transferState = Enum.Transfers.TransferState.ABORTED
-          } else {
-            individualTransferFulfil.transferState = Enum.Transfers.TransferState.COMMITTED
+        if (payload.errorInformation) {
+          const bulkTransfers = await BulkTransferService.getBulkTransferById(payload.bulkTransferId)
+          for (const individualTransferFulfil of bulkTransfers.payeeBulkTransfer.individualTransferResults) {
+            individualTransferFulfil.errorInformation = payload.errorInformation
+            await sendIndividualTransfer(message, messageId, kafkaTopic, headers, payload, state, params, individualTransferFulfil, histTimerEnd)
           }
-          const dataUri = encodePayload(JSON.stringify(individualTransferFulfil), headers[Enum.Http.Headers.GENERAL.CONTENT_TYPE.value])
-          const metadata = Util.StreamingProtocol.createMetadataWithCorrelatedEventState(message.value.metadata.event.id, Enum.Events.Event.Type.FULFIL, Enum.Events.Event.Action.COMMIT, Enum.Events.EventStatus.SUCCESS.status, Enum.Events.EventStatus.SUCCESS.code, Enum.Events.EventStatus.SUCCESS.description) // TODO: switch action to 'bulk-fulfil' flow
-          const msg = {
-            value: Util.StreamingProtocol.createMessage(messageId, headers[Enum.Http.Headers.FSPIOP.DESTINATION], headers[Enum.Http.Headers.FSPIOP.SOURCE], metadata, headers, dataUri, { id: transferId })
+        } else {
+          const IndividualTransferFulfilModel = BulkTransferModels.getIndividualTransferFulfilModel()
+
+          // enable async/await operations for the stream
+          for await (const doc of IndividualTransferFulfilModel.find({ messageId }).cursor()) {
+            await sendIndividualTransfer(message, messageId, kafkaTopic, headers, payload, state, params, doc.payload, histTimerEnd)
           }
-          params = { message: msg, kafkaTopic, consumer: Consumer, producer: Producer }
-          const eventDetail = { functionality: Enum.Events.Event.Type.FULFIL, action: Enum.Events.Event.Action.BULK_COMMIT }
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd, eventDetail })
-          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
         }
       } catch (err) { // TODO: handle individual transfers streaming error
-        Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}6`))
-        Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}6`))
+        Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isErrorEnabled && Logger.error(err)
         return true
       }
     } else { // TODO: handle validation failure
-      Logger.error(Util.breadcrumb(location, { path: 'validationFailed' }))
+      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, { path: 'validationFailed' }))
+      Logger.isErrorEnabled && Logger.error(`validationFailure Reasons - ${JSON.stringify(reasons)}`)
       try {
-        Logger.info(Util.breadcrumb(location, 'saveInvalidRequest'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveInvalidRequest'))
         /**
-         * TODO: Following the example for regular transfers, the folloing should ABORT the
+         * TODO: Following the example for regular transfers, the following should ABORT the
          * entire bulk. CAUTION: As of 20191111 this code would also execute when failure
          * reason is "FSPIOP-Source header should match Payee". In this case we should not
          * abort the bulk as we would have accepted non-legitimate source.
          */
         await BulkTransferService.bulkFulfil(payload, reasons.toString(), false)
       } catch (err) { // TODO: handle insert error
-        Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}7`))
-        Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}7`))
+        Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
+        Logger.isErrorEnabled && Logger.error(err)
         return true
       }
-      Logger.info(Util.breadcrumb(location, `callbackErrorGeneric--${actionLetter}8`))
-      Logger.error(Util.breadcrumb(location, 'notImplemented'))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorGeneric--${actionLetter}8`))
+      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
       return true // TODO: store invalid bulk transfer to database and produce callback notification to payer
     }
   } catch (err) {
-    Logger.error(`${Util.breadcrumb(location)}::${err.message}--BP0`)
+    Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}--BP0`)
+    Logger.isErrorEnabled && Logger.error(err)
     histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     throw err
   }
 }
 
+/**
+ * @function sendIndividualTransfer
+ *
+ * @async
+ * @description sends individual transfers to the fulfil handler
+ */
+const sendIndividualTransfer = async (message, messageId, kafkaTopic, headers, payload, state, params, individualTransferFulfil, histTimerEnd) => {
+  const transferId = individualTransferFulfil.transferId
+  delete individualTransferFulfil.transferId
+  const bulkTransferAssociationRecord = {
+    transferId,
+    bulkTransferId: payload.bulkTransferId,
+    bulkProcessingStateId: Enum.Transfers.BulkProcessingState.PROCESSING,
+    errorCode: payload.errorInformation ? payload.errorInformation.errorCode : undefined,
+    errorDescription: payload.errorInformation ? payload.errorInformation.errorDescription : undefined
+  }
+  await BulkTransferService.bulkTransferAssociationUpdate(transferId, payload.bulkTransferId, bulkTransferAssociationRecord)
+
+  let eventDetail
+  if (state === Enum.Transfers.BulkTransferState.INVALID ||
+    individualTransferFulfil.errorInformation ||
+    !individualTransferFulfil.fulfilment) {
+    individualTransferFulfil.transferState = Enum.Transfers.TransferState.ABORTED
+    eventDetail = { functionality: Enum.Events.Event.Type.FULFIL, action: Enum.Events.Event.Action.BULK_ABORT }
+  } else {
+    individualTransferFulfil.transferState = Enum.Transfers.TransferState.COMMITTED
+    eventDetail = { functionality: Enum.Events.Event.Type.FULFIL, action: Enum.Events.Event.Action.BULK_COMMIT }
+  }
+  const dataUri = encodePayload(JSON.stringify(individualTransferFulfil), headers[Enum.Http.Headers.GENERAL.CONTENT_TYPE.value])
+  const metadata = Util.StreamingProtocol.createMetadataWithCorrelatedEventState(message.value.metadata.event.id, Enum.Events.Event.Type.FULFIL, Enum.Events.Event.Action.COMMIT, Enum.Events.EventStatus.SUCCESS.status, Enum.Events.EventStatus.SUCCESS.code, Enum.Events.EventStatus.SUCCESS.description) // TODO: switch action to 'bulk-fulfil' flow
+  const msg = {
+    value: Util.StreamingProtocol.createMessage(messageId, headers[Enum.Http.Headers.FSPIOP.DESTINATION], headers[Enum.Http.Headers.FSPIOP.SOURCE], metadata, headers, dataUri, { id: transferId })
+  }
+  params = { message: msg, kafkaTopic, consumer: Consumer, producer: Producer }
+  await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd, eventDetail })
+  histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+}
+
 /**
  * @function registerBulkFulfilHandler
  *
@@ -209,7 +242,7 @@ const registerBulkFulfilHandler = async () => {
     await Consumer.createHandler(bulkFulfilHandler.topicName, bulkFulfilHandler.config, bulkFulfilHandler.command)
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -227,7 +260,7 @@ const registerAllHandlers = async () => {
     await registerBulkFulfilHandler()
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/handlers/bulk/get/handler.js

@@ -0,0 +1,203 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Gates Foundation organization for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ * ModusBox
+ - Steven Oderayi <steven.oderayi@modusbox.com>
+ --------------
+ ******/
+'use strict'
+
+const Logger = require('@mojaloop/central-services-logger')
+const EventSdk = require('@mojaloop/event-sdk')
+const Util = require('@mojaloop/central-services-shared').Util
+const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
+const Producer = require('@mojaloop/central-services-stream').Util.Producer
+const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
+const Enum = require('@mojaloop/central-services-shared').Enum
+const Metrics = require('@mojaloop/central-services-metrics')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const BulkTransferService = require('../../../domain/bulkTransfer')
+const BulkTransferModel = require('../../../models/bulkTransfer/bulkTransfer')
+const Validator = require('../shared/validator')
+const Config = require('../../../lib/config')
+const { ERROR_HANDLING } = require('../../../lib/config')
+
+const location = { module: 'BulkGetHandler', method: '', path: '' }
+const consumerCommit = true
+const fromSwitch = true
+
+/**
+ * @function BulkGetHandler
+ *
+ * @async
+ * @description Gets a bulk transfer by id. Gets Kafka config from default.json
+ *
+ * Calls createHandler to register the handler against the Stream Processing API.
+ *
+ * @param {error} error - error thrown if something fails within Kafka
+ * @param {array} messages - a list of messages to consume for the relevant topic
+ *
+ * @returns {object} - Returns a boolean: true if successful, or throws an error if failed
+ */
+const getBulkTransfer = async (error, messages) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'bulk_transfer_get',
+    'Consume a get bulk transfer message from the kafka topic and process it accordingly',
+    ['success', 'fspId']
+  ).startTimer()
+  if (error) {
+    throw ErrorHandler.Factory.reformatFSPIOPError(error)
+  }
+  const message = Array.isArray(messages) ? messages[0] : messages
+  const contextFromMessage = EventSdk.Tracer.extractContextFromMessage(message.value)
+  const span = EventSdk.Tracer.createChildSpanFromContext('cl_bulk_transfer_get', contextFromMessage)
+  try {
+    await span.audit(message, EventSdk.AuditEventAction.start)
+    const metadata = message.value.metadata
+    const action = metadata.event.action
+    const bulkTransferId = message.value.content.uriParams.id
+    const kafkaTopic = message.topic
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: `getBulkTransfer:${action}` }))
+
+    const actionLetter = Enum.Events.ActionLetter.get
+    const params = { message, kafkaTopic, span, consumer: Consumer, producer: Producer }
+    const eventDetail = { functionality: Enum.Events.Event.Type.NOTIFICATION, action: Enum.Events.Event.Action.BULK_GET }
+
+    Util.breadcrumb(location, { path: 'validationFailed' })
+
+    if (!(await Validator.validateParticipantByName(message.value.from)).isValid) {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `breakParticipantDoesntExist--${actionLetter}1`))
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd })
+      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      return true
+    }
+    // TODO: Validate this. Is this sufficient for checking existence of bulk transfer?
+    const bulkTransferLight = await BulkTransferModel.getById(bulkTransferId)
+    if (!bulkTransferLight) {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorBulkTransferNotFound--${actionLetter}3`))
+      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.BULK_TRANSFER_ID_NOT_FOUND, 'Provided Bulk Transfer ID was not found on the server.')
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+      throw fspiopError
+    }
+    // The SD says this should be 404 response which I think will not be constent with single transfers
+    // which responds with CLIENT_ERROR instead
+    const participants = await BulkTransferService.getParticipantsById(bulkTransferId)
+    if (![participants.payeeFsp, participants.payerFsp].includes(message.value.from)) {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNotBulkTransferParticipant--${actionLetter}2`))
+      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR)
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+      throw fspiopError
+    }
+    const isPayeeRequest = participants.payeeFsp === message.value.from
+    Util.breadcrumb(location, { path: 'validationPassed' })
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackMessage--${actionLetter}4`))
+    const bulkTransferResult = await BulkTransferService.getBulkTransferById(bulkTransferId)
+    const bulkTransfer = isPayeeRequest ? bulkTransferResult.payeeBulkTransfer : bulkTransferResult.payerBulkTransfer
+    let payload = {
+      bulkTransferState: bulkTransfer.bulkTransferState
+    }
+    let fspiopError
+    if (bulkTransfer.bulkTransferState === Enum.Transfers.BulkTransferState.REJECTED) {
+      payload = {
+        errorInformation: bulkTransfer.individualTransferResults[0].errorInformation
+      }
+      fspiopError = ErrorHandler.Factory.createFSPIOPErrorFromErrorInformation(payload.errorInformation)
+    } else if (bulkTransfer.bulkTransferState !== Enum.Transfers.BulkTransferState.PROCESSING) {
+      payload = {
+        ...payload,
+        completedTimestamp: bulkTransfer.completedTimestamp,
+        individualTransferResults: bulkTransfer.individualTransferResults,
+        extensionList: bulkTransfer.extensionList
+      }
+    }
+    message.value.content.payload = payload
+    if (fspiopError) {
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(ERROR_HANDLING), eventDetail, fromSwitch })
+    } else {
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
+    }
+    histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    return true
+  } catch (err) {
+    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
+    Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}--G0`)
+    const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+    await span.error(fspiopError, state)
+    await span.finish(fspiopError.message, state)
+    return true
+  } finally {
+    if (!span.isFinished) {
+      await span.finish()
+    }
+  }
+}
+
+/**
+ * @function registerBulkFulfilHandler
+ *
+ * @async
+ * @description Registers the handler for bulk-transfer topic. Gets Kafka config from default.json
+ *
+ * @returns {boolean} - Returns a boolean: true if successful, or throws and error if failed
+ */
+const registerGetBulkTransferHandler = async () => {
+  try {
+    const bulkGetHandler = {
+      command: getBulkTransfer,
+      topicName: Kafka.transformGeneralTopicName(Config.KAFKA_CONFIG.TOPIC_TEMPLATES.GENERAL_TOPIC_TEMPLATE.TEMPLATE, Enum.Events.Event.Type.BULK, Enum.Events.Event.Action.GET),
+      config: Kafka.getKafkaConfig(Config.KAFKA_CONFIG, Enum.Kafka.Config.CONSUMER, Enum.Events.Event.Type.BULK.toUpperCase(), Enum.Events.Event.Action.GET.toUpperCase())
+    }
+    bulkGetHandler.config.rdkafkaConf['client.id'] = bulkGetHandler.topicName
+    await Consumer.createHandler(bulkGetHandler.topicName, bulkGetHandler.config, bulkGetHandler.command)
+    return true
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
+/**
+ * @function RegisterAllHandlers
+ *
+ * @async
+ * @description Registers all module handlers
+ *
+ * @returns {boolean} - Returns a boolean: true if successful, or throws and error if failed
+ */
+const registerAllHandlers = async () => {
+  try {
+    await registerGetBulkTransferHandler()
+    return true
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
+module.exports = {
+  getBulkTransfer,
+  registerGetBulkTransferHandler,
+  registerAllHandlers
+}

package/src/handlers/bulk/index.js

@@ -34,6 +34,7 @@
 const BulkPrepareHandlers = require('./prepare/handler')
 const BulkFulfilHandlers = require('./fulfil/handler')
 const BulkProcessingHandlers = require('./processing/handler')
+const GetBulkTransferHandlers = require('./get/handler')
 const Logger = require('@mojaloop/central-services-logger')
 
 /**
@@ -49,9 +50,10 @@ const registerAllHandlers = async () => {
     await BulkPrepareHandlers.registerAllHandlers()
     await BulkFulfilHandlers.registerAllHandlers()
     await BulkProcessingHandlers.registerAllHandlers()
+    await GetBulkTransferHandlers.registerAllHandlers()
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -60,5 +62,6 @@ module.exports = {
   registerBulkPrepareHandler: BulkPrepareHandlers.registerBulkPrepareHandler,
   registerBulkFulfilHandler: BulkFulfilHandlers.registerBulkFulfilHandler,
   registerBulkProcessingHandler: BulkProcessingHandlers.registerBulkProcessingHandler,
+  registerGetBulkTransferHandler: GetBulkTransferHandlers.registerGetBulkTransferHandler,
   registerAllHandlers
 }