[MTDSA-23287] Update Enum Value for consistency

app/shared/controllers/validators/resolvers/ResolveTaxYear.scala

@@ -38,6 +38,16 @@ object ResolveTaxYear extends ResolverSupport {
     case _ => Invalid(List(TaxYearFormatError))
   }
 
+  def resolverWithCustomErrors(formatError: MtdError, rangeError: MtdError): Resolver[String, TaxYear] = {
+    case value @ taxYearFormat(start, end) =>
+      if (end.toInt - start.toInt == 1)
+        Valid(TaxYear.fromMtd(value))
+      else
+        Invalid(List(rangeError))
+
+    case _ => Invalid(List(formatError))
+  }
+
   def apply(value: String): Validated[Seq[MtdError], TaxYear] = resolver(value)
 
   def apply(value: Option[String]): Validated[Seq[MtdError], Option[TaxYear]] =
@@ -55,10 +65,15 @@ object ResolveTaxYear extends ResolverSupport {
 
 }
 
-case class ResolveTaxYearMinimum(minimumTaxYear: TaxYear, error: MtdError = RuleTaxYearNotSupportedError) extends ResolverSupport {
+case class ResolveTaxYearMinimum(
+    minimumTaxYear: TaxYear,
+    notSupportedError: MtdError = RuleTaxYearNotSupportedError,
+    formatError: MtdError = TaxYearFormatError,
+    rangeError: MtdError = RuleTaxYearRangeInvalidError
+) extends ResolverSupport {
 
   val resolver: Resolver[String, TaxYear] =
-    ResolveTaxYear.resolver thenValidate satisfiesMin(minimumTaxYear, error)
+    ResolveTaxYear.resolverWithCustomErrors(formatError, rangeError) thenValidate satisfiesMin(minimumTaxYear, notSupportedError)
 
   def apply(value: String): Validated[Seq[MtdError], TaxYear] = resolver(value)
 

app/shared/shared-code-changelog.md

@@ -7,10 +7,14 @@ For the Shared Code update steps, see: https://confluence.tools.tax.service.gov.
 
 Place new items at the top, and auto-format the file...
 
+## September 17 2024:  ResolveTaxYearMinimum
+
+Added an apply function on ResolveTaxYearMinimum to allow adding custom errors. Required in individual-losses-api.
+
 ## August 29 2024:  Increased code coverage
 
-Increased the coverage for ResolveTaxYearMinMax and ResolveDateRange so that introducing the shared code into other APIs won't
-reduce their coverage % quite so much.
+Increased the coverage for ResolveTaxYearMinMax and ResolveDateRange so that introducing the shared code into other APIs
+won't reduce their coverage % quite so much.
 
 ## Aug 21 2024: Re-engineer BaseDownstreamConnector and DownstreamUri for HIP support
 

app/v7/common/model/response/AllowancesReliefsAndDeductionsType.scala

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait AllowancesReliefsAndDeductionsType
+
+object AllowancesReliefsAndDeductionsType {
+  case object `investment-reliefs`  extends AllowancesReliefsAndDeductionsType
+  case object `other-reliefs`       extends AllowancesReliefsAndDeductionsType
+  case object `other-expenses`      extends AllowancesReliefsAndDeductionsType
+  case object `other-deductions`    extends AllowancesReliefsAndDeductionsType
+  case object `foreign-reliefs`     extends AllowancesReliefsAndDeductionsType
+
+  implicit val writes: Writes[AllowancesReliefsAndDeductionsType] = Enums.writes[AllowancesReliefsAndDeductionsType]
+
+  implicit val reads: Reads[AllowancesReliefsAndDeductionsType] = Enums.readsUsing {
+    case "investmentReliefs"  => `investment-reliefs`
+    case "otherReliefs"       => `other-reliefs`
+    case "otherExpenses"      => `other-expenses`
+    case "otherDeductions"    => `other-deductions`
+    case "foreignReliefs"     => `foreign-reliefs`
+  }
+
+}

app/v7/common/model/response/CalculationReason.scala

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait CalculationReason
+
+object CalculationReason {
+  case object `customer-request`                extends CalculationReason
+  case object `class2-nic-event`                extends CalculationReason
+  case object `new-loss-event`                  extends CalculationReason
+  case object `updated-loss-event`              extends CalculationReason
+  case object `new-claim-event`                 extends CalculationReason
+  case object `updated-claim-event`             extends CalculationReason
+  case object `new-annual-adjustment-event`     extends CalculationReason
+  case object `updated-annual-adjustment-event` extends CalculationReason
+  case object `unattended-calculation`          extends CalculationReason
+
+  implicit val writes: Writes[CalculationReason] = Enums.writes[CalculationReason]
+
+  implicit val reads: Reads[CalculationReason] = Enums.readsUsing {
+    case "customerRequest"                => `customer-request`
+    case "class2NICEvent"                 => `class2-nic-event`
+    case "newLossEvent"                   => `new-loss-event`
+    case "updatedLossEvent"               => `updated-loss-event`
+    case "newClaimEvent"                  => `new-claim-event`
+    case "updatedClaimEvent"              => `updated-claim-event`
+    case "newAnnualAdjustmentEvent"       => `new-annual-adjustment-event`
+    case "updatedAnnualAdjustmentEvent"   => `updated-annual-adjustment-event`
+    case "unattendedCalculation"          => `unattended-calculation`
+  }
+
+}

app/v7/common/model/response/CalculationType.scala

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait CalculationType
+
+object CalculationType {
+
+  case object `in-year`           extends CalculationType
+  case object `final-declaration` extends CalculationType
+
+  implicit val writes: Writes[CalculationType] = Enums.writes[CalculationType]
+
+  implicit val reads: Reads[CalculationType] = Enums.readsUsing[CalculationType] {
+    case "inYear"          => `in-year`
+    case "crystallisation" => `final-declaration`
+  }
+
+}

app/v7/common/model/response/ChargeableEventGainsIncomeType.scala

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait ChargeableEventGainsIncomeType
+
+object ChargeableEventGainsIncomeType {
+  case object `life-insurance`     extends ChargeableEventGainsIncomeType
+  case object `capital-redemption` extends ChargeableEventGainsIncomeType
+  case object `life-annuity`       extends ChargeableEventGainsIncomeType
+  case object `voided-isa`         extends ChargeableEventGainsIncomeType
+
+  implicit val writes: Writes[ChargeableEventGainsIncomeType] = Enums.writes[ChargeableEventGainsIncomeType]
+
+  implicit val reads: Reads[ChargeableEventGainsIncomeType] = Enums.readsUsing {
+    case "lifeInsurance"      => `life-insurance`
+    case "capitalRedemption"  => `capital-redemption`
+    case "lifeAnnuity"        => `life-annuity`
+    case "voidedIsa"          => `voided-isa`
+  }
+
+}

app/v7/common/model/response/ClaimType.scala

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait ClaimType
+
+object ClaimType {
+  case object `carry-forward`                   extends ClaimType
+  case object `carry-sideways`                  extends ClaimType
+  case object `carry-forward-to-carry-sideways` extends ClaimType
+  case object `carry-sideways-fhl`              extends ClaimType
+  case object `carry-backwards`                 extends ClaimType
+  case object `carry-backwards-general-income`  extends ClaimType
+
+  implicit val writes: Writes[ClaimType] = Enums.writes[ClaimType]
+
+  implicit val reads: Reads[ClaimType] = Enums.readsUsing {
+    case "CF"     => `carry-forward`
+    case "CSGI"   => `carry-sideways`
+    case "CFCSGI" => `carry-forward-to-carry-sideways`
+    case "CSFHL"  => `carry-sideways-fhl`
+    case "CB"     => `carry-backwards`
+    case "CBGI"   => `carry-backwards-general-income`
+  }
+
+}

app/v7/common/model/response/IncomeSourceType.scala

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json._
+
+sealed trait IncomeSourceType
+
+object IncomeSourceType {
+
+  case object `self-employment`           extends IncomeSourceType
+  case object `uk-property-non-fhl`       extends IncomeSourceType
+  case object `foreign-property-fhl-eea`  extends IncomeSourceType
+  case object `uk-property-fhl`           extends IncomeSourceType
+  case object `employments`               extends IncomeSourceType
+  case object `foreign-income`            extends IncomeSourceType
+  case object `foreign-dividends`         extends IncomeSourceType
+  case object `uk-savings-and-gains`      extends IncomeSourceType
+  case object `uk-dividends`              extends IncomeSourceType
+  case object `state-benefits`            extends IncomeSourceType
+  case object `gains-on-life-policies`    extends IncomeSourceType
+  case object `share-schemes`             extends IncomeSourceType
+  case object `foreign-property`          extends IncomeSourceType
+  case object `foreign-savings-and-gains` extends IncomeSourceType
+  case object `other-dividends`           extends IncomeSourceType
+  case object `uk-securities`             extends IncomeSourceType
+  case object `other-income`              extends IncomeSourceType
+  case object `foreign-pension`           extends IncomeSourceType
+  case object `non-paye-income`           extends IncomeSourceType
+  case object `capital-gains-tax`         extends IncomeSourceType
+  case object `charitable-giving`         extends IncomeSourceType
+
+  implicit val incomeSourceTypeWrites: Writes[IncomeSourceType] = Enums.writes[IncomeSourceType]
+
+  implicit val reads: Reads[IncomeSourceType] = Enums.readsUsing {
+    case "01" => `self-employment`
+    case "02" => `uk-property-non-fhl`
+    case "03" => `foreign-property-fhl-eea`
+    case "04" => `uk-property-fhl`
+    case "05" => `employments`
+    case "06" => `foreign-income`
+    case "07" => `foreign-dividends`
+    case "09" => `uk-savings-and-gains`
+    case "10" => `uk-dividends`
+    case "11" => `state-benefits`
+    case "12" => `gains-on-life-policies`
+    case "13" => `share-schemes`
+    case "15" => `foreign-property`
+    case "16" => `foreign-savings-and-gains`
+    case "17" => `other-dividends`
+    case "18" => `uk-securities`
+    case "19" => `other-income`
+    case "20" => `foreign-pension`
+    case "21" => `non-paye-income`
+    case "22" => `capital-gains-tax`
+    case "98" => `charitable-giving`
+  }
+
+  def formatRestricted(types: IncomeSourceType*): Format[IncomeSourceType] = new Format[IncomeSourceType] {
+    override def writes(o: IncomeSourceType): JsValue = incomeSourceTypeWrites.writes(o)
+
+    override def reads(json: JsValue): JsResult[IncomeSourceType] = json.validate[IncomeSourceType](Enums.readsRestricted(types: _*))
+  }
+
+}

app/v7/common/model/response/InputsOtherType.scala

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2023 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package v7.common.model.response
+
+import common.utils.enums.Enums
+import play.api.libs.json.{Reads, Writes}
+
+sealed trait InputsOtherType
+
+object InputsOtherType {
+  case object `coding-out`       extends InputsOtherType
+
+  implicit val writes: Writes[InputsOtherType] = Enums.writes[InputsOtherType]
+
+  implicit val reads: Reads[InputsOtherType] = Enums.readsUsing {
+    case "codingOut"        => `coding-out`
+  }
+
+}