TypeScript claimStoreClient.ClaimStoreClient类代码示例

    ErrorHandling.apply(async (req: express.Request, res: express.Response) => {
      const draft: Draft<DraftClaim> = res.locals.claimDraft
      const user: User = res.locals.user

      draft.document = new DraftClaim().deserialize(prepareClaimDraft(user.email))
      await new DraftService().save(draft, user.bearerToken)

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

      if (roles && !roles.some(role => role.includes('cmc-new-features-consent'))) {
        await claimStoreClient.addRoleToUser(user, 'cmc-new-features-consent-given')
      }

      res.redirect(ClaimPaths.checkAndSendPage.uri)
    })

  .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)
    })
  }))

      it('should retrieve a claim that was successfully saved on first attempt without feature toggles', async () => {
        mockSuccessOnFirstSaveAttempt()

        const claim: Claim = await claimStoreClient.saveClaim(claimDraft, claimant)

        expect(claim.claimData).to.deep.equal(new ClaimData().deserialize(expectedClaimData))
      })

    ErrorHandling.apply(async (req: express.Request,
                               res: express.Response,
                               next: express.NextFunction): Promise<void> => {
      const cookies = new Cookies(req, res)
      let user

      try {
        const authenticationToken = await getAuthToken(req)
        if (authenticationToken) {
          user = await IdamClient.retrieveUserFor(authenticationToken)
          res.locals.isLoggedIn = true
          res.locals.user = user
          setAuthCookie(cookies, authenticationToken)
        }
      } catch (err) {
        return loginErrorHandler(req, res, cookies, next, err)
      }

      if (res.locals.isLoggedIn) {
        if (isDefendantFirstContactPinLogin(req)) {
          // re-set state cookie as it was cleared above, we need it in this case
          cookies.set(stateCookieName, req.query.state)
          return res.redirect(FirstContactPaths.claimSummaryPage.uri)
        } else {
          await claimStoreClient.linkDefendant(user)
          res.redirect(await retrieveRedirectForLandingPage(req, res))
        }
      } else {
        if (res.locals.code) {
          trackCustomEvent('Authentication token undefined (jwt defined)',
            { requestValue: req.query.state })
        }
        res.redirect(OAuthHelper.forLogin(req, res))
      }
    }))

    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 })
    }))

async function retrieveRedirectForLandingPage (req: express.Request, res: express.Response): Promise<string> {
  const eligibility: Eligibility = eligibilityStore.read(req, res)
  if (eligibility.eligible) {
    return ClaimPaths.taskListPage.uri
  }

  const user: User = res.locals.user
  const noClaimIssued: boolean = (await claimStoreClient.retrieveByClaimantId(user)).length === 0
  const noClaimReceived: boolean = (await claimStoreClient.retrieveByDefendantId(user)).length === 0
  const noDraftClaims: boolean = (await draftService.find('claim', '100', user.bearerToken, value => value)).length === 0
  const noDraftResponses: boolean = (await draftService.find('response', '100', user.bearerToken, value => value)).length === 0

  if (noClaimIssued && noClaimReceived && noDraftClaims && noDraftResponses) {
    return EligibilityPaths.startPage.uri
  } else {
    return DashboardPaths.dashboardPage.uri
  }
}

  .get(Paths.dashboardPage.uri, ErrorHandling.apply(async (req: express.Request, res: express.Response): Promise<void> => {
    const claimDraft: Draft<DraftClaim> = res.locals.claimDraft
    const responseDraft: Draft<ResponseDraft> = res.locals.responseDraft
    const user: User = res.locals.user
    const claimsAsClaimant: Claim[] = await claimStoreClient.retrieveByClaimantId(user)
    const claimDraftSaved: boolean = claimDraft.document && claimDraft.id !== 0
    const responseDraftSaved = responseDraft && responseDraft.document && responseDraft.id !== 0
    const claimsAsDefendant: Claim[] = await claimStoreClient.retrieveByDefendantId(user)

    claimState(claimsAsClaimant,ActorType.CLAIMANT)
    claimState(claimsAsDefendant,ActorType.DEFENDANT)

    res.render(Paths.dashboardPage.associatedView, {
      claimsAsClaimant: claimsAsClaimant,
      claimDraftSaved: claimDraftSaved,
      claimsAsDefendant: claimsAsDefendant,
      responseDraftSaved: responseDraftSaved
    })
  }))

    return GuardFactory.createAsync(async (req: express.Request, res: express.Response) => {
      if (!FeatureToggles.isEnabled('newFeaturesConsent')) {
        return true
      }

      const user: User = res.locals.user
      const roles = await claimStoreClient.retrieveUserRoles(user)

      return roles.length !== 0 && roles.some(role => role.includes('cmc-new-features-consent'))
    }, (req: express.Request, res: express.Response): void => {

    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
      })
    }))