first commit

pom.xml

             <version>2.1.2</version>
         </dependency>
 
-        <!-- https://mvnrepository.com/artifact/io.spray/spray-json -->
+        <!-- https://mvnrepository.com/artifact/com.typesafe.play/play-json -->
         <dependency>
-            <groupId>io.spray</groupId>
-            <artifactId>spray-json_2.12</artifactId>
-            <version>1.3.6</version>
+            <groupId>com.typesafe.play</groupId>
+            <artifactId>play-json_2.12</artifactId>
+            <version>2.10.0-RC7</version>
         </dependency>
 
 

src/main/java/fr/natan/akkastreamfileprocessingapi/controller/MovieController.java

 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamFileProcessing;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.scheduling.annotation.Async;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
+import play.api.libs.json.JsValue;
+import play.api.libs.json.Json;
 import scala.collection.IndexedSeq;
+import scala.collection.immutable.List;
 import scala.concurrent.Future;
 
 import java.util.concurrent.CompletableFuture;
 public class MovieController {
 
     private final AkkaStreamFileProcessing akkaStreamFilesProcessing;
-
+    private final CompletableFutureResult completableFutureResult;
     public MovieController(AkkaStreamFileProcessing akkaStreamFilesProcessing) {
         this.akkaStreamFilesProcessing = akkaStreamFilesProcessing;
+        completableFutureResult = new CompletableFutureResult();
     }
 
     @RequestMapping(value = "/persons/id/{personID}", method = RequestMethod.GET)
     private ResponseEntity<String> getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
         Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonById(personID);
-        CompletableFuture<Models.Person> completableFutureResult =
-                new CompletableFutureResult().buildcompletableFuture(personFuture);
-
-        return new ResponseEntity<>(completableFutureResult.get().toString(), HttpStatus.OK);
+        CompletableFuture<Models.Person> personCompletableFuture = this.completableFutureResult.buildcompletableFuture(personFuture);
+        Models.Person person = personCompletableFuture.get();
+        JsValue personJs = Json.toJson(person, person.personFormat());
+        return new ResponseEntity<>(personJs.toString(), HttpStatus.OK);
     }
 
     @RequestMapping(value = "/persons/name/{primaryName}", method = RequestMethod.GET)
