Add Disclosure 5-3 report and protocol

Author: schbetsy

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

@@ -1,3 +1,4 @@
 ReportId,Type,ReportNumber,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"
 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/disclosure/D53.scala

@@ -0,0 +1,77 @@
+package hmda.publication.reports.disclosure
+
+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 D53(
+  respondentId: String,
+  institutionName: String,
+  year: Int,
+  msa: MSAReport,
+  applicantIncomes: List[ApplicantIncome],
+  total: List[Disposition],
+  reportDate: String = formattedCurrentDate,
+  table: String = D53.metaData.reportTable,
+  description: String = D53.metaData.description
+) extends DisclosureReport
+
+object D53 {
+  val metaData = ReportsMetaDataLookup.values("D53")
+  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,
+    respondentId: String,
+    institutionNameF: Future[String]
+  ): Future[D53] = {
+
+    val lars = larSource
+      .filter(lar => lar.respondentId == respondentId)
+      .filter(lar => lar.msa != "NA")
+      .filter(lar => lar.msa.toInt == fipsCode)
+      .filter { lar =>
+        (lar.loanType == 2 || lar.loanType == 3 || lar.loanType == 4) &&
+          (lar.propertyType == 1 || lar.propertyType == 2) &&
+          (lar.purpose == 1)
+      }
+    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 {
+      institutionName <- institutionNameF
+      year <- yearF
+      applicantIncomes <- applicantIncomesF
+      total <- totalF
+    } yield {
+
+      D53(
+        respondentId,
+        institutionName,
+        year,
+        msa,
+        applicantIncomes,
+        total
+      )
+    }
+
+  }
+
+}

publication/src/main/scala/hmda/publication/reports/disclosure/DisclosureReports.scala

@@ -33,6 +33,8 @@ class DisclosureReports(val sys: ActorSystem, val mat: ActorMaterializer) extend
     d51F.map { d51 =>
       println(d51.toJson.prettyPrint)
     }
+
+    //val d53F = D53.generate(larSource, fipsCode, respId, institutionNameF)
   }
 
   private def institutionName(respondentId: String): Future[String] = {

publication/src/main/scala/hmda/publication/reports/protocol/disclosure/D53Protocol.scala

@@ -0,0 +1,58 @@
+package hmda.publication.reports.protocol.disclosure
+
+import hmda.model.publication.reports.{ ApplicantIncome, Disposition, MSAReport }
+import hmda.model.publication.reports.ReportTypeEnum.Disclosure
+import hmda.publication.reports.disclosure.D53
+import hmda.publication.reports.protocol.{ ApplicantIncomeProtocol, MSAReportProtocol, ReportTypeEnumProtocol }
+
+import spray.json._
+import spray.json.DefaultJsonProtocol
+
+object D53Protocol
+    extends DefaultJsonProtocol
+    with ReportTypeEnumProtocol
+    with MSAReportProtocol
+    with ApplicantIncomeProtocol {
+
+  implicit object D53Format extends RootJsonFormat[D53] {
+
+    override def write(obj: D53): JsValue = {
+      JsObject(
+        "respondentId" -> JsString(obj.respondentId),
+        "institutionName" -> JsString(obj.institutionName),
+        "table" -> JsString("5-3"),
+        "type" -> JsString(Disclosure.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): D53 = json.asJsObject.getFields(
+      "respondentId",
+      "institutionName",
+      "table",
+      "type",
+      "desc",
+      "year",
+      "reportDate",
+      "msa",
+      "applicantIncomes",
+      "total"
+    ) match {
+        case Seq(respondentId, institutionName, table, reportType, description, year, reportDate, msa, applicantIncomes, total) =>
+          D53(
+            respondentId.convertTo[String],
+            institutionName.convertTo[String],
+            year.convertTo[Int],
+            msa.convertTo[MSAReport],
+            applicantIncomes.convertTo[List[ApplicantIncome]],
+            total.convertTo[List[Disposition]],
+            reportDate.convertTo[String]
+          )
+      }
+  }
+}

publication/src/test/scala/hmda/publication/reports/disclosure/D53ProtocolSpec.scala

@@ -0,0 +1,33 @@
+package hmda.publication.reports.disclosure
+
+import hmda.publication.reports.protocol.disclosure.D53Protocol._
+import org.scalatest.prop.PropertyChecks
+import org.scalatest.{ MustMatchers, PropSpec }
+import spray.json._
+import DisclosureReportGenerators._
+
+class D53ProtocolSpec extends PropSpec with PropertyChecks with MustMatchers {
+
+  property("D53 Report must convert to and from JSON") {
+    forAll(d53Gen) { d53 =>
+      d53.toJson.convertTo[D53] mustBe d53
+    }
+  }
+
+  property("D53 Report must serialize to the correct JSON format") {
+    forAll(d53Gen) { d53 =>
+      d53.toJson mustBe JsObject(
+        "respondentId" -> JsString(d53.respondentId),
+        "institutionName" -> JsString(d53.institutionName),
+        "table" -> JsString("5-3"),
+        "type" -> JsString("Disclosure"),
+        "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(d53.year),
+        "reportDate" -> JsString(d53.reportDate),
+        "msa" -> d53.msa.toJson,
+        "applicantIncomes" -> d53.applicantIncomes.toJson,
+        "total" -> d53.total.toJson
+      )
+    }
+  }
+}

publication/src/test/scala/hmda/publication/reports/disclosure/D53Spec.scala

@@ -0,0 +1,71 @@
+package hmda.publication.reports.disclosure
+
+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 }
+
+import scala.concurrent.Future
+
+class D53Spec 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 respId = "98765"
+  val fips = 18700 //Corvallis, OR
+  def loanType = Gen.oneOf(2, 3, 4).sample.get
+  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 = loanType, propertyType = propType, purpose = 1)
+    lar.copy(respondentId = respId, 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 a Disclosure 5-3 report" in {
+    D53.generate(source, fips, respId, Future("Corvallis Test Bank")).map { result =>
+
+      result.msa mustBe MSAReport("18700", "Corvallis, OR", "OR", "Oregon")
+      result.table mustBe "5-3"
+      result.respondentId mustBe "98765"
+      result.institutionName mustBe "Corvallis Test Bank"
+      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/disclosure/DisclosureReportGenerators.scala

@@ -19,4 +19,16 @@ object DisclosureReportGenerators {
     } yield D51(respId, instName, year, msa, applicantIncomes, total, reportDate)
   }
 
+  implicit def d53Gen: Gen[D53] = {
+    for {
+      respId <- Gen.alphaStr
+      instName <- Gen.alphaStr
+      year = Calendar.getInstance().get(Calendar.YEAR)
+      reportDate = formatDate(Calendar.getInstance().toInstant)
+      msa <- msaReportGen
+      applicantIncomes <- Gen.listOfN(5, applicantIncomeGen)
+      total <- totalDispositionGen
+    } yield D53(respId, instName, year, msa, applicantIncomes, total, reportDate)
+  }
+
 }