first commit

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

     }
 
     @RequestMapping(value = "/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
-    private ResponseEntity<String> getListOfPersonsByTvSerieitle(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
+    private ResponseEntity<String> getListOfPersonsForTvSerie(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
       akkaStreamFilesProcessing.getPersonsTeamForTvSerie(tvSerieTitle);
        return new ResponseEntity<>("is running", HttpStatus.OK);
     }

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

 
 //noinspection SpellCheckingInspection
 trait AkkaStreamFileProcessing {
-  def getAllPersons(): Unit
-
   def getPersonById(nconst: String): Future[Person]
   def getPersonByName(primaryName: String): Future[IndexedSeq[Person]]
 
-  def getAllTvSeries(): Unit
-
   def getByTvSeriePrimaryTitle(tvSerieTitle: String):Future[Seq[TvSeries]]
 
-  def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String)
-
-
+  def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String): Future[List[Person]]
+  def getAllTvSeries(): Unit
+  def getAllPersons(): Unit
 }

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

 
   override def getPersonById(nconst: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
-
-
     val res = source
       .via(flow = filterByPersonIdFlow(nconst = nconst))
       .runWith(Sink.head)
       case Failure(exception) => logger.info(s"$exception")
       case Success(value) => logger.info(s"$value")
     }
-
   }
 
   private def getTvSerieIdByPrimaryTitle(primaryTitle: String): Future[Option[String]] = {
       .filter((rowMap: Map[String, String]) => {
         rowMap.getOrElse(key = "primaryTitle", "") == primaryTitle
       })
-      .map((rowMap: Map[String, String]) => {
-        rowMap.get("tconst")
-      })
+      .map((rowMap: Map[String, String]) => rowMap.get("tconst"))
       .runWith(Sink.head)
 
     res
-
   }
 
-  private def getListOfPersonsIDByTvSerieID(tvSerieID: Future[Option[String]]): Future[IndexedSeq[Option[String]]]={
+  private def getListOfPersonsIDByTvSerieID(tvSerieID: Future[Option[String]]): Future[List[Option[String]]]={
     val source: Source[Map[String, String], _] = buildSource(inputFile = titlePrincipalsBasics)
 
-    val res: Future[IndexedSeq[Option[String]]] = source
+    val res: Future[List[Option[String]]] = source
       .filter((rowMaps: Map[String, String])=>{
         rowMaps.getOrElse(key = "tconst", default = "")==tvSerieID.value.get.get.get
       })
         rowMap.get(key = "nconst")
       })
       .runWith(Sink.collection)
-
     res
-
   }
 
-  private def getListOfPersonsForTvSerie(listPersonsIDs: Future[IndexedSeq[Option[String]]]): Future[IndexedSeq[Person]] = {
+  private def getListOfPersonsForTvSerie(listPersonsIDs: Future[List[Option[String]]]): Future[List[Person]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
 
-    val res : Future[IndexedSeq[Person]]=
+    val res : Future[List[Person]]=
       source
         .filter((rowMaps: Map[String, String])=>{
           listPersonsIDs.value.get.get.contains(rowMaps.get(key = "nconst"))
 
     res
   }
-  override def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String):Unit={
+  override def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String):Future[List[Person]]={
 
     logger.info("STEP 1/3")
     val tvSerieID = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
-    tvSerieID.onComplete({
-      case Failure(exception) => logger.error(s"$exception")
+    tvSerieID.andThen({
+      case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!1$exception")
       case Success(value: Option[String]) =>
         logger.info(s"TvSerie ID: $value")
         logger.info("END STEP 1/3")
     })
     logger.info("STEP 2/3")
-    val listPersonIDs = getListOfPersonsIDByTvSerieID(tvSerieID = tvSerieID)
-    listPersonIDs.onComplete({
-      case Failure(exception) => logger.error(s"$exception")
-      case Success(value) =>
-        value.toList.foreach((personID: Option[String])=>logger.info(s"Person ID:$personID"))
+    val listPersonIDs: Future[List[Option[String]]] = getListOfPersonsIDByTvSerieID(tvSerieID = tvSerieID)
+    listPersonIDs.andThen({
+      case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!!2$exception")
+      case Success(value: List[Option[String]]) =>
+        value.foreach((personID:Option[String])=>logger.info(s"Person ID:$personID"))
         logger.info("END STEP 2/3")
     })
 
     logger.info("STEP 3/3")
-    val personsTeam= getListOfPersonsForTvSerie(listPersonsIDs = listPersonIDs)
-    personsTeam.onComplete({
-      case Failure(exception) => logger.error(s"$exception")
+    val personsTeam: Future[List[Person]] = getListOfPersonsForTvSerie(listPersonsIDs = listPersonIDs)
+    personsTeam.andThen({
+      case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!!!!3$exception")
       case Success(value) =>
-        logger.info(s"${value.toList}")
-        value.toList.foreach((person:Person)=>logger.info(s"${person.toString}"))
+        logger.info(s"$value")
+        value.foreach((person:Person)=>logger.info(s"${person.toString}"))
         logger.info("END STEP 3/3")
     })
 
+   null
   }
-
 }