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

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

@@ -30,7 +30,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
@@ -41,7 +40,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')
@@ -97,21 +96,21 @@ const bulkPrepare = async (error, messages) => {
     const action = message.value.metadata.event.action
     const bulkTransferId = payload.bulkTransferId
     const kafkaTopic = message.topic
-    Logger.info(Util.breadcrumb(location, { method: 'bulkPrepare' }))
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: 'bulkPrepare' }))
 
     const actionLetter = action === Enum.Events.Event.Action.BULK_PREPARE ? Enum.Events.ActionLetter.bulkPrepare : Enum.Events.ActionLetter.unknown
     let 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, BulkTransferService.getBulkTransferDuplicateCheck, BulkTransferService.saveBulkTransferDuplicateCheck)
     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) { // TODO: handle modified request
-      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 }
       params.message.value.content.uriParams = { id: bulkTransferId }
@@ -121,26 +120,24 @@ const bulkPrepare = async (error, messages) => {
 
     const { isValid, reasons, payerParticipantId, payeeParticipantId } = await Validator.validateBulkTransfer(payload, headers)
     if (isValid) {
-      Logger.info(Util.breadcrumb(location, { path: 'isValid' }))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'isValid' }))
       try {
-        Logger.info(Util.breadcrumb(location, 'saveBulkTransfer'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveBulkTransfer'))
         const participants = { payerParticipantId, payeeParticipantId }
         await BulkTransferService.bulkPrepare(payload, participants)
       } catch (err) { // TODO: handle insert error
-        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, 'individualTransfers'))
-        // stream initialization
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'individualTransfers'))
+
         const IndividualTransferModel = BulkTransferModels.getIndividualTransferModel()
-        const indvidualTransfersStream = IndividualTransferModel.find({ messageId }).cursor()
-        // enable async/await operations for the stream
-        const streamReader = AwaitifyStream.createReader(indvidualTransfersStream)
-        let doc
 
