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;
 
+@SuppressWarnings("SpellCheckingInspection")
 @RestController
 public class MovieController {
 
     }
 
     @RequestMapping(value = "/persons", method = RequestMethod.GET)
-    private ResponseEntity<String> getallPersons(){
+    private ResponseEntity<String> getAllPersons(){
         akkaStreamFilesProcessing.getAllPersons();
         return new ResponseEntity<>("is running", HttpStatus.OK);
     }
     }
 
     @RequestMapping(value = "/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
-    private ResponseEntity<String> getListOfPersonsIDByTvSerieID(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
+    private ResponseEntity<String> getListOfPersonsByTvSerieitle(@PathVariable(name = "tvSerieTitle") String tvSerieTitle){
       akkaStreamFilesProcessing.getPersonsTeamForTvSerie(tvSerieTitle);
        return new ResponseEntity<>("is running", HttpStatus.OK);
     }

src/main/resources/application.yml

 server:
-  port: 8090
+  port: 8091
   servlet:
     context-path: /path
 spring:

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

 
 import java.io.File
 import java.nio.file.Paths
-import java.util
 import scala.concurrent.Future
 
+//noinspection SpellCheckingInspection
 object AkkaStreamComponents {
 
   implicit val actor: ActorSystem = ActorSystem("AkkaStreamActor")
 
   //flows building
 
-  //flow1
   def buildPersonFlow(): Flow[Map[String, String], Person, NotUsed] = {
     val personFlow: Flow[Map[String, String], Person, NotUsed] =
       Flow[Map[String, String]]
     personFlow
   }
 
-  //flow2
-
-  def buildTvSerieFlow(): Flow[Map[String, String], TvSeries, NotUsed] = {
-
-    val tvFlow: Flow[Map[String, String], TvSeries, NotUsed] =
-      Flow[Map[String, String]]
-        .map(row => {
-          buildTvSerieModel(row)
-        })
-    tvFlow
-  }
-
-  //flow3
   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]) => {
     filterFlow
   }
 
-  //flow4
   def filterByPersonIdFlow(nconst: String): Flow[Map[String, String], Person, NotUsed]={
     val personFilter: Flow[Map[String, String], Person, NotUsed]=
       Flow[Map[String, String]]
     personFilter
   }
 
-  //flow5
-  def filterByPersonNameFlow(personName: String): Flow[Map[String, String], Person, NotUsed] ={
+  def filterByPersonNameFlow(primaryName: String): Flow[Map[String, String], Person, NotUsed] ={
     val personFilter: Flow[Map[String, String], Person, NotUsed] =
       Flow[Map[String, String]]
         .filter((rowMap: Map[String, String]) =>{
-          rowMap.getOrElse(key = "primaryName", default = "")==personName
+          rowMap.getOrElse(key = "primaryName", default = "")==primaryName
         })
         .map((rowMap: Map[String, String])=>{
           buildPersonModel(personMap = rowMap)
     personFilter
   }
 
+  def buildTvSerieFlow(): Flow[Map[String, String], TvSeries, NotUsed] = {
+
+    val tvFlow: Flow[Map[String, String], TvSeries, NotUsed] =
+      Flow[Map[String, String]]
+        .map((rowMap: Map[String, String]) => {
+          buildTvSerieModel(tvSerieMap = rowMap)
+        })
+    tvFlow
+  }
   //source building
 
   def buildSource(inputFile: File): Source[Map[String, String], NotUsed] = {
       }
       )
       .via(Compression.gunzip())
-      .via(CsvParsing.lineScanner(CsvParsing.Tab))
+      .via(CsvParsing.lineScanner(CsvParsing.Tab, CsvParsing.DoubleQuote, CsvParsing.DoubleQuote))
       .via(CsvToMap.toMapAsStrings())
 
     datasource
   }
 
   //sinks building
-  //sink1
-  def buildTvSeriesSink(logger: Logger): Sink[TvSeries, Future[Done]] = {
-    val tvSeriesSink : Sink[TvSeries, Future[Done]]= Sink
-      .foreach((tvSerie: TvSeries)=> logger.info(s"${tvSerie.toString}"))
-    tvSeriesSink
-  }
 
   def buildAllTvSeriesSink(logger: Logger): Sink[TvSeries, Future[Done]] = {
     val tvSeriesSink: Sink[TvSeries, Future[Done]] = Sink
       .foreach((tvSerie: TvSeries)=>logger.info(s"${tvSerie.toString}"))
     tvSeriesSink
   }
-  //sink2
   def buildAllPersonsSink(logger: Logger): Sink[Person,Future[Done]] = {
     val listPersonsSink: Sink[Person, Future[Done]]=
       Sink.foreach((person: Person)=>logger.info(s"${person.toString}"))
     listPersonsSink
   }
-
-  //sink3
-  def buildPersonSink(): Sink[Person, Future[Person]] = {
-    Sink.head
-  }
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
-import akka.stream.scaladsl.Source
 import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSeries}
 
 import scala.concurrent.Future
 
+//noinspection SpellCheckingInspection
 trait AkkaStreamFileProcessing {
   def getAllPersons(): Unit
 
   def getPersonById(nconst: String): Future[Person]
-  def getPersonByName(primaryName: String): Unit
+  def getPersonByName(primaryName: String): Future[IndexedSeq[Person]]
 
   def getAllTvSeries(): Unit
 

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

 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.{buildPersonModel, buildTvSerieModel}
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow, buildPersonSink, buildSource, buildTvSerieFlow, buildTvSeriesSink, filterByPersonIdFlow, filterByPersonNameFlow, filterByTvSeriePrimaryTitleFlow}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.buildPersonModel
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
+  buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow,
+  buildSource, buildTvSerieFlow, filterByPersonIdFlow, filterByPersonNameFlow, filterByTvSeriePrimaryTitleFlow}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.duration.DurationInt
-import scala.concurrent.{Await, Future}
+import scala.concurrent.Future
 import scala.language.postfixOps
 import scala.util.{Failure, Success}
 
