Add batch ULI validation (csv)

Author: jmarin

api-model/src/main/scala/hmda/api/model/public/ULIModel.scala

@@ -6,6 +6,8 @@ object ULIModel {
   case class ULI(loanId: String, checkDigit: Int, uli: String)
   case class ULICheck(uli: String)
   case class ULIValidated(isValid: Boolean)
-  case class ULIBatchValidated(uli: String, isValid: Boolean)
+  case class ULIBatchValidated(uli: String, isValid: Boolean) {
+    def toCSV: String = s"$uli,$isValid"
+  }
   case class ULIBatchValidatedResponse(ulis: Seq[ULIBatchValidated])
 }

api/src/main/scala/hmda/api/http/public/PublicHttpApi.scala

@@ -3,19 +3,19 @@ package hmda.api.http.public
 import akka.actor.ActorSystem
 import akka.event.LoggingAdapter
 import akka.stream.ActorMaterializer
-import akka.util.Timeout
+import akka.util.{ ByteString, Timeout }
 import hmda.api.http.HmdaCustomDirectives
 import akka.http.scaladsl.server.Directives._
 import hmda.api.model.public.ULIModel._
 import hmda.validation.engine.lar.ULI._
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
 import akka.http.scaladsl.marshalling.ToResponseMarshallable
-import akka.http.scaladsl.model.StatusCodes
-import akka.stream.scaladsl.Sink
+import akka.http.scaladsl.model.{ HttpCharsets, HttpEntity, StatusCodes }
+import akka.http.scaladsl.model.MediaTypes.`text/csv`
+import akka.stream.scaladsl.{ Sink, Source }
 import hmda.api.protocol.processing.ApiErrorProtocol
 import hmda.api.protocol.public.ULIProtocol
 import hmda.api.util.FlowUtils
-
 import scala.concurrent.ExecutionContext
 import scala.util.{ Failure, Success }
 
@@ -54,12 +54,7 @@ trait PublicHttpApi extends PublicLarHttpApi with HmdaCustomDirectives with ApiE
                   } ~
                     fileUpload("file") {
                       case (_, byteSource) =>
-                        val validatedF = byteSource
-                          .via(framing)
-                          .map(_.utf8String)
-                          .map(uli => (uli, validateULI(uli)))
-                          .map(validated => ULIBatchValidated(validated._1, validated._2))
-                          .runWith(Sink.seq)
+                        val validatedF = processUliFile(byteSource).runWith(Sink.seq)
 
                         onComplete(validatedF) {
                           case Success(validated) =>
@@ -73,8 +68,32 @@ trait PublicHttpApi extends PublicLarHttpApi with HmdaCustomDirectives with ApiE
                         complete(ToResponseMarshallable(StatusCodes.BadRequest))
                     }
                 }
+              } ~
+              path("validate" / "csv") {
+                timedPost { _ =>
+                  fileUpload("file") {
+                    case (_, byteSource) =>
+                      val validated = processUliFile(byteSource)
+                        .map(u => u.toCSV)
+                        .map(l => l + "\n")
+                        .map(s => ByteString(s))
+
+                      complete(HttpEntity.Chunked.fromData(`text/csv`.toContentType(HttpCharsets.`UTF-8`), validated))
+
+                    case _ =>
+                      complete(ToResponseMarshallable(StatusCodes.BadRequest))
+                  }
+                }
               }
           }
       }
     }
+
+  private def processUliFile(byteSource: Source[ByteString, Any]) = {
+    byteSource
+      .via(framing)
+      .map(_.utf8String)
+      .map(uli => (uli, validateULI(uli)))
+      .map(validated => ULIBatchValidated(validated._1, validated._2))
+  }
 }