first commit

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

 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamFileProcessingFuture;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
         IndexedSeq<ModelsAndJsonMap.Person> personIndexedSeq = seqCompletableFuture.get();
         List<String> personsList = new ArrayList<>();
         personIndexedSeq.foreach(person ->{
-            JsValue personJs = Json.toJson(person, person.personJsonFormatter());
-            personsList.add(Json.prettyPrint(personJs));
+            JsValue personJsV = Json.toJson(person, person.personJsonFormatter());
+            personsList.add(Json.prettyPrint(personJsV));
             return null;
         });
 
     }
 
     @RequestMapping(value = "/persons", method = RequestMethod.GET)
-    private ResponseEntity<String> getAllPersons() {
-        akkaStreamFilesProcessing.getAllPersonsFuture();
-        return new ResponseEntity<>("is running", HttpStatus.OK);
+    private List<String> getAllPersons() throws ExecutionException, InterruptedException {
+       Future<IndexedSeq<ModelsAndJsonMap.Person>> indexedSeqFuture = akkaStreamFilesProcessing.getMaxPersonsFuture();
+       CompletableFuture<IndexedSeq<ModelsAndJsonMap.Person>> completableFuture =
+               CompletableFutureBuilder.buildcompletableFuture2(indexedSeqFuture);
+       IndexedSeq<ModelsAndJsonMap.Person> personIndexedSeq = completableFuture.get();
+       List<String> personList = new ArrayList<>();
+       personIndexedSeq.foreach(person ->{
+           JsValue personJsV = Json.toJson(person, person.personJsonFormatter());
+           personList.add(Json.prettyPrint(personJsV));
+           return null;
+       });
+
+       return personList;
     }
 
     @RequestMapping(value = "/tvseries", method = RequestMethod.GET)
-    private ResponseEntity<String> getAllvSeries() {
-        akkaStreamFilesProcessing.getAllTvSeriesFuture();
-        return new ResponseEntity<>("is running", HttpStatus.OK);
+    private List<String> getMaxTvSeries() throws ExecutionException, InterruptedException {
+        Future<IndexedSeq<ModelsAndJsonMap.TvSerie>> futureTvSeries= akkaStreamFilesProcessing.getMaxTvSeriesFuture();
+       CompletableFuture<IndexedSeq<ModelsAndJsonMap.TvSerie>> seqCompletableFuture = CompletableFutureBuilder
+                .buildcompletableFuture2(futureTvSeries);
+
+        IndexedSeq<ModelsAndJsonMap.TvSerie> tvSerieIndexedSeq = seqCompletableFuture.get();
+        List<String> tvSerieList = new ArrayList<>();
+        tvSerieIndexedSeq.foreach(tvSerie ->{
+            JsValue tvSerieJsV = Json.toJson(tvSerie, tvSerie.tvSerieJsonFormatter());
+            tvSerieList.add(Json.prettyPrint(tvSerieJsV));
+            return null;
+        });
+
+        return tvSerieList;
+    }
+
+    @RequestMapping(value = "/episodes", method = RequestMethod.GET)
+    private List<String> getMaxEpisodes() throws ExecutionException, InterruptedException {
+        Future<IndexedSeq<ModelsAndJsonMap.Episode>> seqFuture = akkaStreamFilesProcessing.getMaxEpisodes();
+        CompletableFuture<IndexedSeq<ModelsAndJsonMap.Episode>> completableFuture =
+                CompletableFutureBuilder.buildcompletableFuture2(seqFuture);
+        IndexedSeq<ModelsAndJsonMap.Episode> episodeIndexedSeq = completableFuture.get();
+
+        List<String> episodeList = new ArrayList<>();
+        episodeIndexedSeq.foreach(episode->{
+            JsValue episodeJsV = Json.toJson(episode, episode.episodeFormatter());
+            episodeList.add(Json.prettyPrint(episodeJsV));
+            return null;
+        });
+
+        return episodeList;
     }
 }

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

         return completableFuture;
     }
 
