first commit

pom.xml

             <artifactId>scala-logging-slf4j_2.11</artifactId>
             <version>2.1.2</version>
         </dependency>
-        
+
     </dependencies>
 
     <build>

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

         akkaStreamFilesProcessing.getAllPersons();
         return new ResponseEntity<>("is running", HttpStatus.OK);
     }
+
+    @RequestMapping(value = "/persons/{personID}", method = RequestMethod.GET)
+    private ResponseEntity<String> getPersonByID(@PathVariable(name = "personID") String nconst){
+       akkaStreamFilesProcessing.getPersonById(nconst);
+
+       return new ResponseEntity<>("is running", HttpStatus.OK);
+
+    }
 }

src/main/scala/fr/natan/akkastreamfileprocessingapi/jsonformat/ToJsonMapping.scala

+package fr.natan.akkastreamfileprocessingapi.jsonformat
+
+case class ToJsonMapping() {
+
+}

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

                          nconst: String,
                          primaryName: String,
                          birthYear: String,
-                         dearthYear: String,
+                         deathYear: String,
                          primaryProfession: List[String],
                          knownForTitles: List[String]
                        ){
   override def toString: String = {
-    "Person[ nconst:"+nconst+
-      ", primaryName:"+primaryName+
-    ", birthYear:"+birthYear+
-    ", dearthYear:"+dearthYear+
-    ", primaryProfession:"+primaryProfession+
-    ", knownForTitles:"+knownForTitles
+    "Person[ person-ID:"+nconst+
+      ", primary-name:"+primaryName+
+    ", birth-year:"+birthYear+
+    ", dearth year:"+deathYear+
+    ", primary profession:"+primaryProfession+
+    ", known for titles:"+knownForTitles+
+    "]"
   }
 }

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

                      startYear: String,
                     endYear: String,
                      runtimeMinutes: String,
