TypeScript GuardFactory.create方法代码示例

 /**
  * 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()
   })
 }

 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 {

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

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

  static check (): express.RequestHandler {
    return GuardFactory.create((res: express.Response) => {
      const claim: Claim = res.locals.claim
      const user: User = res.locals.user

      if (claim.settlementReachedAt) {
        logger.warn('State guard: offer settlement reached, redirecting to dashboard')
        return false
      } else if (user.id === claim.claimantId && claim.claimantId !== claim.defendantId
                && claim.settlement.isOfferResponded()) {
        logger.warn('State guard: offer already accepted, redirecting to dashboard')
        return false
      } else {
        return true
      }
    }, (req: express.Request, res: express.Response) => {
      res.redirect(Paths.dashboardPage.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.BY_SET_DATE)
    }, (req: express.Request): void => {
      throw new NotFoundError(req.path)
    })

    return express.Router()
      .get(
        path + Paths.paymentDatePage.uri,
        ...guards,
        stateGuardRequestHandler,
        (req: express.Request, res: express.Response) => {
          this.renderView(new Form(this.createModelAccessor().get(res.locals.draft.document).paymentDate), res)
        })
      .post(
        path + Paths.paymentDatePage.uri,
        ...guards,
        stateGuardRequestHandler,
        FormValidator.requestHandler(PaymentDate, PaymentDate.fromObject),
        ErrorHandling.apply(async (req: express.Request, res: express.Response) => {
          const form: Form<PaymentDate> = req.body

          if (form.hasErrors()) {
            this.renderView(form, res)
          } else {
            this.createModelAccessor().patch(res.locals.draft.document, model => model.paymentDate = form.model)

            await this.saveDraft(res.locals)

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

import { PartyType } from 'common/partyType'

import { ErrorHandling } from 'shared/errorHandling'
import { DraftService } from 'services/draftService'
import { Claim } from 'claims/models/claim'
import { DraftCCJ } from 'ccj/draft/draftCCJ'
import { Draft } from '@hmcts/draft-store-client'

import { Logger } from '@hmcts/nodejs-logging'

const logger = Logger.getLogger('ccj/guards/individualDateOfBirth')

const accessGuardRequestHandler: express.RequestHandler = GuardFactory.create((res: express.Response): boolean => {
  const claim: Claim = res.locals.claim

  return claim.claimData.defendant.type === PartyType.INDIVIDUAL.value
}, (req: express.Request, res: express.Response): void => {
  logger.warn(`CCJ state guard: defendant date of birth is only available for individual defendants - redirecting to dashboard page`)
  res.redirect(DashboardPaths.dashboardPage.uri)
})

function renderView (form: Form<DateOfBirth>, res: express.Response): void {
  res.render(Paths.dateOfBirthPage.associatedView, { form: form })
}

/* tslint:disable:no-default-export */
export default express.Router()
  .get(Paths.dateOfBirthPage.uri,
    accessGuardRequestHandler,
    (req: express.Request, res: express.Response) => {
      const draft: Draft<DraftCCJ> = res.locals.ccjDraft
      renderView(new Form(draft.document.defendantDateOfBirth), res)