Add Aggregate 5-3 report

Author: schbetsy

publication/src/main/resources/reports-metadata.txt

@@ -1,4 +1,5 @@
 ReportId,Type,ReportTable,Dispositions,Description
 A52,Aggregate,5-2,Received;Originated;ApprovedButNotAccepted;Denied;Withdrawn;Closed,"Disposition of Applications for Conventional Home-Purchase Loans, 1-to-4 Family and Manufactured Home Dwellings, by Income, Race, and Ethnicity of Applicant"
+A53,Aggregate,5-3,Received;Originated;ApprovedButNotAccepted;Denied;Withdrawn;Closed,"Disposition of Applications to Refinance Loans on 1-to-4 Family and Manufactured Home Dwellings, by Income, Race, and Ethnicity of Applicant"
 D51,Disclosure,5-1,Received;Originated;ApprovedButNotAccepted;Denied;Withdrawn;Closed,"Disposition of applications for FHA, FSA/RHS, and VA home-purchase loans, 1- to 4-family and manufactured home dwellings, by income, race and ethnicity of applicant"
 D53,Disclosure,5-3,Received;Originated;ApprovedButNotAccepted;Denied;Withdrawn;Closed,"Disposition of Applications to Refinance Loans on 1-to-4 Family and Manufactured Home Dwellings, by Income, Race, and Ethnicity of Applicant"

publication/src/main/scala/hmda/publication/reports/aggregate/A53.scala

@@ -0,0 +1,66 @@
+package hmda.publication.reports.aggregate
+
+import akka.NotUsed
+import akka.stream.scaladsl.Source
+import hmda.model.publication.reports.{ ApplicantIncome, Disposition, MSAReport }
+import hmda.publication.reports._
+import hmda.publication.reports.util.ReportUtil._
+import hmda.publication.reports.util.ReportsMetaDataLookup
+import hmda.query.model.filing.LoanApplicationRegisterQuery
+
+import scala.concurrent.Future
+
+case class A53(
+  year: Int,
+  msa: MSAReport,
+  applicantIncomes: List[ApplicantIncome],
+  total: List[Disposition],
+  reportDate: String = formattedCurrentDate,
+  table: String = A53.metaData.reportTable,
+  description: String = A53.metaData.description
+) extends AggregateReport
+
+object A53 {
+  val metaData = ReportsMetaDataLookup.values("A53")
+  val dispositions = metaData.dispositions
+
+  // Table filters:
+  // Property Type 1,2
+  // Purpose of Loan 3
+  def generate[ec: EC, mat: MAT, as: AS](
+    larSource: Source[LoanApplicationRegisterQuery, NotUsed],
+    fipsCode: Int
+  ): Future[A53] = {
+    val lars = larSource
+      .filter(lar => lar.msa != "NA")
+      .filter(lar => lar.msa.toInt == fipsCode)
+      .filter { lar =>
+        (lar.propertyType == 1 || lar.propertyType == 2) &&
+          (lar.purpose == 3)
+      }
+
+    val larsWithIncome = lars.filter(lar => lar.income != "NA")
+
+    val msa = msaReport(fipsCode.toString)
+
+    val incomeIntervals = calculateMedianIncomeIntervals(fipsCode)
+    val applicantIncomesF = applicantIncomesWithBorrowerCharacteristics(larsWithIncome, incomeIntervals, dispositions)
+
+    val yearF = calculateYear(larSource)
+    val totalF = calculateDispositions(lars, dispositions)
+
+    for {
+      applicantIncomes <- applicantIncomesF
+      year <- yearF
+      total <- totalF
+    } yield {
+
+      A53(
+        year,
+        msa,
+        applicantIncomes,
+        total
+      )
+    }
+  }
+}

publication/src/main/scala/hmda/publication/reports/aggregate/AggregateReports.scala

