TypeScript ClaimStoreClient.retrieveByExternalId方法代码示例

    ErrorHandling.apply(async (req: express.Request, res: express.Response, next: express.NextFunction) => {
      const { externalId } = req.params
      const user: User = res.locals.user
      const claim: Claim = await claimStoreClient.retrieveByExternalId(externalId, user)

      res.render(Paths.confirmationPage.associatedView, { claim: claim })
    }))

  .get(Paths.contactThemPage.uri, ErrorHandling.apply(async (req: express.Request, res: express.Response): Promise<void> => {
    const { externalId } = req.params

    res.render(Paths.contactThemPage.associatedView, {
      claim: await claimStoreClient.retrieveByExternalId(externalId, res.locals.user as User)
    })
  }))

    ErrorHandling.apply(async (req: express.Request, res: express.Response): Promise<void> => {
      const { externalId } = req.params

      const claim = externalId !== draftExternalId ? await claimStoreClient.retrieveByExternalId(externalId, res.locals.user as User) : undefined
      if (claim && claim.claimantId !== res.locals.user.id) {
        throw new ForbiddenError()
      }
      res.render(Paths.claimantPage.associatedView, {
        claim: claim
      })
    }))

  static retrieveByExternalId (req: express.Request, res: express.Response, next: express.NextFunction): void {
    // req.params isn't populated here https://github.com/expressjs/express/issues/2088
    const externalId: string = UUIDUtils.extractFrom(req.path)

    const user: User = res.locals.user
    claimStoreClient.retrieveByExternalId(externalId, user)
      .then((claim: Claim) => {
        res.locals.claim = claim
        next()
      })
      .catch(next)
  }

    ErrorHandling.apply(async (req: express.Request, res: express.Response): Promise<void> => {
      const { externalId } = req.params

      if (externalId === draftExternalId) {
        throw new Error('Draft external ID is not supported')
      }

      const user: User = res.locals.user
      const claim: Claim = await claimStoreClient.retrieveByExternalId(externalId, user)
      if (claim && claim.claimantId !== user.id) {
        throw new ForbiddenError()
      }

      if (claim.claimData.defendant.type === PartyType.INDIVIDUAL.value) {
        res.redirect(CCJPaths.dateOfBirthPage.evaluateUri({ externalId: externalId }))
      } else {
        res.redirect(CCJPaths.paidAmountPage.evaluateUri({ externalId: externalId }))
      }
    }))

async function successHandler (req, res, next) {
  const draft: Draft<DraftClaim> = res.locals.claimDraft
  const user: User = res.locals.user
  const externalId: string = draft.document.externalId
  let savedClaim: Claim

  try {
    const roles: string[] = await claimStoreClient.retrieveUserRoles(user)

    if (!roles.length) {
      logger.error(`missing consent not given role for user, User Id : ${user.id}`)
    }

    let features: string
    if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_admissions')) {
      features = 'admissions'
    }

    if (draft.document.amount.totalAmount() <= 300) {
      if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_directions_questionnaire')) {
        features += features === undefined ? 'directionsQuestionnaire' : ', directionsQuestionnaire'
      }
    }

    if (draft.document.amount.totalAmount() <= 300) {
      if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_mediation_pilot')) {
        features += features === undefined ? 'mediationPilot' : ', mediationPilot'
      }
    }

    savedClaim = await claimStoreClient.saveClaim(draft, user, features)

  } catch (err) {
    if (err.statusCode === HttpStatus.INTERNAL_SERVER_ERROR || err.statusCode === HttpStatus.SERVICE_UNAVAILABLE) {
      logError(
        user.id,
        draft.document.claimant.payment,
        `Payment processed successfully but there was a problem saving claim '${externalId}' to the claim store.`
      )
      trackCustomEvent(`Post payment successful but unable to store claim in claim-store with externalId: ${externalId}`,
        {
          externalId: externalId,
          payment: draft.document.claimant.payment,
          error: err
        })
      next(err)
      return
    } else if (err.statusCode === HttpStatus.CONFLICT) {
      logError(
        user.id,
        draft.document.claimant.payment,
        `Payment processed successfully and claim ${externalId} already exists.`
      )
      savedClaim = await claimStoreClient.retrieveByExternalId(externalId, user)
    }
  }
  const payClient: PayClient = await getPayClient(req)
  const paymentReference = draft.document.claimant.payment.reference

  if (savedClaim) {
    const ccdCaseNumber = savedClaim.ccdCaseId === undefined ? 'UNKNOWN' : String(savedClaim.ccdCaseId)
    await payClient.update(user, paymentReference, savedClaim.externalId, ccdCaseNumber)
  }

  await new DraftService().delete(draft.id, user.bearerToken)
  res.redirect(Paths.confirmationPage.evaluateUri({ externalId: externalId }))
}