-        while ((doc = await streamReader.readAsync()) !== null) {
+        // for loop on a stream cursor
+        for await (const doc of IndividualTransferModel.find({ messageId }).cursor()) {
           const individualTransfer = doc.payload
           individualTransfer.payerFsp = payload.payerFsp
           individualTransfer.payeeFsp = payload.payeeFsp
@@ -164,26 +161,30 @@ const bulkPrepare = async (error, messages) => {
           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'))
         await BulkTransferService.bulkPrepare(payload, { payerParticipantId, payeeParticipantId }, 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
   }
@@ -208,7 +209,7 @@ const registerBulkPrepareHandler = async () => {
     await Consumer.createHandler(bulkPrepareHandler.topicName, bulkPrepareHandler.config, bulkPrepareHandler.command)
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -226,7 +227,7 @@ const registerAllHandlers = async () => {
     await registerBulkPrepareHandler()
     return true
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

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

@@ -39,7 +39,7 @@ const Enum = require('@mojaloop/central-services-shared').Enum
 const Metrics = require('@mojaloop/central-services-metrics')
 const Config = require('../../../lib/config')
 const decodePayload = require('@mojaloop/central-services-shared').Util.StreamingProtocol.decodePayload
-const BulkTransferModels = require('@mojaloop/central-object-store').Models.BulkTransfer
+const BulkTransferModels = require('@mojaloop/object-store-lib').Models.BulkTransfer
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const location = { module: 'BulkProcessingHandler', method: '', path: '' } // var object used as pointer
@@ -72,7 +72,7 @@ const bulkProcessing = async (error, messages) => {
     ['success', 'fspId']
   ).startTimer()
   if (error) {
-    // Logger.error(error)
+    // Logger.isErrorEnabled && Logger.error(error)
     throw error
   }
   let message = {}
@@ -89,15 +89,23 @@ const bulkProcessing = async (error, messages) => {
     const state = message.value.metadata.event.state
     const transferId = payload.transferId || (message.value.content.uriParams && message.value.content.uriParams.id)
     const kafkaTopic = message.topic
-    Logger.info(Util.breadcrumb(location, { method: 'bulkProcessing' }))
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: 'bulkProcessing' }))
 
-    const actionLetter = action === Enum.Events.Event.Action.BULK_PREPARE ? Enum.Events.ActionLetter.bulkPrepare
-      : (action === Enum.Events.Event.Action.BULK_COMMIT ? Enum.Events.ActionLetter.bulkCommit
-        : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED ? Enum.Events.ActionLetter.bulkTimeoutReceived
-          : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED ? Enum.Events.ActionLetter.bulkTimeoutReserved
-            : (action === Enum.Events.Event.Action.PREPARE_DUPLICATE ? Enum.Events.ActionLetter.bulkPrepareDuplicate
-              : (action === Enum.Events.Event.Action.FULFIL_DUPLICATE ? Enum.Events.ActionLetter.bulkFulfilDuplicate
-                : Enum.Events.ActionLetter.unknown)))))
+    const actionLetter = action === Enum.Events.Event.Action.BULK_PREPARE
+      ? Enum.Events.ActionLetter.bulkPrepare
+      : (action === Enum.Events.Event.Action.BULK_COMMIT
+          ? Enum.Events.ActionLetter.bulkCommit
+          : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED
+              ? Enum.Events.ActionLetter.bulkTimeoutReceived
+              : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED
+                  ? Enum.Events.ActionLetter.bulkTimeoutReserved
+                  : (action === Enum.Events.Event.Action.PREPARE_DUPLICATE
+                      ? Enum.Events.ActionLetter.bulkPrepareDuplicate
+                      : (action === Enum.Events.Event.Action.FULFIL_DUPLICATE
+                          ? Enum.Events.ActionLetter.bulkFulfilDuplicate
+                          : (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 }
     const eventDetail = { functionality: Enum.Events.Event.Type.NOTIFICATION, action }
 
@@ -175,6 +183,12 @@ const bulkProcessing = async (error, messages) => {
         processingStateId = Enum.Transfers.BulkProcessingState.EXPIRED
         errorCode = payload.errorInformation && payload.errorInformation.errorCode
         errorDescription = payload.errorInformation && payload.errorInformation.errorDescription
+      } else if (action === Enum.Events.Event.Action.BULK_ABORT) {
+        // TODO: Need to validate `state.status`
+        processingStateId = Enum.Transfers.BulkProcessingState.REJECTED
+        completedBulkState = Enum.Transfers.BulkTransferState.REJECTED
+        errorCode = payload.errorInformation && payload.errorInformation.errorCode
+        errorDescription = payload.errorInformation && payload.errorInformation.errorDescription
       } else {
         const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, `Invalid action for bulk in ${Enum.Transfers.BulkTransferState.PROCESSING} state`)
         throw fspiopError
@@ -233,23 +247,24 @@ const bulkProcessing = async (error, messages) => {
     if (bulkTransferState !== bulkTransferInfo.bulkTransferStateId) {
       await BulkTransferService.createBulkTransferState({
         bulkTransferId: bulkTransferInfo.bulkTransferId,
-        bulkTransferStateId: bulkTransferState
+        bulkTransferStateId: bulkTransferState,
+        reason: errorDescription || null
       })
     }
 
     let getBulkTransferByIdResult
     if (produceNotification) {
-      Logger.info(Util.breadcrumb(location, { path: 'produceNotification' }))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'produceNotification' }))
       getBulkTransferByIdResult = await BulkTransferService.getBulkTransferById(bulkTransferInfo.bulkTransferId)
     } else {
-      Logger.info(Util.breadcrumb(location, { path: 'awaitAllTransfers' }))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'awaitAllTransfers' }))
       criteriaState = null // debugging breakpoint line
       return true
     }
 
     if (produceNotification) {
       if (eventType === Enum.Events.Event.Type.BULK_PROCESSING && action === Enum.Events.Event.Action.BULK_PREPARE) {
-        Logger.info(Util.breadcrumb(location, `bulkPrepare--${actionLetter}2`))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `bulkPrepare--${actionLetter}2`))
         const payeeBulkResponse = Object.assign({}, { messageId: message.value.id, headers }, getBulkTransferByIdResult.payeeBulkTransfer)
         const payeeIndividualTransfers = payeeBulkResponse.individualTransferResults.filter(individualTransfer => {
           return !individualTransfer.errorInformation
@@ -275,12 +290,12 @@ const bulkProcessing = async (error, messages) => {
           // TODO: handle use case when no individual transfer has been accepted:
           // Switch to finilize bulk state and notify payer with PUT /bulkTransfers/{id}
           // const payerBulkResponse = Object.assign({}, { messageId: message.value.id, headers }, getBulkTransferByIdResult.payerBulkTransfer)
-          Logger.info(Util.breadcrumb(location, `noTransfers--${actionLetter}1`))
-          Logger.error(Util.breadcrumb(location, 'notImplemented'))
+          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `noTransfers--${actionLetter}1`))
+          Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, 'notImplemented'))
           return true
         }
