first commit

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

@@ -40,7 +40,7 @@ public class MovieController {
 
     @RequestMapping(value = "/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
     private Future<IndexedSeq<Models.Person>> getPersonsForTvSerie(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
-      return akkaStreamFilesProcessing.getPersonsTeamForTvSerie(tvSerieTitle);
+      return akkaStreamFilesProcessing.getTeamOfPersonsForTvSerie(tvSerieTitle);
     }
 
     @RequestMapping(value = "/persons", method = RequestMethod.GET)

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

@@ -4,14 +4,14 @@ import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSeries}
 
 import scala.concurrent.Future
 
-//noinspection SpellCheckingInspection
+//noinspection SpellCheckingInspection,AccessorLikeMethodIsUnit
 trait AkkaStreamFileProcessing {
   def getPersonById(nconst: String): Future[Person]
   def getPersonByName(primaryName: String): Future[IndexedSeq[Person]]
 
   def getTvSerieByPrimaryTitle(tvSerieTitle: String):Future[IndexedSeq[TvSeries]]
 
-  def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]]
+  def getTeamOfPersonsForTvSerie(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]]
   def getAllTvSeries(): Unit
   def getAllPersons(): Unit
 }

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

@@ -49,30 +49,30 @@ class AkkaStreamFileProcessingImpl extends AkkaStreamFileProcessing {
     persons.onComplete({
       case Failure(exception) => logger.error(s"$exception")
       case Success(value: IndexedSeq[Person]) =>
-        value.foreach((person: Person)=>logger.info(s"$person"))
+        value.foreach((person: Person) => logger.info(s"$person"))
         logger.info("SUCCESS")
     })
 
     persons
   }
 
-  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String):Future[IndexedSeq[TvSeries]] = {
+  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String): Future[IndexedSeq[TvSeries]] = {
 
     val tvSeriesSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
 
     val filterByTvSerieTitle: Flow[Map[String, String], TvSeries, NotUsed] =
       filterByTvSeriePrimaryTitleFlow(tvSeriePrimaryTitle = tvSeriePrimaryTitle)
 
-    val tvSries :Future[IndexedSeq[TvSeries]] = tvSeriesSource
+    val tvSries: Future[IndexedSeq[TvSeries]] = tvSeriesSource
       .via(flow = filterByTvSerieTitle)
       .runWith(Sink.collection)
 
-      tvSries.onComplete({
+    tvSries.onComplete({
       case Failure(exception) => logger.info(s"$exception")
       case Success(value: IndexedSeq[TvSeries]) =>
-        value.foreach((tvSrie: TvSeries)=>logger.info(s"$tvSrie"))
+        value.foreach((tvSrie: TvSeries) => logger.info(s"$tvSrie"))
         logger.info("SUCCESS")
-      })
+    })
 
     tvSries
   }
@@ -90,13 +90,13 @@ class AkkaStreamFileProcessingImpl extends AkkaStreamFileProcessing {
     res
   }
 