-    private ResponseEntity<IndexedSeq<String>> getPersonByName(@PathVariable(name = "primaryName") String primaryName) throws ExecutionException, InterruptedException {
-        Future<IndexedSeq<Models.Person>> personsFuture = akkaStreamFilesProcessing.getPersonByName(primaryName);
-        CompletableFuture completableFutureResult =new
-                CompletableFutureResult().buildCompletableFuture2(personsFuture);
-        IndexedSeq<String> list = (IndexedSeq<String>) completableFutureResult.get();
-        return new ResponseEntity<>(list, HttpStatus.OK);
+    private ResponseEntity<String> getPersonByName(@PathVariable(name = "primaryName") String primaryName)
+            throws ExecutionException, InterruptedException {
+
+        Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonByName(primaryName);
+        CompletableFuture completableFutureResult = this.completableFutureResult.buildcompletableFuture(personFuture);
+       Models.Person person = (Models.Person) completableFutureResult.get();
+       JsValue personJs = Json.toJson(person, person.personFormat());
+        return new ResponseEntity<>(personJs.toString(), HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/tvseries/{tvseriePrimaryTitle}", method = RequestMethod.GET)
-    private Future<IndexedSeq<Models.TvSeries>> getTvserieByPrimaryTitle(@PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) {
-        return akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
+    @RequestMapping(value = "/tvseries/id/{tvSerieId}", method = RequestMethod.GET)
+    private ResponseEntity<String> getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID) throws ExecutionException, InterruptedException {
+        Future<Models.TvSerie> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieById(tvSerieID);
+        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = this.completableFutureResult.buildcompletableFuture(tvSerieFuture);
+        Models.TvSerie tvSerie = tvSerieCompletableFuture.get();
+        JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
+
+        return new ResponseEntity<>(tvSerieJs.toString(), HttpStatus.OK);
+    }
+
+    @RequestMapping(value = "/tvseries/title/{tvseriePrimaryTitle}", method = RequestMethod.GET)
+    private ResponseEntity<List<Models.TvSerie>> getTvserieByPrimaryTitle(@PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) {
+       List<Models.TvSerie> listFuture = akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
+
+       return new ResponseEntity<>(listFuture, HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
-    @Async
+    @RequestMapping(value = "/persons/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
     private Future<IndexedSeq<Models.Person>> getPersonsForTvSerie(@PathVariable(name = "tvSerieTitle") String tvSerieTitle) {
         return akkaStreamFilesProcessing.getTeamOfPersonsForTvSerie(tvSerieTitle);
     }

src/main/java/fr/natan/akkastreamfileprocessingapi/futurecompleteness/CompletableFutureResult.java

 package fr.natan.akkastreamfileprocessingapi.futurecompleteness;
 
-import scala.collection.IndexedSeq;
 import scala.concurrent.Future;
 
+import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 
 
     public CompletableFuture<T> buildcompletableFuture(Future<T> future){
         CompletableFuture<T> completableFuture = new CompletableFuture<>();
-        Executors.newCachedThreadPool().submit(()->{
-            Thread.sleep(500);
+        Executors.newSingleThreadExecutor().submit(()->{
+            Thread.sleep(new Random().nextInt(500-200)+200);
             return completableFuture.complete(future.value().get().get());
         });
-        return completableFuture;
-    }
 
-    public CompletableFuture<IndexedSeq<T>> buildCompletableFuture2(Future<IndexedSeq<T>> futures){
-        CompletableFuture<IndexedSeq<T>> completableFuture = new CompletableFuture<>();
-        Executors.newCachedThreadPool().submit(
-                ()->{
-                    Thread.sleep(500);
-                    return completableFuture.complete(futures.value().get().get().seq());
-                }
-        );
         return completableFuture;
     }
+
 }

src/main/scala/fr/natan/akkastreamfileprocessingapi/models/Models.scala

 package fr.natan.akkastreamfileprocessingapi.models
 
+import play.api.libs.json.{JsValue, Json, Writes}
+
 object Models {
 
-  final case class Person(nconst: String, primaryName: String, birthYear: String, deathYear: String,
-                          primaryProfession: List[String], knownForTitles: List[String]) {
-    override def toString: String = {
-      "Person[person-ID:" + nconst +
-        ", primary-name:" + primaryName +
-        ", birth-year:" + birthYear +
-        ", dearth-year:" + deathYear +
-        ", primary-profession:" + primaryProfession +
-        ", known-for-titles" + knownForTitles +
-        "]"
-    }
+  final case class Person(
+                           personID: String,
+                           primaryName: String,
+                           birthYear: String,
+                           deathYear: String,
+                           primaryProfession: List[String],
+                           knownForTitles: List[String]
+                         ) {
 
+    implicit val personFormat = new Writes[Person] {
+      override def writes(person: Person): JsValue = Json.obj(
+        "person id" -> person.personID,
+        "primary name" -> person.primaryName,
+        "birth year" -> person.birthYear,
+        "death year" -> person.deathYear,
+        "primary profession" -> person.primaryProfession,
+        "known for titles" -> person.knownForTitles
+      )
+    }
   }
 
-  final case class TvSeries(
-                             tconst: String,
-                             titleType: String,
-                             primaryTitle: String,
-                             originalTitle: String,
-                             startYear: String,
-                             endYear: String,
-                             runtimeMinutes: String,
-                             genres: String
-                           ) {
+  final case class TvSerie(
+                            tvSerieID: String,
+                            titleType: String,
+                            primaryTitle: String,
+                            originalTitle: String,
+                            startYear: String,
+                            endYear: String,
+                            runtimeMinutes: String,
+                            genres: List[String]
+                          ) {
 
-    override def toString: String = {
-      "TvSerie[tvSerieID : " + tconst +
-        ", title-type:" + titleType +
-        ", primary-title:" + primaryTitle + "" +
-        ", riginal-title:" + originalTitle +
-        ", start year:" + startYear +
-        ", end year:" + endYear +
-        ", runtime minutes:" + runtimeMinutes +
-        ", genres:" + genres + "]"
+    implicit val tvSerieFormat = new Writes[TvSerie] {
+      override def writes(tvSerie: TvSerie): JsValue = Json.obj(
+        "tv serie id" -> tvSerie.tvSerieID,
+        "tv serie type" -> tvSerie.titleType,
+        "primary title" -> tvSerie.primaryTitle,
+        "original title" -> tvSerie.originalTitle,
+        "start year" -> tvSerie.startYear,
+        "end year" -> tvSerie.endYear,
+        "runtime minutes" -> tvSerie.runtimeMinutes,
+        "genres" -> tvSerie.genres
+      )
     }
   }
-
 }

src/main/scala/fr/natan/akkastreamfileprocessingapi/models/ModelsBuilder.scala

 package fr.natan.akkastreamfileprocessingapi.models
-import Models.{Person, TvSeries}
+import Models.{Person, TvSerie}
 object ModelsBuilder {
 
   def buildPersonModel(personMap: Map[String, String]): Person = {
     )
   }
 
-  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSeries = {
-    val tvSerie: TvSeries = TvSeries(
+  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSerie = {
+    val tvSerie: TvSerie = TvSerie(
       tvSerieMap("tconst"),
       tvSerieMap("titleType"),
       tvSerieMap("primaryTitle"),
       tvSerieMap("startYear"),
       tvSerieMap("endYear"),
       tvSerieMap("runtimeMinutes"),
-      tvSerieMap("genres")
+      tvSerieMap("genres").split(",").toList
     )
     tvSerie
   }

src/main/scala/fr/natan/akkastreamfileprocessingapi/service/AkkaStreamComponents.scala

 import akka.{Done, NotUsed}
 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.businessexceptions.FileNotFoundException
-import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSeries}
+import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
 import fr.natan.akkastreamfileprocessingapi.valitator.Validators.fileExists
 import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.{buildPersonModel, buildTvSerieModel}
 
   implicit val actor: ActorSystem = ActorSystem("AkkaStreamActor")
 
   //flows building
-
   def buildPersonFlow(): Flow[Map[String, String], Person, NotUsed] = {
     val personFlow: Flow[Map[String, String], Person, NotUsed] =
       Flow[Map[String, String]]
     personFlow
   }
 
-  def filterByTvSeriePrimaryTitleFlow(tvSeriePrimaryTitle: String): Flow[Map[String, String], TvSeries, NotUsed] = {
-    val filterFlow: Flow[Map[String, String], TvSeries, NotUsed] = Flow[Map[String, String]]
-        .filter((rows: Map[String, String]) => {
-          rows.getOrElse(key = "primaryTitle", default = "")==tvSeriePrimaryTitle
-        })
-        .map(rowMap => {
-          val tvSerie: TvSeries = buildTvSerieModel(tvSerieMap = rowMap)
-          tvSerie
-        })
-
-    filterFlow
-  }
-
-  def filterByPersonIdFlow(nconst: String): Flow[Map[String, String], Person, NotUsed]={
-    val personFilter: Flow[Map[String, String], Person, NotUsed]=
+  def filterPersonByIdFlow(personID: String): Flow[Map[String, String], Person, NotUsed]={
+    val personFlowFilter: Flow[Map[String, String], Person, NotUsed]=
       Flow[Map[String, String]]
         .filter((rowMap:Map[String, String])=>{
-          rowMap.getOrElse(key="nconst",default="")==nconst
+          rowMap.getOrElse(key="nconst",default="")==personID
         })
         .map(rowMap=>{
           buildPersonModel(personMap = rowMap)
         })
 
-    personFilter
+    personFlowFilter
   }
 
-  def filterByPersonNameFlow(primaryName: String): Flow[Map[String, String], Person, NotUsed] ={
-    val personFilter: Flow[Map[String, String], Person, NotUsed] =
+  def filterPersonByNameFlow(primaryName: String): Flow[Map[String, String], Person, NotUsed] ={
+    val personFlowFilter: Flow[Map[String, String], Person, NotUsed] =
       Flow[Map[String, String]]
         .filter((rowMap: Map[String, String]) =>{
           rowMap.getOrElse(key = "primaryName", default = "")==primaryName
           buildPersonModel(personMap = rowMap)
         })
 
-    personFilter
+    personFlowFilter
   }
 
-  def buildTvSerieFlow(): Flow[Map[String, String], TvSeries, NotUsed] = {
+  def buildTvSerieFlow(): Flow[Map[String, String], TvSerie, NotUsed] = {
 
-    val tvFlow: Flow[Map[String, String], TvSeries, NotUsed] =
+    val tvSerieFlow: Flow[Map[String, String], TvSerie, NotUsed] =
       Flow[Map[String, String]]
         .map((rowMap: Map[String, String]) => {
           buildTvSerieModel(tvSerieMap = rowMap)
         })
-    tvFlow
+    tvSerieFlow
   }
+
+  def filterTvSerieByIdFlow(tvSerieID: String): Flow[Map[String, String], TvSerie, NotUsed] = {
+    val tvSerieFlowFilter : Flow[Map[String, String], TvSerie, NotUsed] =
+      Flow[Map[String, String]]
+        .filter((rowMap: Map[String, String])=>rowMap.getOrElse(key = "tconst", default = "")==tvSerieID)
+        .map((rowMap: Map[String, String])=>{
+          buildTvSerieModel(tvSerieMap = rowMap)
+        })
+
+    tvSerieFlowFilter
+  }
+  def filterTvSerieByPrimaryTitleFlow(tvSeriePrimaryTitle: String): Flow[Map[String, String], TvSerie, NotUsed] = {
+    val filterFlowFilter: Flow[Map[String, String], TvSerie, NotUsed] = Flow[Map[String, String]]
+      .filter((rows: Map[String, String]) => {
+        rows.getOrElse(key = "primaryTitle", default = "") == tvSeriePrimaryTitle
+      })
+      .map(rowMap => {
+        val tvSerie: TvSerie = buildTvSerieModel(tvSerieMap = rowMap)
+        tvSerie
+      })
+
+    filterFlowFilter
+  }
+
   //source building
 
   def buildSource(inputFile: File): Source[Map[String, String], NotUsed] = {
 
   //sinks building
 
-  def buildAllTvSeriesSink(logger: Logger): Sink[TvSeries, Future[Done]] = {
-    val tvSeriesSink: Sink[TvSeries, Future[Done]] = Sink
-      .foreach((tvSerie: TvSeries)=>logger.info(s"${tvSerie.toString}"))
+  def buildAllTvSeriesSink(logger: Logger): Sink[TvSerie, Future[Done]] = {
+    val tvSeriesSink: Sink[TvSerie, Future[Done]] = Sink
+      .foreach((tvSerie: TvSerie)=>logger.info(s"${tvSerie.toString}"))
     tvSeriesSink
   }
   def buildAllPersonsSink(logger: Logger): Sink[Person,Future[Done]] = {

src/main/scala/fr/natan/akkastreamfileprocessingapi/service/AkkaStreamFileProcessing.scala

 package fr.natan.akkastreamfileprocessingapi.service
 
-import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSeries}
+import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
 
 import scala.concurrent.Future
 
 //noinspection SpellCheckingInspection,AccessorLikeMethodIsUnit
 trait AkkaStreamFileProcessing {
   def getPersonById(personID: String): Future[Person]
-  def getPersonByName(primaryName: String): Future[IndexedSeq[Person]]
+  def getPersonByName(primaryName: String): Future[Person]
 
-  def getTvSerieByPrimaryTitle(tvSerieTitle: String):Future[IndexedSeq[TvSeries]]
+  def getTvSerieById(tvSerieID: String): Future[TvSerie]
+  def getTvSerieByPrimaryTitle(tvSerieTitle: String):List[TvSerie]
 
   def getTeamOfPersonsForTvSerie(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]]
   def getAllTvSeries(): Unit

src/main/scala/fr/natan/akkastreamfileprocessingapi/service/AkkaStreamFileProcessingImpl.scala

 package fr.natan.akkastreamfileprocessingapi.service
 
+import akka.Done
 import akka.actor.ActorSystem
-import akka.stream.scaladsl.{Flow, Sink, Source}
-import akka.{Done, NotUsed}
+import akka.stream.scaladsl.{Sink, Source}
 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics, titlePrincipalsBasics}
-import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSeries}
+import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
 import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.buildPersonModel
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
-  buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow, buildSource, buildTvSerieFlow,
-  filterByPersonIdFlow, filterByPersonNameFlow, filterByTvSeriePrimaryTitleFlow
-}
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow, buildSource, buildTvSerieFlow, filterPersonByIdFlow, filterPersonByNameFlow, filterTvSerieByIdFlow, filterTvSerieByPrimaryTitleFlow}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.Future
+import scala.concurrent.duration.DurationInt
+import scala.concurrent.{Await, Future}
 import scala.language.postfixOps
 import scala.util.{Failure, Success}
 
   override def getPersonById(personID: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
     val res: Future[Person] = source
-      .via(flow = filterByPersonIdFlow(nconst = personID))
+      .via(flow = filterPersonByIdFlow(personID = personID))
       .runWith(Sink.head)
 
-    res.andThen {
+    res.onComplete({
       case Failure(exception) => logger.info(s"$exception")
-      case Success(value) => logger.info(s"$value")
-    }
+      case Success(value:Person) => logger.info(s"$value")
+    })
 
     res
   }
 
-  override def getPersonByName(primaryName: String): Future[IndexedSeq[Person]] = {
+  override def getPersonByName(primaryName: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
-    val persons: Future[IndexedSeq[Person]] = source
-      .via(flow = filterByPersonNameFlow(primaryName = primaryName))
-      .runWith(Sink.collection)
+    val persons: Future[Person] = source
+      .via(flow = filterPersonByNameFlow(primaryName = primaryName))
+      .runWith(Sink.head)
 
     persons.onComplete({
       case Failure(exception) => logger.error(s"$exception")
-      case Success(value: IndexedSeq[Person]) =>
-        value.foreach((person: Person) => logger.info(s"$person"))
+      case Success(value: Person) => logger.info(s"$value")
         logger.info("SUCCESS")
     })
 
     persons
   }
 
-  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String): Future[IndexedSeq[TvSeries]] = {
+  override def getTvSerieById(tvSerieID: String): Future[TvSerie] = {
+    val source: Source[Map[String, String], _] = buildSource(inputFile = titleBasics)
+    val res: Future[TvSerie] = source
+      .via(flow = filterTvSerieByIdFlow(tvSerieID = tvSerieID))
+      .runWith(Sink.head)
 
-    val tvSeriesSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
+    res.onComplete({
+      case Failure(exception) => logger.info(s"$exception")
+      case Success(value: TvSerie) => logger.info(s"$value")
+    })
+    res
+  }
+  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String): List[TvSerie] = {
 
-    val filterByTvSerieTitle: Flow[Map[String, String], TvSeries, NotUsed] =
-      filterByTvSeriePrimaryTitleFlow(tvSeriePrimaryTitle = tvSeriePrimaryTitle)
+    val tvSeriesSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
 
-    val tvSries: Future[IndexedSeq[TvSeries]] = tvSeriesSource
-      .via(flow = filterByTvSerieTitle)
+    val tvSries: Future[List[TvSerie]] = tvSeriesSource
+      .via(flow = filterTvSerieByPrimaryTitleFlow(tvSeriePrimaryTitle = tvSeriePrimaryTitle))
       .runWith(Sink.collection)
 
     tvSries.onComplete({
       case Failure(exception) => logger.info(s"$exception")
-      case Success(value: IndexedSeq[TvSeries]) =>
-        value.foreach((tvSrie: TvSeries) => logger.info(s"$tvSrie"))
+      case Success(value: List[TvSerie]) =>
+        value.foreach((tvSrie: TvSerie) => logger.info(s"$tvSrie"))
         logger.info("SUCCESS")
     })
-
-    tvSries
+    Await.result(tvSries,2 minutes)
+    val tvSriesList : List[TvSerie] = tvSries.value.get.get
+    tvSriesList
   }
 
+
   private def getTvSerieIdByPrimaryTitle(primaryTitle: String): Future[Option[String]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = titleBasics)
 
 
   override def getAllTvSeries(): Unit = {
     val source: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
-    val sink: Sink[TvSeries, Future[Done]] = buildAllTvSeriesSink(logger = logger)
+    val sink: Sink[TvSerie, Future[Done]] = buildAllTvSeriesSink(logger = logger)
 
     val startingTime: Long = System.currentTimeMillis()
     //graph sink->flow->sink
         case Failure(error: Error) => logger.error(s"$error")
       }
   }
-
 }