+//noinspection SpellCheckingInspection
 @Component
 class AkkaStreamFileProcessingImpl extends AkkaStreamFileProcessing {
 
   implicit val actorSystem: ActorSystem = ActorSystem("AkkaStreamActor")
   implicit val logger: Logger = Logger(LoggerFactory.getLogger(this.getClass))
 
-  override def getAllPersons() = {
+  override def getAllPersons(): Unit = {
     val personSource: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
     //graph
     val startTime: Long = System.currentTimeMillis()
       case Failure(exception) => logger.error(s"$exception")
       case Success(value) =>
         logger.info(s"$value")
-        val time: Long =(System.currentTimeMillis()-startTime)/100
+        val time: Long = (System.currentTimeMillis() - startTime) / 100
         logger.info(s"elapsed time: $time")
     }
   }
   override def getPersonById(nconst: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
 
-    val startTime: Long = System.currentTimeMillis()
+
     val res = source
       .via(flow = filterByPersonIdFlow(nconst = nconst))
-      .runWith(sink = buildPersonSink())
+      .runWith(Sink.head)
 
     res.andThen {
-      case Failure(exception) => logger.info(s"error!!!!!!!!!!!!!$exception")
+      case Failure(exception) => logger.info(s"$exception")
       case Success(value) => logger.info(s"$value")
     }
 
     res
   }
 
-  override def getPersonByName(primaryName: String): Unit = {
+  override def getPersonByName(primaryName: String): Future[IndexedSeq[Person]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
-    source
-      .via(
-        flow = filterByPersonNameFlow(personName = primaryName)
-      )
-      .runWith(sink = buildPersonSink())
-      .andThen {
-        case Failure(exception) => logger.info(s"$exception")
-        case Success(value) => logger.info(s"$value: Successufully processing")
-      }
+    val persons: Future[IndexedSeq[Person]] = source
+      .via(flow = filterByPersonNameFlow(primaryName = primaryName))
+      .runWith(Sink.collection)
+
+    persons
   }
 
   override def getAllTvSeries(): Unit = {
 
   }
 
-  private def getTvSerieIdByPrimaryTitle(primaryTitle: String): String = {
+  private def getTvSerieIdByPrimaryTitle(primaryTitle: String): Future[Option[String]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = titleBasics)
 
-    var tvSerie: TvSeries = null
     val res: Future[Option[String]] = source
       .filter((rowMap: Map[String, String]) => {
         rowMap.getOrElse(key = "primaryTitle", "") == primaryTitle
       })
       .map((rowMap: Map[String, String]) => {
-        tvSerie = buildTvSerieModel(rowMap)
         rowMap.get("tconst")
       })
       .runWith(Sink.head)
 
-    Await.result(res, 1 minutes)
-    val tconst: String = res.value.get.get.get
-    logger.info(s"TvSerie ID: $tconst, $tvSerie")
-    tconst
+    res
+
   }
 
-  private def getListOfPersonsIDByTvSerieID(tconst: String): List[Option[String]]={
+  private def getListOfPersonsIDByTvSerieID(tvSerieID: Future[Option[String]]): Future[IndexedSeq[Option[String]]]={
     val source: Source[Map[String, String], _] = buildSource(inputFile = titlePrincipalsBasics)
 
-    val startTime : Long = System.currentTimeMillis()
     val res: Future[IndexedSeq[Option[String]]] = source
       .filter((rowMaps: Map[String, String])=>{
-        rowMaps.getOrElse(key = "tconst", default = "")==tconst
+        rowMaps.getOrElse(key = "tconst", default = "")==tvSerieID.value.get.get.get
       })
       .map((rowMap: Map[String, String])=>{
         rowMap.get(key = "nconst")
       })
       .runWith(Sink.collection)
-      .andThen {
-        case Success(value) =>
-          logger.info(s"$value")
-          val elapsedTime : Long = (System.currentTimeMillis() - startTime)/1000
-          logger.info(s"success, elapsed time: $elapsedTime")
-
-        case Failure(error: Error) => logger.error(s"$error")
-      }
-
-    Await.result(res, 3 minutes)
-    val listPersonsID: List[Option[String]] = res.value.get.get.toList
 
-    listPersonsID
+    res
 
   }
 
-  private def getListOfPersonsForTvSerie(nconstList: List[Option[String]]): List[Person] = {
+  private def getListOfPersonsForTvSerie(listPersonsIDs: Future[IndexedSeq[Option[String]]]): Future[IndexedSeq[Person]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
 
-    val startTime: Long = System.currentTimeMillis()
-
     val res : Future[IndexedSeq[Person]]=
       source
         .filter((rowMaps: Map[String, String])=>{
-          nconstList.contains(rowMaps.get(key = "nconst"))
+          listPersonsIDs.value.get.get.contains(rowMaps.get(key = "nconst"))
         })
       .map((rowMap: Map[String, String])=>{
        buildPersonModel(rowMap)
       })
       .runWith(Sink.collection)
-      .andThen {
-        case Failure(exception) => logger.error(s"$exception")
-        case Success(value) =>
-          val elapsedTime: Long = (System.currentTimeMillis()-startTime)/1000
-          logger.info(s"END: Successfully, elapsed time: $elapsedTime")
-      }
-
-    Await.result(res, 4 minutes)
-    val listPersons: List[Person] = res.value.get.get.toList
-
-    listPersons
 
+    res
   }
   override def getPersonsTeamForTvSerie(tvSeriePrimaryTitle: String):Unit={
 
-    val tvSerieID: String = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
-    val listPersonIDs: List[Option[String]] = getListOfPersonsIDByTvSerieID(tconst = tvSerieID)
-    val personsTeam: List[Person] = getListOfPersonsForTvSerie(nconstList = listPersonIDs)
+    logger.info("STEP 1/3")
+    val tvSerieID = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
+    tvSerieID.onComplete({
+      case Failure(exception) => logger.error(s"$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"))
+        logger.info("END STEP 2/3")
+    })
 
-    logger.info(s"Team size:${personsTeam.size}")
-    personsTeam.foreach((person: Person)=>{
-      logger.info(s"${person.toString}")
+    logger.info("STEP 3/3")
+    val personsTeam= getListOfPersonsForTvSerie(listPersonsIDs = listPersonIDs)
+    personsTeam.onComplete({
+      case Failure(exception) => logger.error(s"$exception")
+      case Success(value) =>
+        logger.info(s"${value.toList}")
+        value.toList.foreach((person:Person)=>logger.info(s"${person.toString}"))
+        logger.info("END STEP 3/3")
     })
 
   }

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

+package fr.natan.akkastreamfileprocessingapi.service
+
+import org.springframework.stereotype.Component
+
+@Component
+class CompleteFuture {
+
+}