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 })
}))
it('should retrieve claim saved on first attempt that timed out and caused a 409 on retry', async () => {
resolveLinkDefendant()
mockTimeoutOnFirstSaveAttemptAndConflictOnSecondOne()
const claim: Claim = await claimStoreClient.saveClaim(claimDraft, claimant, 'admissions')
expect(claim.claimData).to.deep.equal(new ClaimData().deserialize(expectedClaimData))
})
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
})
}))
