TypeScript ResponseDraft.isResponseRejectedFullyBecausePaidWhatOwed方法代碼示例

 private static convertFullDefence (draft: ResponseDraft, claim: Claim, mediationDraft: MediationDraft): FullDefenceResponse {
   return {
     responseType: ResponseType.FULL_DEFENCE,
     defendant: this.convertPartyDetails(draft.defendantDetails),
     defenceType: this.inferDefenceType(draft),
     defence: draft.defence.text,
     timeline: {
       rows: draft.timeline.getPopulatedRowsOnly(),
       comment: draft.timeline.comment
     } as DefendantTimeline,
     evidence: {
       rows: convertEvidence(draft.evidence) as any,
       comment: draft.evidence.comment
     } as DefendantEvidence,
     freeMediation: this.convertFreeMediation(mediationDraft, draft),
     mediationPhoneNumber: this.convertMediationPhoneNumber(mediationDraft, draft, claim),
     mediationContactPerson: this.convertMediationContactPerson(mediationDraft, draft, claim),
     paymentDeclaration: draft.isResponseRejectedFullyBecausePaidWhatOwed() ? new PaymentDeclaration(
       draft.rejectAllOfClaim.howMuchHaveYouPaid.date.asString(),
       draft.rejectAllOfClaim.howMuchHaveYouPaid.amount,
       draft.rejectAllOfClaim.howMuchHaveYouPaid.text
     ) : undefined,
     statementOfTruth: this.convertStatementOfTruth(draft)
   }
 }

    it('should return true when response is full admission with already paid and amount claimed', () => {
      const draft: ResponseDraft = new ResponseDraft()
      draft.response = new Response(ResponseType.DEFENCE)
      draft.rejectAllOfClaim = new RejectAllOfClaim(RejectAllOfClaimOption.ALREADY_PAID, new HowMuchHaveYouPaid(100))

      expect(draft.isResponseRejectedFullyBecausePaidWhatOwed()).to.be.equals(true)
    })

 static convert (draft: ResponseDraft, mediationDraft: MediationDraft, claim: Claim): Response {
   switch (draft.response.type) {
     case FormResponseType.DEFENCE:
       if (draft.isResponseRejectedFullyBecausePaidWhatOwed()
         && draft.rejectAllOfClaim.howMuchHaveYouPaid.amount < claim.totalAmountTillToday) {
         return this.convertFullDefenceAsPartialAdmission(draft, claim, mediationDraft)
       }
       return this.convertFullDefence(draft, claim, mediationDraft)
     case FormResponseType.FULL_ADMISSION:
       return this.convertFullAdmission(draft, claim, mediationDraft)
     case FormResponseType.PART_ADMISSION:
       return this.convertPartAdmission(draft, claim, mediationDraft)
     default:
       throw new Error(`Unsupported response type: ${draft.response.type.value}`)
   }
 }

  static buildRespondToClaimSection (draft: ResponseDraft, claim: Claim): TaskList {
    const externalId: string = claim.externalId
    const tasks: TaskListItem[] = []

    tasks.push(
      new TaskListItem(
        'Choose a response',
        Paths.responseTypePage.evaluateUri({ externalId: externalId }),
        OweMoneyTask.isCompleted(draft)
      )
    )

    if (draft.isResponseRejectedFullyBecausePaidWhatOwed()) {
      tasks.push(
        new TaskListItem(
          'Tell us how much you’ve paid',
          FullRejectionPaths.howMuchHaveYouPaidPage.evaluateUri({ externalId: externalId }),
          ValidationUtils.isValid(draft.rejectAllOfClaim.howMuchHaveYouPaid)
        )
      )

      if (ClaimFeatureToggles.isFeatureEnabledOnClaim(claim)
        && draft.rejectAllOfClaim.howMuchHaveYouPaid !== undefined
        && draft.rejectAllOfClaim.howMuchHaveYouPaid.amount < claim.totalAmountTillToday) {
        tasks.push(
          new TaskListItem(
            'Why do you disagree with the amount claimed?',
            FullRejectionPaths.whyDoYouDisagreePage.evaluateUri({ externalId: externalId }),
            ValidationUtils.isValid(draft.rejectAllOfClaim.whyDoYouDisagree)
          )
        )
      }
    }

    if (draft.isResponseRejectedFullyWithDispute()) {
      tasks.push(
        new TaskListItem(
          'Why do you disagree with the claim?',
          Paths.defencePage.evaluateUri({ externalId: externalId }),
          YourDefenceTask.isCompleted(draft)
        )
      )
    }

    if (ClaimFeatureToggles.isFeatureEnabledOnClaim(claim)) {
      if (draft.isResponseFullyAdmitted()) {
        tasks.push(
          new TaskListItem(
            'Decide how you’ll pay',
            FullAdmissionPaths.paymentOptionPage.evaluateUri({ externalId: externalId }),
            DecideHowYouWillPayTask.isCompleted(draft)
          )
        )

        if (StatementOfMeansFeature.isApplicableFor(claim, draft)) {
          tasks.push(
            new TaskListItem(
              'Share your financial details',
              StatementOfMeansPaths.introPage.evaluateUri({ externalId: externalId }),
              StatementOfMeansTask.isCompleted(draft)
            )
          )
        } else if (draft.defendantDetails.partyDetails.isBusiness() &&
            !draft.isImmediatePaymentOptionSelected(draft.fullAdmission) &&
            !draft.isImmediatePaymentOptionSelected(draft.partialAdmission)
        ) {
          tasks.push(
            new TaskListItem(
              'Share your financial details',
              Paths.sendCompanyFinancialDetailsPage.evaluateUri({ externalId: externalId }),
              ViewSendCompanyFinancialDetailsTask.isCompleted(draft)
            )
          )
        }

        if (draft.isResponseFullyAdmittedWithInstalments()) {
          tasks.push(
            new TaskListItem(
              'Your repayment plan',
              FullAdmissionPaths.paymentPlanPage.evaluateUri({ externalId: externalId }),
              YourRepaymentPlanTask.isCompleted(draft.fullAdmission.paymentIntention.paymentPlan)
            )
          )
        }
      }

      const partiallyAdmitted = draft.isResponsePartiallyAdmitted()
      const partiallyAdmittedAndPaid = draft.isResponsePartiallyAdmittedAndAlreadyPaid()

      if (partiallyAdmitted) {

        if (partiallyAdmittedAndPaid) {
          tasks.push(
            new TaskListItem(
              'How much have you paid?',
              PartAdmissionPaths.howMuchHaveYouPaidPage.evaluateUri({ externalId: externalId }),
              ValidationUtils.isValid(draft.partialAdmission.howMuchHaveYouPaid)
            )
          )
          if (draft.partialAdmission.paymentIntention !== undefined) {
//.........這裏部分代碼省略.........

 private static isRejectedFullyBecausePaidLessThanClaimAmountAndExplanationGiven (claim: Claim, draft: ResponseDraft): boolean {
   return draft.isResponseRejectedFullyBecausePaidWhatOwed()
     && draft.rejectAllOfClaim.howMuchHaveYouPaid !== undefined
     && claim.totalAmountTillToday > draft.rejectAllOfClaim.howMuchHaveYouPaid.amount
     && ValidationUtils.isValid(draft.rejectAllOfClaim.whyDoYouDisagree)
 }

 private static isRejectedFullyBecausePaidMoreThenClaimAmount (claim: Claim, draft: ResponseDraft): boolean {
   return draft.isResponseRejectedFullyBecausePaidWhatOwed()
     && draft.rejectAllOfClaim.howMuchHaveYouPaid !== undefined
     && claim.totalAmountTillToday < draft.rejectAllOfClaim.howMuchHaveYouPaid.amount
 }