-  private def getListOfPersonsIDByTvSerieID(tvSerieID: Future[Option[String]]): Future[IndexedSeq[Option[String]]]={
+  private def getListOfPersonsIDByTvSerieID(tvSerieID: Future[Option[String]]): Future[IndexedSeq[Option[String]]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = titlePrincipalsBasics)
     val res: Future[IndexedSeq[Option[String]]] = source
-      .filter((rowMaps: Map[String, String])=>{
-        rowMaps.getOrElse(key = "tconst", default = "")==tvSerieID.value.get.get.get
+      .filter((rowMaps: Map[String, String]) => {
+        rowMaps.getOrElse(key = "tconst", default = "") == tvSerieID.value.get.get.get
       })
-      .map((rowMap: Map[String, String])=>{
+      .map((rowMap: Map[String, String]) => {
         rowMap.get(key = "nconst")
       })
       .runWith(Sink.collection)
@@ -107,53 +107,58 @@ class AkkaStreamFileProcessingImpl extends AkkaStreamFileProcessing {
   private def getListOfPersonsForTvSerie(listPersonsIDs: Future[IndexedSeq[Option[String]]]): Future[IndexedSeq[Person]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
 
-    val res : Future[IndexedSeq[Person]]=
+    val res: Future[IndexedSeq[Person]] =
       source
-        .filter((rowMaps: Map[String, String])=>{
+        .filter((rowMaps: Map[String, String]) => {
           listPersonsIDs.value.get.get.contains(rowMaps.get(key = "nconst"))
         })
-      .map((rowMap: Map[String, String])=>{
-       buildPersonModel(rowMap)
-      })
-      .runWith(Sink.collection)
+        .map((rowMap: Map[String, String]) => {
+          buildPersonModel(rowMap)
+        })
+        .runWith(Sink.collection)
 
     res
   }
-  override def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String):Future[IndexedSeq[Person]]={
 
-    logger.info("STEP 1/3")
-    val tvSerieID : Future[Option[String]]= getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
-    tvSerieID.andThen({
-      case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!1$exception")
+  override def getTeamOfPersonsForTvSerie(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]] = {
+
+    //futures chaining
+    logger.info("STEP 1/3 START")
+    val tvSerieIDFuture: Future[Option[String]] = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
+
+    val finalResult: Future[IndexedSeq[Person]] = tvSerieIDFuture.andThen({
+      case Failure(exception) => logger.error(s"$exception")
       case Success(value: Option[String]) =>
         logger.info(s"TvSerie ID: $value")
-        logger.info("END STEP 1/3")
-    }).flatMap({
-      future =>
-        logger.info("STEP 2/3")
-        val listPersonIDs: Future[IndexedSeq[Option[String]]] = getListOfPersonsIDByTvSerieID(tvSerieID = tvSerieID)
-        listPersonIDs.andThen({
-          case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!!2$exception")
-          case Success(value) =>
-            value.foreach((personID: Option[String]) => logger.info(s"Person ID:$personID"))
-            logger.info("END STEP 2/3")
-        }).flatMap({
-          future =>
-            logger.info("STEP 3/3")
-            val personsTeam: Future[IndexedSeq[Person]] = getListOfPersonsForTvSerie(listPersonsIDs = listPersonIDs)
-            personsTeam.andThen({
-              case Failure(exception) => logger.error(s"!!!!!!!!!!!!!!!!!!!!!!!3$exception")
-              case Success(value) =>
-                logger.info(s"$value")
-                value.foreach((person: Person) => logger.info(s"${person.toString}"))
-                logger.info("END STEP 3/3")
-            })
-        })
+        logger.info("STEP 1/3 END")
     })
+      .flatMap({
+       _ =>
+         logger.info("STEP 2/3 START")
+         val listPersonIDsFuture: Future[IndexedSeq[Option[String]]] = getListOfPersonsIDByTvSerieID(tvSerieID = tvSerieIDFuture)
+          listPersonIDsFuture.andThen({
+            case Failure(exception) => logger.error(s"$exception")
+            case Success(value) =>
+              value.foreach((personID: Option[String]) => logger.info(s"Person ID:$personID"))
+              logger.info("STEP 2/3 END")
+          })
+            .flatMap({
+              future =>
+                logger.info("STEP 3/3 START")
+                val personsTeamFuture: Future[IndexedSeq[Person]] = getListOfPersonsForTvSerie(listPersonsIDs = listPersonIDsFuture)
+                personsTeamFuture.andThen({
+                  case Failure(exception) => logger.error(s"$exception")
+                  case Success(value: IndexedSeq[Person]) =>
+                    value.foreach((person: Person) => logger.info(s"${person.toString}"))
+                    logger.info("STEP 3/3 END")
+                })
+            })
+      })
 
-   null
+    finalResult
   }
 
+
   override def getAllPersons(): Unit = {
     val personSource: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
     //graph