TypeScript guardFactory.GuardFactory类代码示例

 /**
  * Throws Forbidden error if user is not defendant in the case
  *
  * @returns {express.RequestHandler} - request handler middleware
  */
 static check (): express.RequestHandler {
   return GuardFactory.create((res: express.Response) => {
     const claim: Claim = res.locals.claim
     const user: User = res.locals.user
     return claim.defendantId === user.id
   }, (req: express.Request, res: express.Response): void => {
     throw new ForbiddenError()
   })
 }

function checkConsentedAlready (): express.RequestHandler {
  return GuardFactory.createAsync(async (req: express.Request, res: express.Response) => {
    const user: User = res.locals.user
    const roles = await claimStoreClient.retrieveUserRoles(user)

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

 static checkClaimantResponseDoesNotExist (): express.RequestHandler {
   const allowed = (res: express.Response) => {
     const claim: Claim = res.locals.claim
     return claim.claimantResponse === undefined
   }
   const accessDeniedCallback = (req: express.Request, res: express.Response) => {
     logger.warn('State guard: claimant response already exists - redirecting to dashboard')
     res.redirect(DashboardPaths.dashboardPage.uri)
   }
   return GuardFactory.create(allowed, accessDeniedCallback)
 }

  /**
   * Guard checks whether Statement of Means is required.
   * If so it accepts request, otherwise it makes redirect to task list
   *
   * @returns {e.RequestHandler}
   */
  static requestHandler (requireInitiatedModel: boolean = true): express.RequestHandler {
    return GuardFactory.create((res: express.Response) => {
      const draft: Draft<ResponseDraft> = res.locals.responseDraft
      const claim: Claim = res.locals.claim

      return StatementOfMeansFeature.isApplicableFor(claim, draft.document)
        && (requireInitiatedModel ? draft.document.statementOfMeans !== undefined : true)
    }, (req: express.Request, res: express.Response): void => {
      res.redirect(Paths.taskListPage.evaluateUri({ externalId: UUIDUtils.extractFrom(req.path) }))
    })
  }

 /**
  * Protects response journey from being accessed when response has not been submitted yet. Request in such scenario
  * will result in rendering not found page. In opposite scenario where response has already been made,
  * the request will be processed.
  */
 static checkResponseExists (): express.RequestHandler {
   const allowed = (res: express.Response) => {
     const claim: Claim = res.locals.claim
     return claim.response !== undefined
   }
   const accessDeniedCallback = (req: express.Request, res: express.Response) => {
     logger.warn('State guard: no response exists - rendering not found page')
     throw new NotFoundError(req.path)
   }
   return GuardFactory.create(allowed, accessDeniedCallback)
 }

  static requestHandler (): express.RequestHandler {
    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 => {
      res.redirect(ClaimPaths.newFeaturesConsentPage.uri)
    })
  }

  static requestHandler (): express.RequestHandler {

    function isRequestAllowed (res: express.Response): boolean {
      const draft: Draft<ResponseDraft> = res.locals.responseDraft

      return draft.document.isResponseRejected()
    }

    function accessDeniedCallback (req: express.Request, res: express.Response): void {
      logger.warn('Full Rejection Guard: user tried to access page for full rejection flow')
      throw new NotFoundError(req.path)
    }

    return GuardFactory.create(isRequestAllowed, accessDeniedCallback)
  }

  static requestHandler (): express.RequestHandler {

    function isRequestAllowed (res: express.Response): boolean {
      const draft: Draft<ResponseDraft> = res.locals.responseDraft
      const claim: Claim = res.locals.claim

      return ClaimFeatureToggles.isFeatureEnabledOnClaim(claim) && draft.document.isResponsePartiallyAdmitted()
    }

    function accessDeniedCallback (req: express.Request, res: express.Response): void {
      const claim: Claim = res.locals.claim
      logger.warn('Partial Admission Guard: user tried to access page for partial admission flow')
      res.redirect(Paths.responseTypePage.evaluateUri({ externalId: claim.externalId }))
    }

    return GuardFactory.create(isRequestAllowed, accessDeniedCallback)
  }

  /**
   * Makes sure that eligibility check has passed prior accessing protected pages. The eligibility is assessed by
   * checking whether draft has been marked as eligible or whether eligible cookie exists. If none of the conditions
   * is met then user is redirected to eligibility index page, otherwise request is let through as is.
   *
   * @returns {express.RequestHandler} - request handler middleware
   */
  static requestHandler (): express.RequestHandler {
    return GuardFactory.createAsync(async (req: express.Request, res: express.Response) => {
      const draft: Draft<DraftClaim> = res.locals.claimDraft
      if (draft.document.eligibility) {
        return true
      }

      const eligibility = eligibilityStore.read(req, res)
      if (eligibility.eligible) {
        await this.markDraftEligible(draft, res.locals.user)
        eligibilityStore.clear(req, res)
        return true
      }

      return false
    }, (req: express.Request, res: express.Response): void => {
      res.redirect(EligibilityPaths.startPage.uri)
    })
  }

  buildRouter (path: string, ...guards: express.RequestHandler[]): express.Router {
    const stateGuardRequestHandler: express.RequestHandler = GuardFactory.create((res: express.Response): boolean => {
      const model: PaymentIntention = this.createModelAccessor().get(res.locals.draft.document)

      return model
        && model.paymentOption
        && model.paymentOption.isOfType(PaymentType.INSTALMENTS)
    }, (req: express.Request, res: express.Response): void => {
      throw new NotFoundError(req.path)
    })

    return express.Router()
      .get(path + Paths.paymentPlanPage.uri,
        ...guards,
        stateGuardRequestHandler,
        ErrorHandling.apply(async (req: express.Request, res: express.Response) => {
          this.renderView(new Form(this.createModelAccessor().get(res.locals.draft.document).paymentPlan), res)
        }))
      .post(path + Paths.paymentPlanPage.uri,
        ...guards,
        stateGuardRequestHandler,
        FormValidator.requestHandler(PaymentPlanModel, PaymentPlanModel.fromObject, undefined, ['calculatePaymentPlan']),
        ErrorHandling.apply(
          async (req: express.Request, res: express.Response): Promise<void> => {
            let form: Form<PaymentPlanModel> = req.body

            const error: FormValidationError = this.postValidation(req, res)

            if (error) {
              form = new Form<PaymentPlanModel>(form.model, [error, ...form.errors])
            }

            if (form.hasErrors() || _.get(req, 'body.action.calculatePaymentPlan')) {
              this.renderView(form, res)
            } else {
              this.createModelAccessor().patch(res.locals.draft.document, model => model.paymentPlan = form.model)

              await this.saveDraft(res.locals)

              res.redirect(this.buildPostSubmissionUri(req, res))
            }
          }))
  }