@@ -27,5 +27,7 @@ class AggregateReports(val sys: ActorSystem, val mat: ActorMaterializer) extends
     a52F.map { a52 =>
       println(a52.toJson.prettyPrint)
     }
+
+    // A53.generate(larSource, fipsCode)
   }
 }

publication/src/main/scala/hmda/publication/reports/protocol/aggregate/A53Protocol.scala

@@ -0,0 +1,50 @@
+package hmda.publication.reports.protocol.aggregate
+
+import hmda.model.publication.reports.{ ApplicantIncome, Disposition, MSAReport }
+import hmda.model.publication.reports.ReportTypeEnum._
+import hmda.publication.reports.aggregate.A53
+import hmda.publication.reports.protocol.{ ApplicantIncomeProtocol, MSAReportProtocol, ReportTypeEnumProtocol }
+import spray.json._
+
+object A53Protocol
+    extends DefaultJsonProtocol
+    with ReportTypeEnumProtocol
+    with MSAReportProtocol
+    with ApplicantIncomeProtocol {
+
+  implicit object A53Format extends RootJsonFormat[A53] {
+    override def write(obj: A53): JsValue = {
+      JsObject(
+        "table" -> JsString("5-3"),
+        "type" -> JsString(Aggregate.toString),
+        "desc" -> JsString(obj.description),
+        "year" -> JsNumber(obj.year),
+        "reportDate" -> JsString(obj.reportDate),
+        "msa" -> obj.msa.toJson,
+        "applicantIncomes" -> obj.applicantIncomes.toJson,
+        "total" -> obj.total.toJson
+      )
+    }
+
+    override def read(json: JsValue): A53 = json.asJsObject.getFields(
+      "table",
+      "type",
+      "desc",
+      "year",
+      "reportDate",
+      "msa",
+      "applicantIncomes",
+      "total"
+    ) match {
+        case Seq(table, reportType, description, year, reportDate, msa, applicantIncomes, total) =>
+          A53(
+            year.convertTo[Int],
+            msa.convertTo[MSAReport],
+            applicantIncomes.convertTo[List[ApplicantIncome]],
+            total.convertTo[List[Disposition]],
+            reportDate.convertTo[String]
+          )
+      }
+  }
+
+}

publication/src/test/scala/hmda/publication/reports/aggregate/A53ProtocolSpec.scala

@@ -0,0 +1,31 @@
+package hmda.publication.reports.aggregate
+
+import hmda.publication.reports.protocol.aggregate.A53Protocol._
+import org.scalatest.{ MustMatchers, PropSpec }
+import org.scalatest.prop.PropertyChecks
+import spray.json._
+import AggregateReportGenerators._
+
+class A53ProtocolSpec extends PropSpec with PropertyChecks with MustMatchers {
+
+  property("A53 Report must convert to and from JSON") {
+    forAll(a53Gen) { a53 =>
+      a53.toJson.convertTo[A53] mustBe a53
+    }
+  }
+
+  property("A53 Report must serialize to the correct JSON format") {
+    forAll(a53Gen) { a53 =>
+      a53.toJson mustBe JsObject(
+        "table" -> JsString("5-3"),
+        "type" -> JsString("Aggregate"),
+        "desc" -> JsString("Disposition of Applications to Refinance Loans on 1-to-4 Family and Manufactured Home Dwellings, by Income, Race, and Ethnicity of Applicant"),
+        "year" -> JsNumber(a53.year),
+        "reportDate" -> JsString(a53.reportDate),
+        "msa" -> a53.msa.toJson,
+        "applicantIncomes" -> a53.applicantIncomes.toJson,
+        "total" -> a53.total.toJson
+      )
+    }
+  }
+}

publication/src/test/scala/hmda/publication/reports/aggregate/A53Spec.scala