-    public static <T> CompletableFuture<IndexedSeq<T>> buildcompletableFuture2(Future<IndexedSeq<T>> futureListT) {
+    public static <T> CompletableFuture<IndexedSeq<T>> buildcompletableFuture2(Future<IndexedSeq<T>> futureIndexedSeqT) {
 
         CompletableFuture<IndexedSeq<T>> completableFuture = new CompletableFuture<>();
         Executors.newSingleThreadExecutor().submit(() -> {
-            while (!futureListT.isCompleted()) {
+            while (!futureIndexedSeqT.isCompleted()) {
                 try {
                     TimeUnit.MILLISECONDS.sleep(300);
                 } catch (InterruptedException e) {
                     throw new RuntimeException(e);
                 }
+
             }
 
-            IndexedSeq<T> task = futureListT.value().get().get();
+            IndexedSeq<T> task = futureIndexedSeqT.value().get().get();
             completableFuture.complete(task);
 
         });

src/main/scala/fr/natan/akkastreamfileprocessingapi/datasource/Datasource.scala

   val titleBasics: File = new File("../title.basics.tsv.gz")
   val nameBasics: File = new File("../name.basics.tsv.gz")
   val titlePrincipalsBasics: File = new File("../title.principals.tsv.gz")
+  val titleEpisode: File = new File("../title.episode.tsv.gz")
+  val MAXI_ROWS : Int = 10000
 }

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

 
   final case class Person(personID: String,
                           primaryName: String,
-                          birthYear: String,
-                          deathYear: String,
+                          birthYear: Option[String],
+                          deathYear: Option[String],
                           primaryProfession: List[String],
                           knownForTitles: List[String]
                          ) {
                            primaryTitle: String,
                            originalTitle: String,
                            startYear: String,
-                           endYear: String,
+                           endYear: Option[String],
                            runtimeMinutes: String,
                            genres: List[String]
                           ) {
       )
 
   }
+
+
+  final case class Episode(
+                            id: String,
+                            parentId: String,
+                            seasonNumber: Option[String],
+                            episodeNumber: Option[String]
+                          ){
+    implicit val episodeFormatter : Writes[Episode] =
+      (episode:Episode) => Json.obj(
+        "episode id"-> episode.id,
+        "parent id"-> episode.parentId,
+        "season number"->episode.seasonNumber,
+        "episode number"->episode.episodeNumber
+      )
+  }
 }

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

 package fr.natan.akkastreamfileprocessingapi.models
