first commit

src/main/scala/fr/natan/akkastreamfileprocessingapi/datasource/Datasource.scala

   val titleBasics: File = new File("../title.basics.tsv.gz")
   val nameBasics: File = new File("../name.basics.tsv.gz")
   val titlePrincipalsBasics: File = new File("../title.basics.tsv.gz")
+  val separator: String = "\t"
 }

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

 package fr.natan.akkastreamfileprocessingapi.models
 
-final case class Person(nconst: String,
-                  primaryName: String,
-                  birthYear: String,
-                  dearthYear: String,
-                  primaryProfession: String,
-                  knownForTitles: List[String]
-                 )
+final case class Person(
+                         nconst: String,
+                         primaryName: String,
+                         birthYear: String,
+                         dearthYear: String,
+                         primaryProfession: List[String],
+                         knownForTitles: List[String]
+                       ){
+  override def toString: String = {
+    "Person[ nconst:"+nconst+
+      ", primaryName:"+primaryName+
+    ", birthYear:"+birthYear+
+    ", dearthYear:"+dearthYear+
+    ", primaryProfession:"+primaryProfession+
+    ", knownForTitles:"+knownForTitles
+  }
+}

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

                    ) {
 
   override def toString: String = {
-    "TvSerie[tvSerieID : " + tconst +", title-type:"+titleType+", primary-title:"+primaryTitle+"" +
-      ", riginal-title:"+originalTitle+", is adult (no=0, yes=1):"+isAdult+", start year:"+startYear+
-    ", end year:"+endYear+", runtime minutes:"+runtimeMinutes+", genre:"+genre+"]"
+    "TvSerie[tvSerieID : " + tconst +
+      ", title-type:"+titleType+
+      ", primary-title:"+primaryTitle+"" +
+      ", riginal-title:"+originalTitle+
+      ", is adult (no=0, yes=1):"+isAdult+
+      ", start year:"+startYear+
+    ", end year:"+endYear+
+      ", runtime minutes:"+runtimeMinutes+
+      ", genre:"+genre+"]"
   }
 }

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

 import akka.{Done, NotUsed}
 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.businessexceptions.FileNotFoundException
-import fr.natan.akkastreamfileprocessingapi.models.TvSeries
+import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.separator
+import fr.natan.akkastreamfileprocessingapi.models.{Person, TvSeries}
 import fr.natan.akkastreamfileprocessingapi.valitator.Validators.fileExists
 
 import java.io.File
 
   implicit val actor: ActorSystem = ActorSystem("AkkaStreamActor")
 
-  private def convertToClassMovie(array: Array[String]): TvSeries = {
+  private def convertToTvSerie(array: Array[String]): TvSeries = {
     val tvSerie: TvSeries = TvSeries(
       array(0),
       array(1),
     tvSerie
   }
 
+  private def convertToPerson(array: Array[String]): Person ={
+    Person(
+      array(0),
+      array(1),
+      array(2),
+      array(3),
+      array(4).split(",").toList,
+      array(5).split(",").toList,
+    )
+  }
+
   //flows
 
-  def buildMovieFlow(movieID: String): Flow[String, TvSeries, NotUsed] = {
+  def buildTvSerieFlow(movieID: String): Flow[String, TvSeries, NotUsed] = {
 
-    val flow: Flow[String, TvSeries, NotUsed] =
+    val tvFlow: Flow[String, TvSeries, NotUsed] =
       Flow[String].filter(rows => !rows.contains(movieID))
         .map(row => {
-          val movie: Array[String] = row.split("\t")
-          convertToClassMovie(movie)
+          val movie: Array[String] = row.split(separator)
+          convertToTvSerie(movie)
         })
-    flow
+    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))
+        })
+
+    personFlow
+  }
   def buildfilterByMoviePrimaryTitleFlow(moviePrimaryTitle: String): Flow[String, TvSeries, NotUsed] = {
     val filterFlow: Flow[String, TvSeries, NotUsed] =
       Flow[String]
         })
         .map(row => {
           val movie: Array[String] = row.split("\t")
-          convertToClassMovie(movie)
+          convertToTvSerie(movie)
         })
 
     filterFlow
   }
 
   //sink
-  def buildSink(logger: Logger): Sink[TvSeries, Future[Done]] = {
-    val sink = Sink.foreach[TvSeries](
+  def buildTvSeriesSink(logger: Logger): Sink[TvSeries, Future[Done]] = {
+    val tvSeriesSink : Sink[TvSeries, Future[Done]]= Sink.foreach[TvSeries](
       (movie: TvSeries) => {
         logger.info(s"${movie.toString}")
       }
     )
-    sink
+    tvSeriesSink
+  }
+
+  def buildPersonSink(logger: Logger): Sink[Person, Future[Done]] ={
+    val personSink :Sink[Person, Future[Done]] = Sink
+      .foreach[Person]((person: Person)=>{
+        logger.info(s"${person.toString}")
+      })
+
+    personSink
   }
 }

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

 
   def getAllMovies()
   def getMoviesByTitle (movieTitle: String)
+
+  def getAllPersons()
 }

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

 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.titleBasics
 import fr.natan.akkastreamfileprocessingapi.models.TvSeries
-import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAndValidateSource, buildMovieFlow, buildSink, buildfilterByMoviePrimaryTitleFlow}
+import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{buildAndValidateSource, buildTvSerieFlow, buildTvSeriesSink, buildfilterByMoviePrimaryTitleFlow}
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
   override def getAllMovies(): Unit = {
 
     val source: Source[String, NotUsed] = buildAndValidateSource(inputFile = titleBasics)
-    val sink: Sink[TvSeries, Future[Done]] = buildSink(logger = logger)
+    val sink: Sink[TvSeries, Future[Done]] = buildTvSeriesSink(logger = logger)
 
 
     val startingTime: Long = System.currentTimeMillis()
 
     //graph sink->flow->sink
     source
-      .via(flow = buildMovieFlow(movieID = "tconst"))
+      .via(flow = buildTvSerieFlow(movieID = "tconst"))
       .runWith(sink = sink)
       .andThen {
       case Success(value) =>
   override def getMoviesByTitle(moviePrimaryTitle: String): Unit = {
 
     val source: Source[String, NotUsed] = buildAndValidateSource(inputFile = titleBasics)
-    val sink: Sink[TvSeries, Future[Done]] = buildSink(logger = logger)
+    val sink: Sink[TvSeries, Future[Done]] = buildTvSeriesSink(logger = logger)
 
     val filterByMovieTitleFlow: Flow[String, TvSeries, NotUsed] =
       buildfilterByMoviePrimaryTitleFlow(moviePrimaryTitle = moviePrimaryTitle)
       case Failure(error: Error) => logger.error(s"$error")
     }
   }
+
+  override def getAllPersons(): Unit = {
+    ???
+  }
 }