@@ -0,0 +1,65 @@
+package hmda.publication.reports.aggregate
+
+import akka.NotUsed
+import akka.actor.ActorSystem
+import akka.stream.ActorMaterializer
+import akka.stream.scaladsl.Source
+import hmda.model.fi.lar.{ LarGenerators, LoanApplicationRegister }
+import hmda.model.publication.reports.ActionTakenTypeEnum._
+import hmda.model.publication.reports.ApplicantIncomeEnum.LessThan50PercentOfMSAMedian
+import hmda.model.publication.reports.{ EthnicityBorrowerCharacteristic, MSAReport, MinorityStatusBorrowerCharacteristic, RaceBorrowerCharacteristic }
+import hmda.query.model.filing.LoanApplicationRegisterQuery
+import hmda.query.repository.filing.LarConverter._
+import org.scalacheck.Gen
+import org.scalatest.{ AsyncWordSpec, BeforeAndAfterAll, MustMatchers }
+
+class A53Spec extends AsyncWordSpec with MustMatchers with LarGenerators with BeforeAndAfterAll {
+
+  implicit val system = ActorSystem()
+  implicit val ec = system.dispatcher
+  implicit val materializer = ActorMaterializer()
+
+  override def afterAll(): Unit = {
+    super.afterAll()
+    system.terminate()
+  }
+
+  val fips = 18700 //Corvallis, OR
+  def propType = Gen.oneOf(1, 2).sample.get
+
+  val lars = lar100ListGen.sample.get.map { lar: LoanApplicationRegister =>
+    val geo = lar.geography.copy(msa = fips.toString)
+    val loan = lar.loan.copy(loanType = 1, propertyType = propType, purpose = 1)
+    lar.copy(geography = geo, loan = loan)
+  }
+
+  val source: Source[LoanApplicationRegisterQuery, NotUsed] = Source
+    .fromIterator(() => lars.toIterator)
+    .map(lar => toLoanApplicationRegisterQuery(lar))
+
+  val expectedDispositions = List(ApplicationReceived, LoansOriginated, ApprovedButNotAccepted, ApplicationsDenied, ApplicationsWithdrawn, ClosedForIncompleteness)
+
+  "Generate an Aggregate 5-3 report" in {
+    A53.generate(source, fips).map { result =>
+
+      result.msa mustBe MSAReport("18700", "Corvallis, OR", "OR", "Oregon")
+      result.table mustBe "5-3"
+      result.applicantIncomes.size mustBe 5
+
+      val lowestIncome = result.applicantIncomes.head
+      lowestIncome.applicantIncome mustBe LessThan50PercentOfMSAMedian
+
+      val races = lowestIncome.borrowerCharacteristics.head.asInstanceOf[RaceBorrowerCharacteristic].races
+      races.size mustBe 8
+
+      val ethnicities = lowestIncome.borrowerCharacteristics(1).asInstanceOf[EthnicityBorrowerCharacteristic].ethnicities
+      ethnicities.size mustBe 4
+
+      val minorityStatuses = lowestIncome.borrowerCharacteristics(2).asInstanceOf[MinorityStatusBorrowerCharacteristic].minoritystatus
+      minorityStatuses.size mustBe 2
+
+      races.head.dispositions.map(_.disposition) mustBe expectedDispositions
+    }
+  }
+
+}

publication/src/test/scala/hmda/publication/reports/aggregate/AggregateReportGenerators.scala

@@ -16,4 +16,14 @@ object AggregateReportGenerators {
       total <- totalDispositionGen
     } yield A52(year, msa, applicantIncomes, total, reportDate)
   }
+
+  implicit def a53Gen: Gen[A53] = {
+    for {
+      msa <- msaReportGen
+      year = Calendar.getInstance().get(Calendar.YEAR)
+      reportDate = formatDate(Calendar.getInstance().toInstant)
+      applicantIncomes <- Gen.listOfN(5, applicantIncomeGen)
+      total <- totalDispositionGen
+    } yield A53(year, msa, applicantIncomes, total, reportDate)
+  }
 }