-import ModelsAndJsonMap.{Person, TvSerie}
+import ModelsAndJsonMap.{Episode, Person, TvSerie}
 object ModelsBuilder {
 
-  def buildPersonModel(personMap: Map[String, String]): Person =
-  {
+  def buildPersonModel(personMap: Map[String, String]): Person = {
     Person(
       personMap("nconst"),
       personMap("primaryName"),
-      personMap("birthYear"),
-      personMap("deathYear"),
+      Option( personMap("birthYear")),
+      Option(personMap("deathYear")),
       personMap("primaryProfession").split(",").toList,
       personMap("knownForTitles").split(",").toList
     )
   }
 
-  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSerie =
-  {
+  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSerie = {
     val tvSerie: TvSerie = TvSerie(
       tvSerieMap("tconst"),
       tvSerieMap("titleType"),
       tvSerieMap("primaryTitle"),
       tvSerieMap("originalTitle"),
       tvSerieMap("startYear"),
-      tvSerieMap("endYear"),
+      Option(tvSerieMap("endYear")),
       tvSerieMap("runtimeMinutes"),
       tvSerieMap("genres").split(",").toList
     )
     tvSerie
   }
+
+  def buildEpisodeModel(episodeMap: Map[String, String]): Episode = {
+    val episode: Episode = Episode(
+      episodeMap("tconst"),
+      episodeMap("parentTconst"),
+      Option(episodeMap("seasonNumber")),
+      Option(episodeMap("episodeNumber")),
+    )
+
+    episode
+  }
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
+import akka.NotUsed
 import akka.actor.ActorSystem
 import akka.stream.alpakka.csv.scaladsl.{CsvParsing, CsvToMap}
 import akka.stream.scaladsl.{Compression, FileIO, Flow, Sink, Source}
-import akka.{Done, NotUsed}
-import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.businessexceptions.FileNotFoundException
-import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
-import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.{buildPersonModel, buildTvSerieModel}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Episode, Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.{buildEpisodeModel, buildPersonModel, buildTvSerieModel}
 import fr.natan.akkastreamfileprocessingapi.valitator.Validators.fileExists
 
 import java.io.File
   implicit val actorSystem: ActorSystem = ActorSystem("AkkaStreamActor")
 
   //flows building
-  def buildPersonFlow(): Flow[Map[String, String], Person, NotUsed] = {
+  def buildPersonFlow (): Flow[Map[String, String], Person, NotUsed] = {
     val personFlow: Flow[Map[String, String], Person, NotUsed] =
       Flow[Map[String, String]]
         .map((rowMap: Map[String, String]) => {
     personFlow
   }
 
-  def filterPersonByIdFlow(personID: String): Flow[Map[String, String], Person, NotUsed]={
-    val personFlowFilter: 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="")==personID
+        .filter((rowMap: Map[String, String]) => {
+          rowMap.getOrElse(key = "nconst", default = "") == personID
         })
-        .map(rowMap=>{
+        .map(rowMap => {
           buildPersonModel(personMap = rowMap)
         })
 
     personFlowFilter
   }
 
-  def filterPersonByNameFlow(primaryName: String): 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
+        .filter((rowMap: Map[String, String]) => {
+          rowMap.getOrElse(key = "primaryName", default = "") == primaryName
         })
-        .map((rowMap: Map[String, String])=>{
+        .map((rowMap: Map[String, String]) => {
           buildPersonModel(personMap = rowMap)
         })
 
     tvSerieFlow
   }
 
-  def filterTvSerieByIdFlow(tvSerieID: String): Flow[Map[String, String], TvSerie, NotUsed] = {
-    val tvSerieFlowFilter : Flow[Map[String, String], TvSerie, NotUsed] =
+  def buildEpisodeFlow (): Flow[Map[String, String], Episode, NotUsed] ={
+    val episodeFlow: Flow[Map[String, String], Episode, NotUsed] =
       Flow[Map[String, String]]
-        .filter((rowMap: Map[String, String])=>rowMap.getOrElse(key = "tconst", default = "")==tvSerieID)
         .map((rowMap: Map[String, String])=>{
+          buildEpisodeModel(episodeMap = rowMap)
+        })
+
+    episodeFlow
+  }
+
+  //filters flow
+  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]) => {
   }
 
   //sinks building
+  def buildMaxPersonsSink(): Sink[Person, Future[IndexedSeq[Person]]] = {
+    val listPersonsSink: Sink[Person, Future[IndexedSeq[Person]]] =
+      Sink.collection[Person, IndexedSeq[Person]]
+    listPersonsSink
+  }
 
-  def buildAllTvSeriesSink(logger: Logger): Sink[TvSerie, Future[Done]] = {
-    val tvSeriesSink: Sink[TvSerie, Future[Done]] = Sink
-      .foreach((tvSerie: TvSerie)=>logger.info(s"${tvSerie.toString}"))
+  def buildMaxTvSeriesSink(): Sink[TvSerie, Future[IndexedSeq[TvSerie]]] = {
+    val tvSeriesSink: Sink[TvSerie, Future[IndexedSeq[TvSerie]]] = Sink
+      .collection[TvSerie, IndexedSeq[TvSerie]]
     tvSeriesSink
   }
-  def buildAllPersonsSink(logger: Logger): Sink[Person,Future[Done]] = {
-    val listPersonsSink: Sink[Person, Future[Done]]=
-      Sink.foreach((person: Person)=>logger.info(s"${person.toString}"))
-    listPersonsSink
+
+  def buildMaxEpisodesSink(): Sink[Episode, Future[IndexedSeq[Episode]]] = {
+    val episodeSink: Sink[Episode, Future[IndexedSeq[Episode]]] = Sink
+      .collection[Episode, IndexedSeq[Episode]]
+    episodeSink
   }
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
-import akka.Done
-import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Episode, Person, TvSerie}
 
 import scala.concurrent.Future
 
 
   def getPersonsForTvSerieByTvSerieTitleFuture(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]]
   def getPersonsForTvSerieByTvSerieIDFuture(tvSerieId: String): Future[IndexedSeq[Person]]
-  def getAllTvSeriesFuture: Future[Done]
-  def getAllPersonsFuture: Future[Done]
+  def getMaxPersonsFuture: Future[IndexedSeq[Person]]
+  def getMaxTvSeriesFuture: Future[IndexedSeq[TvSerie]]
+  def getMaxEpisodes: Future[IndexedSeq[Episode]]
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
-import akka.Done
 import akka.stream.scaladsl.{Sink, Source}
 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.businessexceptions.PersonNotFoundException
-import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics, titlePrincipalsBasics}
-import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{actorSystem, buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow, buildTvSerieFlow, filterPersonByIdFlow, filterPersonByNameFlow, filterTvSerieByIdFlow, filterTvSerieByPrimaryTitleFlow}
-import fr.natan.akkastreamfileprocessingapi.service.UtilitiesClass.{getListOfPersonsForTvSerie, getListOfPersonsIDByTvSerieID, getTvSerieIDFuture, getTvSerieIdByPrimaryTitle}
+import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{
+  MAXI_ROWS,
+  nameBasics,
+  titleBasics,
+  titleEpisode,
+  titlePrincipalsBasics
+}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Episode, Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
+  actorSystem,
+  buildAndValidateSource,
+  buildEpisodeFlow,
+  buildMaxEpisodesSink,
+  buildMaxPersonsSink,
+  buildMaxTvSeriesSink,
+  buildPersonFlow,
+  buildTvSerieFlow,
+  filterPersonByIdFlow,
+  filterPersonByNameFlow,
+  filterTvSerieByIdFlow,
+  filterTvSerieByPrimaryTitleFlow
+}
+import fr.natan.akkastreamfileprocessingapi.service.UtilitiesClass.{
+  getListOfPersonsForTvSerie,
+  getListOfPersonsIDByTvSerieID,
+  getTvSerieIDFuture,
+  getTvSerieIdByPrimaryTitle
+}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 
     personFuture.onComplete({
       case Failure(exception) => throw new PersonNotFoundException()
-      case Success(value:Option[Person]) =>logger.info(s"${value.get}")
+      case Success(value: Option[Person]) => logger.info(s"${value.get}")
     })
 
     personFuture
 
   }
 
-  override def getAllPersonsFuture: Future[Done] = {
+  override def getMaxPersonsFuture: Future[IndexedSeq[Person]] = {
     val personSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = nameBasics)
     //graph
     val startTime: Long = System.currentTimeMillis()
-    val result: Future[Done] = personSource
+    val result: Future[IndexedSeq[Person]] = personSource
       .via(flow = buildPersonFlow())
-      .runWith(sink = buildAllPersonsSink(logger = logger))
-
-    result.onComplete {
-      case Failure(exception) => logger.error(s"$exception")
-      case Success(value) =>
-        logger.info(s"$value")
-        val time: Long = (System.currentTimeMillis() - startTime) / 100
-        logger.info(s"elapsed time: $time")
-    }
+      .take(n = MAXI_ROWS)
+      .runWith(sink = buildMaxPersonsSink())
+
     result
   }
 
-  override def getAllTvSeriesFuture: Future[Done] = {
+  override def getMaxTvSeriesFuture: Future[IndexedSeq[TvSerie]] = {
     val source: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
-    val sink: Sink[TvSerie, Future[Done]] = buildAllTvSeriesSink(logger = logger)
 
     val startingTime: Long = System.currentTimeMillis()
     //graph sink->flow->sink
-    val results: Future[Done] = source
+    val results: Future[IndexedSeq[TvSerie]] = source
       .via(flow = buildTvSerieFlow())
-      .runWith(sink = sink)
-      .andThen {
-        case Success(value) =>
-          val elapsedTime: Long = (System.currentTimeMillis() - startingTime) / 1000
-          logger.info(s"$value: successfully processing file, elapsed time $titleBasics: $elapsedTime sec")
-        case Failure(error: Error) => logger.error(s"$error")
-      }
+      .take(n = MAXI_ROWS)
+      .runWith(sink = buildMaxTvSeriesSink())
 
     results
   }
+
+  override def getMaxEpisodes: Future[IndexedSeq[Episode]] = {
+    val source: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleEpisode)
+
+    val listEpisodeFuture: Future[IndexedSeq[Episode]] = source
+      .via(flow = buildEpisodeFlow())
+      .take(n = MAXI_ROWS)
+      .runWith(sink = buildMaxEpisodesSink())
+
+    listEpisodeFuture
+  }
 }
 
 
+

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

 
     tvSerieIdFuture
   }
-
 }