-                     genre: String
+                     genres: String
                    ) {
 
   override def toString: String = {
       ", start year:"+startYear+
     ", end year:"+endYear+
       ", runtime minutes:"+runtimeMinutes+
-      ", genre:"+genre+"]"
+      ", genre:"+genres+"]"
   }
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
 import akka.actor.ActorSystem
+import akka.stream.alpakka.csv.scaladsl.{CsvParsing, CsvToMap}
 import akka.stream.javadsl.Framing
 import akka.stream.scaladsl.{Compression, FileIO, Flow, Sink, Source}
 import akka.util.ByteString
 
   implicit val actor: ActorSystem = ActorSystem("AkkaStreamActor")
 
-  private def convertToTvSerie(array: Array[String]): TvSeries = {
+  private def convertToTvSerie(map: Map[String, String]): TvSeries = {
     val tvSerie: TvSeries = TvSeries(
-      array(0),
-      array(1),
-      array(2),
-      array(3),
-      array(4),
-      array(5),
-      array(6),
-      array(7),
-      array(8))
+      map("tconst"),
+      map("titleType"),
+      map("primaryTitle"),
+      map("originalTitle"),
+      map("isAdult"),
+      map("startYear"),
+      map("endYear"),
+      map("runtimeMinutes"),
+      map("genres")
+    )
 
     tvSerie
   }
 
-  private def convertToPerson(array: Array[String]): Person ={
+  private def convertToPerson(map: Map[String, String]): Person ={
     Person(
-      array(0),
-      array(1),
-      array(2),
-      array(3),
-      array(4).split(",").toList,
-      array(5).split(",").toList,
+      map("nconst"),
+      map("primaryName"),
+      map("birthYear"),
+      map("deathYear"),
+      map("primaryProfession").split(",").toList,
+      map("knownForTitles").split(",").toList,
     )
   }
 
   //flows
 
-  def buildTvSerieFlow(movieID: String): Flow[String, TvSeries, NotUsed] = {
+  def buildTvSerieFlow(): Flow[Map[String, String], TvSeries, NotUsed] = {
 
-    val tvFlow: Flow[String, TvSeries, NotUsed] =
-      Flow[String].filter(rows => !rows.contains(movieID))
+    val tvFlow: Flow[Map[String, String], TvSeries, NotUsed] =
+      Flow[Map[String, String]]
         .map(row => {
-          val movie: Array[String] = row.split(separator)
-          convertToTvSerie(movie)
+          convertToTvSerie(row)
         })
     tvFlow
   }
 
-  def buildPersonFlow(personID: String): Flow[String, Person, NotUsed]={
-    val personFlow: Flow[String, Person, NotUsed] =
-      Flow[String]
-        .filterNot((rows: String)=>{
-          rows.contains(personID)
-        })
-        .map((row: String)=>{
-          convertToPerson(row.split(separator))
+  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]) => {
+          convertToPerson(rowMap)
         })
 
     personFlow
   }
-  def buildfilterByMoviePrimaryTitleFlow(moviePrimaryTitle: String): Flow[String, TvSeries, NotUsed] = {
-    val filterFlow: Flow[String, TvSeries, NotUsed] =
-      Flow[String]
-        .filter((rows: String) => {
-          rows.contains(moviePrimaryTitle)
+
+  def filterByMoviePrimaryTitleFlow(moviePrimaryTitle: String): Flow[Map[String, String], TvSeries, NotUsed] = {
+    val filterFlow: Flow[Map[String, String], TvSeries, NotUsed] = Flow[Map[String, String]]
+        .filter((rows: Map[String, String]) => {
+          rows.getOrElse("primaryTitle","")==moviePrimaryTitle
         })
-        .map(row => {
-          val movie: Array[String] = row.split("\t")
-          convertToTvSerie(movie)
+        .map(rowMap => {
+          convertToTvSerie(map = rowMap)
         })
 
     filterFlow
   }
+
+  def filterByPersonID(nconst: 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("nconst","")==nconst
+        })
+        .map(rowMap=>{
+          convertToPerson(map = rowMap)
+        })
+
+    personFilter
+  }
+
   //source
-  def buildSource(inputFile: File): Source[String, NotUsed] = {
+  def buildSource(inputFile: File): Source[Map[String, String], NotUsed] = {
 
-    var source: Source[String, NotUsed] = null
+    var datasource: Source[Map[String, String], NotUsed] = null
 
     if (!fileExists(inputFile.getPath)) {
       return null
     }
-    source = Source
+    datasource = Source
       .single(inputFile)
-      .flatMapConcat(
-        (file: File) =>
-          FileIO.fromPath(Paths.get(inputFile.getPath)
-          )
+      .flatMapConcat((filename: File) => {
+        FileIO.fromPath(
+          Paths.get(filename.getPath)
+        )
+      }
       )
       .via(Compression.gunzip())
-      .via(
-        Framing.delimiter(ByteString("\n"), 4096)
-          .map(byteString => byteString.utf8String)
-      )
+      .via(CsvParsing.lineScanner(CsvParsing.Tab, CsvParsing.DoubleQuote))
+      .via(CsvToMap.toMapAsStrings())
 
-    source
+    datasource
   }
 
-  def buildAndValidateSource(inputFile: File): Source[String, NotUsed] = {
+  def buildAndValidateSource(inputFile: File): Source[Map[String, String], NotUsed] = {
 
-    val source: Source[String, NotUsed] = buildSource(inputFile = inputFile)
+    val source: Source[Map[String, String], NotUsed] = buildSource(inputFile = inputFile)
     if (source == null) {
       throw new FileNotFoundException(filename = inputFile.getPath)
     }
     tvSeriesSink
   }
 
-  def buildPersonSink(logger: Logger): Sink[Person, Future[Done]] ={
-    val personSink :Sink[Person, Future[Done]] = Sink
-      .foreach[Person]((person: Person)=>{
+  def buildPersonsSink(logger: Logger): Sink[Person,Future[Done]] = {
+    val listPersonsSink: Sink[Person, Future[Done]]=
+      Sink.foreach[Person]((person: Person)=>{
         logger.info(s"${person.toString}")
       })
 
-    personSink
+    listPersonsSink
+  }
+
+  def buildPersonSink(logger: Logger): Sink[Person, Future[Done]] = {
+    Sink.foreach[Person](
+      (person: Person) => logger.info(s"${person.toString}")
+    )
   }
 }

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

 package fr.natan.akkastreamfileprocessingapi.service
 
+import akka.Done
+
+import scala.concurrent.Future
+
 trait AkkaStreamFileProcessing {
 
   def getAllMovies()
   def getMoviesByTitle (movieTitle: String)
 
   def getAllPersons()
+
+  def getPersonById(nconst: String)
 }

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

 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics}
 import fr.natan.akkastreamfileprocessingapi.models.{Person, TvSeries}
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAndValidateSource, buildPersonFlow, buildPersonSink, buildSource, buildTvSerieFlow, buildTvSeriesSink, buildfilterByMoviePrimaryTitleFlow}
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
+  buildAndValidateSource,
+  buildPersonFlow,
+  buildPersonSink,
+  buildPersonsSink,
+  buildSource, buildTvSerieFlow,
+  buildTvSeriesSink, filterByMoviePrimaryTitleFlow,
+  filterByPersonID
+}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 
   override def getAllMovies(): Unit = {
 
-    val source: Source[String, NotUsed] = buildAndValidateSource(inputFile = titleBasics)
+    val source: Source[Map[String, String], NotUsed] = buildAndValidateSource(inputFile = titleBasics)
     val sink: Sink[TvSeries, Future[Done]] = buildTvSeriesSink(logger = logger)
 
 
 
     //graph sink->flow->sink
     source
-      .via(flow = buildTvSerieFlow(movieID = "tconst"))
+      .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")
-    }
+        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")
+      }
 
   }
 
   override def getMoviesByTitle(moviePrimaryTitle: String): Unit = {
 
-    val tvSeriesSource: Source[String, NotUsed] = buildAndValidateSource(inputFile = titleBasics)
+    /*val tvSeriesSource: Source[String, NotUsed] = buildAndValidateSource(inputFile = titleBasics)
     val tvSeriesSink: Sink[TvSeries, Future[Done]] = buildTvSeriesSink(logger = logger)
 
     val filterByMovieTitleFlow: Flow[String, TvSeries, NotUsed] =
-      buildfilterByMoviePrimaryTitleFlow(moviePrimaryTitle = moviePrimaryTitle)
+      filterByMoviePrimaryTitleFlow(moviePrimaryTitle = moviePrimaryTitle)
 
     val startTime: Long = System.currentTimeMillis()
-    val listTvSeries: Future[Done]= tvSeriesSource
+    val listTvSeries: Future[Done] = tvSeriesSource
       .via(flow = filterByMovieTitleFlow)
       .runWith(sink = tvSeriesSink)
       .andThen {
-      case Success(value) =>
-        val elapsedTime: Long = (System.currentTimeMillis() - startTime) / 1000
-        logger.info(s"$value: successfully processing file, elapsed time $titleBasics: $elapsedTime sec")
-      case Failure(error: Error) => logger.error(s"$error")
-    }
+        case Success(value) =>
+          val elapsedTime: Long = (System.currentTimeMillis() - startTime) / 1000
+          logger.info(s"$value: successfully processing file, elapsed time $titleBasics: $elapsedTime sec")
+        case Failure(error: Error) => logger.error(s"$error")
+      }*/
   }
 
   override def getAllPersons(): Unit = {
-    val personSource: Source[String, NotUsed]= buildSource(inputFile = nameBasics)
-    val personSink: Sink[Person, Future[Done]] = buildPersonSink(logger = logger)
+    val personSource: Source[Map[String, String], NotUsed] = buildSource(inputFile = nameBasics)
+    val personSink: Sink[Person, Future[Done]] = buildPersonsSink(logger = logger)
 
     //graph
+    val startTime: Long = System.currentTimeMillis()
     personSource
-      .via(flow = buildPersonFlow(personID = "nconst"))
+      .via(flow = buildPersonFlow())
       .runWith(sink = personSink)
       .andThen {
         case Success(value) =>
-          logger.info(s"$value: successfully processing file")
+          val elapsedTime: Long = (System.currentTimeMillis() - startTime) / 1000
+          logger.info(s"$value: successfully processing file $elapsedTime sec")
         case Failure(error: Error) => logger.error(s"$error")
       }
   }
+
+  override def getPersonById(nconst: String): Unit = {
+    val source: Source[Map[String, String], NotUsed] = buildSource(inputFile = nameBasics)
+    val sink: Sink[Person, Future[Done]] = buildPersonSink(logger = logger)
+
+    val startTime: Long = System.currentTimeMillis()
+    source
+      .via(flow = filterByPersonID(nconst = nconst))
+      .runWith(sink = sink)
+      .andThen {
+        case Success(value) => {
+          val elapsedTime: Long = (System.currentTimeMillis()-startTime)/1000
+          logger.info(s"$value: Successfully processed, elapsed time: $elapsedTime")
+        }
+        case Failure(exception) => logger.error(s"$exception: Fail")
+      }
+  }
+
+
 }