Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
}
} else { // individual transfer from a bulk
if (result[i].transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
message.to = message.from
message.from = Enum.Http.Headers.FSPIOP.SWITCH.value
message.metadata.event.type = Enum.Events.Event.Type.BULK_PROCESSING
message.metadata.event.action = Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED
await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.BULK_PROCESSING, Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED, message, state, null, span)
} else if (result[i].transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
message.metadata.event.type = Enum.Events.Event.Type.POSITION
message.metadata.event.action = Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED
await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.POSITION, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED, message, state, result[i].payerFsp, span)
}
}
} catch (err) {
const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
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)
throw fspiopError
} finally {
if (!span.isFinished) {
await span.finish()
}
}
}
return {
intervalMin,
cleanup,
intervalMax,
result
}
throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, 'The requested hub operator account type is not allowed.')
}
const newCurrencyAccount = await ParticipantService.createHubAccount(participant.participantId, request.payload.currency, ledgerAccountType.ledgerAccountTypeId)
if (!newCurrencyAccount) {
throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, 'Participant account and Position create have failed.')
}
participant.currencyList.push(newCurrencyAccount.participantCurrency)
} else {
throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, 'Participant was not found.')
}
// end here : move to domain
const ledgerAccountTypes = await request.server.methods.enums('ledgerAccountType')
const ledgerAccountIds = Util.transpose(ledgerAccountTypes)
return h.response(entityItem(participant, ledgerAccountIds)).code(201)
} catch (err) {
throw ErrorHandler.Factory.reformatFSPIOPError(err)
}
}
exports.prepareData = async () => {
try {
const transferResult = await TransferPreparationModule.prepareData()
const transfer = await TransferModel.getById(transferResult.transfer.transferId)
const ilp = await IlpPacketModel.getByTransferId(transferResult.transfer.transferId)
return {
ilp,
transfer,
participantPayer: transferResult.participantPayerResult,
participantPayee: transferResult.participantPayeeResult
}
} catch (err) {
throw ErrorHandler.Factory.reformatFSPIOPError(err)
}
}
const destroyById = async (id) => {
try {
await Db.transfer.destroy({ transferId: id })
} catch (err) {
throw ErrorHandler.Factory.reformatFSPIOPError(err)
}
}
const transformTransferToFulfil = (transfer) => {
try {
const result = {
completedTimestamp: transfer.completedTimestamp,
transferState: transfer.transferStateEnumeration
}
if (transfer.fulfilment !== '0') result.fulfilment = transfer.fulfilment
const extension = transformExtensionList(transfer.extensionList)
if (extension.length > 0) {
result.extensionList = { extension }
}
return Util.omitNil(result)
} catch (err) {
throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, `Unable to transform to fulfil response: ${err}`)
}
}
const transferStateChange = {
transferId: transferInfo.transferId,
transferStateId,
reason: transferInfo.reason
}
await PositionService.changeParticipantPosition(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange)
await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail })
histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
return true
} else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.TIMEOUT_RESERVED, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED].includes(action)) {
Logger.info(Utility.breadcrumb(location, { path: 'timeout' }))
span.setTags({ transactionId: transferId })
const transferInfo = await TransferService.getTransferInfoToChangePosition(transferId, Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP, Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
if (transferInfo.transferStateId !== Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
Logger.info(Utility.breadcrumb(location, `validationFailed::notReceivedFulfilState2--${actionLetter}6`))
throw ErrorHandler.Factory.createInternalServerFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR.message)
} else {
Logger.info(Utility.breadcrumb(location, `validationPassed2--${actionLetter}7`))
const isReversal = true
const transferStateChange = {
transferId: transferInfo.transferId,
transferStateId: Enum.Transfers.TransferInternalState.EXPIRED_RESERVED,
reason: ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.message
}
await PositionService.changeParticipantPosition(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange)
const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.EXPIRED_ERROR, null, null, null, payload.extensionList)
if (action === Enum.Events.Event.Action.TIMEOUT_RESERVED) {
eventDetail.action = Enum.Events.Event.Action.ABORT
}
await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail })
throw fspiopError
}
const saveBulkTransferFulfilmentDuplicateCheck = async (bulkTransferId, hash) => {
Logger.debug(`save BulkTransferFulfilmentDuplicateCheck (bulkTransferId=${bulkTransferId}, hash=${hash})`)
try {
return Db.bulkTransferFulfilmentDuplicateCheck.insert({ bulkTransferId, hash })
} catch (err) {
throw ErrorHandler.Factory.reformatFSPIOPError(err)
}
}
Sidecar.logRequest(request)
try {
const result = await ParticipantService.adjustLimits(request.params.name, request.payload)
const { participantLimit } = result
const updatedLimit = {
currency: request.payload.currency,
limit: {
type: request.payload.limit.type,
value: participantLimit.value,
alarmPercentage: participantLimit.thresholdAlarmPercentage
}
}
return h.response(updatedLimit).code(200)
} catch (err) {
throw ErrorHandler.Factory.reformatFSPIOPError(err)
}
}