first commit

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

 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
 
-import java.util.Collection;
-import java.util.List;
-
 @RestController
 public class MovieController {
 
         return new ResponseEntity<>("is running", HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/movies/id/{tvSerieID}", method = RequestMethod.GET)
-    private ResponseEntity<String> getListOfPersonsIDByTvSerieID(@PathVariable(name = "tvSerieID") String tvSerieID){
-       akkaStreamFilesProcessing.getListOfPersonsIDByTvSerieID(tvSerieID);
+    @RequestMapping(value = "/movies/title/{tvSerieTitle}", method = RequestMethod.GET)
+    private ResponseEntity<String> getListOfPersonsIDByTvSerieID(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
+        akkaStreamFilesProcessing.generalize(tvSerieTitle);
        return new ResponseEntity<>("is running", HttpStatus.OK);
     }
 }

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

 
   //source building
 
-  def buildSource(inputFile: File): Source[Map[String, String], _] = {
+  def buildSource(inputFile: File): Source[Map[String, String], NotUsed] = {
 
     var datasource: Source[Map[String, String], NotUsed] = null
     if (!fileExists(inputFile.getPath)) {

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

 
   def getByTvSeriePrimaryTitle(tvSerieTitle: String): Unit
 
-  def getListOfPersonsIDByTvSerieID(tconst: String): List[Option[String]]
+  def generalize(tvSeriePrimaryTitle: String): Unit
+
+
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
 import akka.actor.ActorSystem
-import akka.stream.ActorAttributes.supervisionStrategy
-import akka.stream.Supervision.resumingDecider
 import akka.stream.scaladsl.{Flow, Sink, Source}
 import akka.{Done, NotUsed}
 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.ModelsBuilder.buildTvSerieModel
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAllPersonsSink, buildAndValidateSource, buildPersonFlow, buildPersonSink, buildSource, buildTvSerieFlow, buildTvSeriesSink, filterByPersonIdFlow, filterByPersonNameFlow, filterByTvSeriePrimaryTitleFlow}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.{buildPersonModel, buildTvSerieModel}
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
+  buildAllPersonsSink,
+  buildAndValidateSource,
+  buildPersonFlow,
+  buildPersonSink,
+  buildSource,
+  buildTvSerieFlow,
+  buildTvSeriesSink,
+  filterByPersonIdFlow,
+  filterByPersonNameFlow,
+  filterByTvSeriePrimaryTitleFlow
+}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 import scala.concurrent.{Await, Future}
 import scala.language.postfixOps
 import scala.util.{Failure, Success}
-import scala.collection.immutable.Iterable
 
 @Component
 class AkkaStreamFileProcessingImpl extends AkkaStreamFileProcessing {
     tconst
   }
 
-  def getListOfPersonsIDByTvSerieID(tconst: String): List[Option[String]]={
+  private def getListOfPersonsIDByTvSerieID(tconst: String): List[Option[String]]={
     val source: Source[Map[String, String], _] = buildSource(inputFile = titlePrincipalsBasics)
-    var tvSeries: Iterable[TvSeries]=null
 
     val startTime : Long = System.currentTimeMillis()
     val res: Future[IndexedSeq[Option[String]]] = source
       .map((rowMap: Map[String, String])=>{
         rowMap.get(key = "nconst")
       })
-      .withAttributes(supervisionStrategy(resumingDecider))
       .runWith(Sink.collection)
       .andThen {
         case Success(value) =>
         case Failure(error: Error) => logger.error(s"$error")
       }
 
-    Await.result(res,5 minutes)
+    Await.result(res, 3 minutes)
     val listPersonsID: List[Option[String]] = res.value.get.get.toList
 
     listPersonsID
 
   }
 
+  private def getListOfPersonsForTvSerie(nconstList: List[Option[String]]): List[Person] = {
+    val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
+
+    val startTime: Long = System.currentTimeMillis()
+
+    val res : Future[IndexedSeq[Person]]= source
+      .filter((rowMap: Map[String, String])=>{
+        nconstList.contains(rowMap.getOrElse(key = "nconst",default = ""))
+      })
+      .map((rowMap: Map[String, String])=>{
+        val person: Person = buildPersonModel(rowMap)
+        person
+      })
+      .runWith(Sink.collection)
+      .andThen {
+        case Failure(exception) => logger.error(s"$exception")
+        case Success(value) =>
+          val elapsedTime: Long = (System.currentTimeMillis()-startTime)/1000
+          logger.info(s"$value")
+          logger.info(s"END: Successfully, elapsed time: $elapsedTime")
+      }
+
+    Await.result(res, 4 minutes)
+    val listPersons: List[Person] = res.value.get.get.toList
+
+    listPersons
+
+  }
+
+  override def generalize(tvSeriePrimaryTitle: String): Unit={
+
+    val tvSerieID: String = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
+    val listPersonIDs: List[Option[String]] = getListOfPersonsIDByTvSerieID(tconst = tvSerieID)
+    getListOfPersonsForTvSerie(nconstList = listPersonIDs)
+  }
 
 }