ErrorHandling.apply(async (req: express.Request, res: express.Response, next: express.NextFunction): Promise<void> => {
      const { externalId } = req.params
      const form: Form<Response> = req.body

      if (form.hasErrors()) {
        renderView(form, res)
      } else {
        const claim: Claim = res.locals.claim
        const draft: Draft<ResponseDraft> = res.locals.responseDraft
        const user: User = res.locals.user

        draft.document.response = form.model

        if (draft.document.response.type === ResponseType.FULL_ADMISSION) {
          if (!draft.document.fullAdmission) {
            draft.document.fullAdmission = new FullAdmission()
          }
          delete draft.document.partialAdmission
          delete draft.document.freeMediation
        } else if (draft.document.response.type === ResponseType.PART_ADMISSION) {
          if (!draft.document.partialAdmission) {
            draft.document.partialAdmission = new PartialAdmission()
          }
          delete draft.document.fullAdmission
          delete draft.document.rejectAllOfClaim
          delete draft.document.freeMediation
        } else {
          delete draft.document.fullAdmission
          delete draft.document.partialAdmission
          delete draft.document.statementOfMeans
        }

        await new DraftService().save(draft, user.bearerToken)

        switch (draft.document.response.type) {
          case ResponseType.DEFENCE:
            res.redirect(Paths.defenceRejectAllOfClaimPage.evaluateUri({ externalId: externalId }))
            break

          case ResponseType.PART_ADMISSION:
            if (FeatureToggles.hasAnyAuthorisedFeature(claim.features, 'admissions')) {
              res.redirect(PartAdmissionPaths.alreadyPaidPage.evaluateUri({ externalId: externalId }))
            } else {
              res.redirect(Paths.sendYourResponseByEmailPage.evaluateUri({ externalId: externalId }))
            }
            break

          case ResponseType.FULL_ADMISSION:
            if (FeatureToggles.hasAnyAuthorisedFeature(claim.features, 'admissions')) {
              res.redirect(Paths.taskListPage.evaluateUri({ externalId: claim.externalId }))
            } else {
              res.redirect(Paths.sendYourResponseByEmailPage.evaluateUri({ externalId: externalId }))
            }
            break

          default:
            next(new Error(`Unknown response type: ${draft.document.response.type}`))
        }
      }
    }))

  static buildResolvingClaimSection (draft: ResponseDraft, claim: Claim, mediationDraft?: MediationDraft): TaskList {
    if (draft.isResponseRejectedFullyWithDispute()
      || TaskListBuilder.isRejectedFullyBecausePaidLessThanClaimAmountAndExplanationGiven(claim, draft)
      || TaskListBuilder.isPartiallyAdmittedAndWhyDoYouDisagreeTaskCompleted(draft)) {
      let path: string
      if (FeatureToggles.isEnabled('mediation')) {
        path = MediationPaths.freeMediationPage.evaluateUri({ externalId: claim.externalId })
        return new TaskList(
          'Try to resolve the claim', [
            new TaskListItem(
              'Free telephone mediation',
              path,
              FreeMediationTask.isCompleted(draft, mediationDraft)
            )
          ]
        )
      } else {
        path = Paths.freeMediationPage.evaluateUri({ externalId: claim.externalId })
        return new TaskList(
          'Resolving the claim', [
            new TaskListItem(
              'Consider free mediation',
              path,
              FreeMediationTask.isCompleted(draft, mediationDraft)
            )
          ]
        )
      }

    }

    return undefined
  }

 private static convertFreeMediation (mediationDraft: MediationDraft, draft: ResponseDraft): YesNoOption {
   if (FeatureToggles.isEnabled('mediation')) {
     return FreeMediationUtil.convertFreeMediation(mediationDraft.youCanOnlyUseMediation)
   } else {
     return FreeMediationUtil.convertFreeMediation(draft.freeMediation)
   }
 }

        it('should be not available when defendant did not request free mediation and claimant rejected response', () => {
          claim = new Claim().deserialize({
            ...claimStoreServiceMock.sampleClaimObj, ...{
              response: {
                ...partialAdmissionWithPaymentBySetDateData,
                freeMediation: 'no'
              }
            }
          })
          draft = new DraftClaimantResponse().deserialize({
            ...draftStoreServiceMock.sampleClaimantResponseDraftObj, ...{
              settleAdmitted: {
                admitted: {
                  option: 'no'
                }
              }
            }
          })

          const taskList: TaskList = TaskListBuilder.buildHowYouWantToRespondSection(draft, claim, new MediationDraft())
          if (FeatureToggles.isEnabled('mediation')) {
            expect(taskList.tasks.find(task => task.name === featureToggleMediationTaskLabel)).to.be.undefined
          } else {
            expect(taskList.tasks.find(task => task.name === mediationTaskLabel)).to.be.undefined
          }
        })

 static isCompleted (claimantResponseDraft: DraftClaimantResponse, mediationDraft: MediationDraft): boolean {
   if (FeatureToggles.isEnabled('mediation')) {
     return mediationDraft.willYouTryMediation !== undefined && validator.validateSync(mediationDraft.willYouTryMediation).length === 0
   } else {
     return claimantResponseDraft.freeMediation !== undefined && validator.validateSync(claimantResponseDraft.freeMediation).length === 0
   }
 }

const getPayClient = async (req: express.Request): Promise<PayClient> => {
  const authToken = await new ServiceAuthTokenFactoryImpl().get()

  if (FeatureToggles.isEnabled('mockPay')) {
    return new MockPayClient(req.url)
  }
  return new GovPayClient(authToken)
}

 static isCompleted (responseDraft: ResponseDraft, mediationDraft: MediationDraft): boolean {
   if (FeatureToggles.isEnabled('mediation')) {
     return (this.isWillYouTryMediationCompleted(mediationDraft)) ||
       this.isYouCanOnlyUseMediationCompleted(mediationDraft) &&
       this.isCanWeUseCompleted(mediationDraft)
   } else {
     return responseDraft.freeMediation !== undefined && validator.validateSync(responseDraft.freeMediation).length === 0
   }
 }

    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 => {

    it('Should not return "Free telephone mediation" when not fully reject', () => {
      isResponseRejectedFullyWithDisputeStub.returns(false)

      const tasks: TaskListItem[] = TaskListBuilder.buildRemainingTasks(new ResponseDraft(), claim, new MediationDraft())
      if (FeatureToggles.isEnabled('mediation')) {
        expect(tasks.map(task => task.name)).to.not.contain(featureToggleMediationTaskLabel)
      } else {
        expect(tasks.map(task => task.name)).to.not.contain(mediationTaskLabel)
      }
    })