-      } else if (eventType === Enum.Events.Event.Type.BULK_PROCESSING && [Enum.Events.Event.Action.BULK_COMMIT, Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED].includes(action)) {
-        Logger.info(Util.breadcrumb(location, `bulkFulfil--${actionLetter}3`))
+      } else if (eventType === Enum.Events.Event.Type.BULK_PROCESSING && [Enum.Events.Event.Action.BULK_COMMIT, Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED, Enum.Events.Event.Action.BULK_ABORT].includes(action)) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `bulkFulfil--${actionLetter}3`))
         const participants = await BulkTransferService.getParticipantsById(bulkTransferInfo.bulkTransferId)
         const normalizedKeys = Object.keys(headers).reduce((keys, k) => { keys[k.toLowerCase()] = k; return keys }, {})
         const payeeBulkResponseHeaders = Util.Headers.transformHeaders(headers, { httpMethod: headers[normalizedKeys[Enum.Http.Headers.FSPIOP.HTTP_METHOD]], sourceFsp: Enum.Http.Headers.FSPIOP.SWITCH.value, destinationFsp: participants.payeeFsp })
@@ -292,25 +307,36 @@ const bulkProcessing = async (error, messages) => {
         await (new BulkTransferResultModel(payeeBulkResponse)).save()
         const payerParams = Util.clone(params)
         const payeeParams = Util.clone(params)
+        let payerPayload
+        let payeePayload
+
+        if (action === Enum.Events.Event.Action.BULK_ABORT && params.decodedPayload.errorInformation) {
+          payerPayload = { bulkTransferId: payerBulkResponse.bulkTransferId, errorInformation: params.decodedPayload.errorInformation }
+          payeePayload = { bulkTransferId: payeeBulkResponse.bulkTransferId, errorInformation: params.decodedPayload.errorInformation }
+        } else {
+          payerPayload = Util.omitNil({
+            bulkTransferId: payerBulkResponse.bulkTransferId,
+            bulkTransferState: payerBulkResponse.bulkTransferState,
+            completedTimestamp: payerBulkResponse.completedTimestamp,
+            extensionList: payerBulkResponse.extensionList
+          })
+          payeePayload = Util.omitNil({
+            bulkTransferId: payeeBulkResponse.bulkTransferId,
+            bulkTransferState: payeeBulkResponse.bulkTransferState,
+            completedTimestamp: payeeBulkResponse.completedTimestamp,
+            extensionList: payeeBulkResponse.extensionList
+          })
+        }
 
-        const payerPayload = Util.omitNil({
-          bulkTransferId: payerBulkResponse.bulkTransferId,
-          bulkTransferState: payerBulkResponse.bulkTransferState,
-          completedTimestamp: payerBulkResponse.completedTimestamp,
-          extensionList: payerBulkResponse.extensionList
-        })
         const payerMetadata = Util.StreamingProtocol.createMetadataWithCorrelatedEvent(params.message.value.metadata.event.id, payerParams.message.value.metadata.type, payerParams.message.value.metadata.action, Enum.Events.EventStatus.SUCCESS)
         payerParams.message.value = Util.StreamingProtocol.createMessage(params.message.value.id, participants.payerFsp, payerBulkResponse.headers[normalizedKeys[Enum.Http.Headers.FSPIOP.SOURCE]], payerMetadata, payerBulkResponse.headers, payerPayload)
-        const payeePayload = Util.omitNil({
-          bulkTransferId: payeeBulkResponse.bulkTransferId,
-          bulkTransferState: payeeBulkResponse.bulkTransferState,
-          completedTimestamp: payeeBulkResponse.completedTimestamp,
-          extensionList: payeeBulkResponse.extensionList
-        })
+
         const payeeMetadata = Util.StreamingProtocol.createMetadataWithCorrelatedEvent(params.message.value.metadata.event.id, payeeParams.message.value.metadata.type, payeeParams.message.value.metadata.action, Enum.Events.EventStatus.SUCCESS)
         payeeParams.message.value = Util.StreamingProtocol.createMessage(params.message.value.id, participants.payeeFsp, Enum.Http.Headers.FSPIOP.SWITCH.value, payeeMetadata, payeeBulkResponse.headers, payeePayload)
         if ([Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED].includes(action)) {
           eventDetail.action = Enum.Events.Event.Action.BULK_COMMIT
+        } else if ([Enum.Events.Event.Action.BULK_ABORT].includes(action)) {
+          eventDetail.action = Enum.Events.Event.Action.BULK_ABORT
         }
         await Kafka.proceed(Config.KAFKA_CONFIG, payerParams, { consumerCommit, eventDetail })
         histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
@@ -326,7 +352,7 @@ const bulkProcessing = async (error, messages) => {
       } else {
         // TODO: For the following (Internal Server Error) scenario a notification is produced for each individual transfer.
         // It also needs to be processed first in order to accumulate transfers and send the callback notification at bulk level.
-        Logger.info(Util.breadcrumb(location, `invalidEventTypeOrAction--${actionLetter}4`))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `invalidEventTypeOrAction--${actionLetter}4`))
         const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event action:(${action}) and/or type:(${eventType})`).toApiErrorObject(Config.ERROR_HANDLING)
         const eventDetail = { functionality: Enum.Events.Event.Type.NOTIFICATION, action: Enum.Events.Event.Action.BULK_PROCESSING }
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError, eventDetail, fromSwitch })
@@ -335,7 +361,8 @@ const bulkProcessing = async (error, messages) => {
       }
     }
   } 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 ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -360,6 +387,7 @@ const registerBulkProcessingHandler = async () => {
     await Consumer.createHandler(bulkProcessingHandler.topicName, bulkProcessingHandler.config, bulkProcessingHandler.command)
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -377,6 +405,7 @@ const registerAllHandlers = async () => {
     await registerBulkProcessingHandler()
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }

package/src/handlers/bulk/shared/validator.js

@@ -25,6 +25,7 @@
  * ModusBox
  - Georgi Georgiev <georgi.georgiev@modusbox.com>
  - Rajiv Mothilal <rajiv.mothilal@modusbox.com>
+ - Steven Oderayi <steven.oderayi@modusbox.com>
  --------------
  ******/
 'use strict'
@@ -130,7 +131,18 @@ const validateBulkTransferFulfilment = async (payload, headers) => {
   return { isValid, reasons }
 }
 
+const validateParticipantBulkTransferId = async function (participantName, bulkTransferId) {
+  const bulkTransferParticipant = await BulkTransferService.getBulkTransferParticipant(participantName, bulkTransferId)
+  let validationPassed = false
+  if (Array.isArray(bulkTransferParticipant) && bulkTransferParticipant.length > 0) {
+    validationPassed = true
+  }
+  return validationPassed
+}
+
 module.exports = {
   validateBulkTransfer,
-  validateBulkTransferFulfilment
+  validateBulkTransferFulfilment,
+  validateParticipantByName,
+  validateParticipantBulkTransferId
 }

package/src/handlers/index.js

@@ -59,13 +59,14 @@ Program.command('handler') // sub-command name, coffeeType = type, required
   .option('--bulkprepare', 'Start the Bulk Prepare Handler')
   .option('--bulkfulfil', 'Start the Bulk Fulfil Handler')
   .option('--bulkprocessing', 'Start the Bulk Processing Handler')
+  .option('--bulkget', 'Start the Bulk Get Handler')
   // .option('--reject', 'Start the Reject Handler')
 
   // function to execute when command is uses
   .action(async (args) => {
     const handlerList = []
     if (args.prepare) {
-      Logger.debug('CLI: Executing --prepare')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --prepare')
       const handler = {
         type: 'prepare',
         enabled: true
@@ -73,7 +74,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.position) {
-      Logger.debug('CLI: Executing --position')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --position')
       const handler = {
         type: 'position',
         enabled: true
@@ -81,7 +82,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.get) {
-      Logger.debug('CLI: Executing --get')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --get')
       const handler = {
         type: 'get',
         enabled: true
@@ -89,7 +90,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.fulfil) {
-      Logger.debug('CLI: Executing --fulfil')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --fulfil')
       const handler = {
         type: 'fulfil',
         enabled: true
@@ -97,7 +98,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.timeout) {
-      Logger.debug('CLI: Executing --timeout')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --timeout')
       const handler = {
         type: 'timeout',
         enabled: true
@@ -105,7 +106,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.admin) {
-      Logger.debug('CLI: Executing --admin')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --admin')
       const handler = {
         type: 'admin',
         enabled: true
@@ -113,7 +114,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.bulkprepare) {
-      Logger.debug('CLI: Executing --bulkprepare')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --bulkprepare')
       const handler = {
         type: 'bulkprepare',
         enabled: true
@@ -121,7 +122,7 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.bulkfulfil) {
-      Logger.debug('CLI: Executing --bulkfulfil')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --bulkfulfil')
       const handler = {
         type: 'bulkfulfil',
         enabled: true
@@ -129,13 +130,21 @@ Program.command('handler') // sub-command name, coffeeType = type, required
       handlerList.push(handler)
     }
     if (args.bulkprocessing) {
-      Logger.debug('CLI: Executing --bulkprocessing')
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --bulkprocessing')
       const handler = {
         type: 'bulkprocessing',
         enabled: true
       }
       handlerList.push(handler)
     }
+    if (args.bulkget) {
+      Logger.isDebugEnabled && Logger.debug('CLI: Executing --bulkget')
+      const handler = {
+        type: 'bulkget',
+        enabled: true
+      }
+      handlerList.push(handler)
+    }
 
     module.exports = Setup.initialize({
       service: 'handler',