first commit

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

 package fr.natan.akkastreamfileprocessingapi.controller;
 
 import fr.natan.akkastreamfileprocessingapi.futurecompleteness.CompletableFutureBuilder;
-import fr.natan.akkastreamfileprocessingapi.models.Models;
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap;
 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamFileProcessingFuture;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
-import java.util.concurrent.TimeoutException;
-
 
 @SuppressWarnings("SpellCheckingInspection")
 @RestController
 
     @RequestMapping(value = "/persons/id/{personID}", method = RequestMethod.GET)
     private String getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
-        Future<Option<Models.Person>> futurePerson = akkaStreamFilesProcessing.getPersonByIdFuture(personID);
-        CompletableFuture<Models.Person> completableFuture = CompletableFutureBuilder
+        Future<Option<ModelsAndJsonMap.Person>> futurePerson = akkaStreamFilesProcessing.getPersonByIdFuture(personID);
+        CompletableFuture<ModelsAndJsonMap.Person> completableFuture = CompletableFutureBuilder
                 .buildcompletableFuture1(futurePerson);
         while (!completableFuture.isDone()) {
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
-        Models.Person person = completableFuture.get();
+        ModelsAndJsonMap.Person person = completableFuture.get();
 
-        JsValue personJs = Json.toJson(person, person.personFormat());
+        JsValue personJs = Json.toJson(person, person.personJsonFormatter());
         return Json.prettyPrint(personJs);
     }
 
     private String getPersonByName(@PathVariable(name = "primaryName") String primaryName)
             throws ExecutionException, InterruptedException {
 
-        Future<Option<Models.Person>> personFuture = akkaStreamFilesProcessing.getPersonByNameFuture(primaryName);
-        CompletableFuture<Models.Person> personCompletableFuture = CompletableFutureBuilder
+        Future<Option<ModelsAndJsonMap.Person>> personFuture = akkaStreamFilesProcessing.getPersonByNameFuture(primaryName);
+        CompletableFuture<ModelsAndJsonMap.Person> personCompletableFuture = CompletableFutureBuilder
                 .buildcompletableFuture1(personFuture);
         while (!personCompletableFuture.isDone()) {
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
-        Models.Person person = personCompletableFuture.get();
-        JsValue personJs = Json.toJson(person, person.personFormat());
+        ModelsAndJsonMap.Person person = personCompletableFuture.get();
+        JsValue personJs = Json.toJson(person, person.personJsonFormatter());
         return Json.prettyPrint(personJs);
     }
 
     @RequestMapping(value = "/tvseries/id/{tvSerieId}", method = RequestMethod.GET)
     private String getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID)
             throws ExecutionException, InterruptedException {
-        Future<Option<Models.TvSerie>> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieByIdFuture(tvSerieID);
-        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = CompletableFutureBuilder
+        Future<Option<ModelsAndJsonMap.TvSerie>> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieByIdFuture(tvSerieID);
+        CompletableFuture<ModelsAndJsonMap.TvSerie> tvSerieCompletableFuture = CompletableFutureBuilder
                 .buildcompletableFuture1(tvSerieFuture);
         while (!tvSerieCompletableFuture.isDone()) {
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
-        Models.TvSerie tvSerie = tvSerieCompletableFuture.get();
-        JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
+        ModelsAndJsonMap.TvSerie tvSerie = tvSerieCompletableFuture.get();
+        JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieJsonFormatter());
         return Json.prettyPrint(tvSerieJs);
     }
 
     private List<String> getTvserieByPrimaryTitle(
             @PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) throws InterruptedException, ExecutionException {
 
-        Future<IndexedSeq<Models.TvSerie>> listFuture = akkaStreamFilesProcessing
+        Future<IndexedSeq<ModelsAndJsonMap.TvSerie>> listFuture = akkaStreamFilesProcessing
                 .getTvSeriesByPrimaryTitleFuture(tvseriePrimaryTitle);
-        CompletableFuture<IndexedSeq<Models.TvSerie>> completableFuture =
+        CompletableFuture<IndexedSeq<ModelsAndJsonMap.TvSerie>> completableFuture =
                 CompletableFutureBuilder.buildcompletableFuture2(listFuture);
         while (!completableFuture.isDone()) {
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
-        IndexedSeq<Models.TvSerie> tvSerieList = completableFuture.get();
+        IndexedSeq<ModelsAndJsonMap.TvSerie> tvSerieList = completableFuture.get();
         List<String> tvSeries = new ArrayList<>();
         tvSerieList.foreach(tvSerie -> {
-            JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
+            JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieJsonFormatter());
             tvSeries.add(Json.prettyPrint(tvSerieJs));
             return null;
         });
     private List<String> getPersonsForTvSerieByTvSerieTitle(@PathVariable(name = "tvSerieTitle") String tvSerieTitle)
             throws InterruptedException, ExecutionException {
 
-        Future<IndexedSeq<Models.Person>> futurePersonSeq = akkaStreamFilesProcessing
+        Future<IndexedSeq<ModelsAndJsonMap.Person>> futurePersonSeq = akkaStreamFilesProcessing
                 .getPersonsForTvSerieByTvSerieTitleFuture(tvSerieTitle);
-        CompletableFuture<IndexedSeq<Models.Person>> completableFuture = CompletableFutureBuilder
+        CompletableFuture<IndexedSeq<ModelsAndJsonMap.Person>> completableFuture = CompletableFutureBuilder
                 .buildcompletableFuture2(futurePersonSeq);
         while (!completableFuture.isDone()){
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
 
-        IndexedSeq<Models.Person> personIndexedSeq = completableFuture.get();
+        IndexedSeq<ModelsAndJsonMap.Person> personIndexedSeq = completableFuture.get();
         List<String> personList = new ArrayList<>();
         personIndexedSeq.foreach(person -> {
-            JsValue personJs = Json.toJson(person, person.personFormat());
+            JsValue personJs = Json.toJson(person, person.personJsonFormatter());
             personList.add(Json.prettyPrint(personJs));
             return null;
         });
     private List<String> getPersonsForTvSerieByTvSerieID(@PathVariable(name = "tvSerieID") String tvSerieID)
             throws InterruptedException, ExecutionException {
 
-        Future<IndexedSeq<Models.Person>> futureIndexedSeqPersons = akkaStreamFilesProcessing
+        Future<IndexedSeq<ModelsAndJsonMap.Person>> futureIndexedSeqPersons = akkaStreamFilesProcessing
                 .getPersonsForTvSerieByTvSerieIDFuture(tvSerieID);
-        CompletableFuture<IndexedSeq<Models.Person>> seqCompletableFuture = CompletableFutureBuilder
+        CompletableFuture<IndexedSeq<ModelsAndJsonMap.Person>> seqCompletableFuture = CompletableFutureBuilder
                 .buildcompletableFuture2(futureIndexedSeqPersons);
 
         while (!seqCompletableFuture.isDone()){
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
-        IndexedSeq<Models.Person> personIndexedSeq = seqCompletableFuture.get();
+        IndexedSeq<ModelsAndJsonMap.Person> personIndexedSeq = seqCompletableFuture.get();
         List<String> personsList = new ArrayList<>();
         personIndexedSeq.foreach(person ->{
-            JsValue personJs = Json.toJson(person, person.personFormat());
+            JsValue personJs = Json.toJson(person, person.personJsonFormatter());
             personsList.add(Json.prettyPrint(personJs));
             return null;
         });

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

-package fr.natan.akkastreamfileprocessingapi.models
-
-import play.api.libs.json.{JsValue, Json, Writes}
-
-object Models {
-
-  //noinspection TypeAnnotation
-  final case class Person(
-                           personID: String,
-                           primaryName: String,
-                           birthYear: String,
-                           deathYear: String,
-                           primaryProfession: List[String],
-                           knownForTitles: List[String]
-                         ) {
-
-    implicit val personFormat = new Writes[Person] {
-      override def writes(person: Person): JsValue = Json.obj(
-        "person id" -> person.personID,
-        "primary name" -> person.primaryName,
-        "birth year" -> person.birthYear,
-        "death year" -> person.deathYear,
-        "primary profession" -> person.primaryProfession,
-        "known for titles" -> person.knownForTitles
-      )
-    }
-  }
-
-  //noinspection TypeAnnotation
-  final case class TvSerie(
-                            tvSerieID: String,
-                            titleType: String,
-                            primaryTitle: String,
-                            originalTitle: String,
-                            startYear: String,
-                            endYear: String,
-                            runtimeMinutes: String,
-                            genres: List[String]
-                          ) {
-
-    implicit val tvSerieFormat = new Writes[TvSerie] {
-      override def writes(tvSerie: TvSerie): JsValue = Json.obj(
-        "tv serie id" -> tvSerie.tvSerieID,
-        "tv serie type" -> tvSerie.titleType,
-        "primary title" -> tvSerie.primaryTitle,
-        "original title" -> tvSerie.originalTitle,
-        "start year" -> tvSerie.startYear,
-        "end year" -> tvSerie.endYear,
-        "runtime minutes" -> tvSerie.runtimeMinutes,
-        "genres" -> tvSerie.genres
-      )
-    }
-  }
-}

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

+package fr.natan.akkastreamfileprocessingapi.models
+
+import play.api.libs.json.{Json, Writes}
+
+object ModelsAndJsonMap {
+
+  final case class Person(personID: String,
+                          primaryName: String,
+                          birthYear: String,
+                          deathYear: String,
+                          primaryProfession: List[String],
+                          knownForTitles: List[String]
+                         ) {
+
+    implicit val personJsonFormatter: Writes[Person] =
+      (person: Person) => Json.obj(
+        "person id" -> person.personID,
+        "primary name" -> person.primaryName,
+        "birth year" -> person.birthYear,
+        "death year" -> person.deathYear,
+        "primary profession" -> person.primaryProfession,
+        "known for titles" -> person.knownForTitles
+      )
+  }
+
+  final case class TvSerie(tvSerieID: String,
+                           titleType: String,
+                           primaryTitle: String,
+                           originalTitle: String,
+                           startYear: String,
+                           endYear: String,
+                           runtimeMinutes: String,
+                           genres: List[String]
+                          ) {
+
+    implicit val tvSerieJsonFormatter: Writes[TvSerie] =
+      (tvSerie: TvSerie) => Json.obj(
+        "tv serie id" -> tvSerie.tvSerieID,
+        "tv serie type" -> tvSerie.titleType,
+        "primary title" -> tvSerie.primaryTitle,
+        "original title" -> tvSerie.originalTitle,
+        "start year" -> tvSerie.startYear,
+        "end year" -> tvSerie.endYear,
+        "runtime minutes" -> tvSerie.runtimeMinutes,
+        "genres" -> tvSerie.genres
+      )
+
+  }
+}

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

 package fr.natan.akkastreamfileprocessingapi.models
-import Models.{Person, TvSerie}
+import ModelsAndJsonMap.{Person, TvSerie}
 object ModelsBuilder {
 
-  def buildPersonModel(personMap: Map[String, String]): Person = {
+  def buildPersonModel(personMap: Map[String, String]): Person =
+  {
     Person(
       personMap("nconst"),
       personMap("primaryName"),
     )
   }
 
-  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSerie = {
+  def buildTvSerieModel(tvSerieMap: Map[String, String]): TvSerie =
+  {
     val tvSerie: TvSerie = TvSerie(
       tvSerieMap("tconst"),
       tvSerieMap("titleType"),

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.Models.{Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
 import fr.natan.akkastreamfileprocessingapi.valitator.Validators.fileExists
 import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.{buildPersonModel, buildTvSerieModel}
 

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

 package fr.natan.akkastreamfileprocessingapi.service
 
 import akka.Done
-import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
 
 import scala.concurrent.Future
 

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

 import akka.stream.scaladsl.{Sink, Source}
 import com.typesafe.scalalogging.slf4j.Logger
 import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics}
-import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.{Person, TvSerie}
 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
   actorSystem, buildAllPersonsSink, buildAllTvSeriesSink, buildAndValidateSource, buildPersonFlow, buildSource,
   buildTvSerieFlow, filterPersonByIdFlow, filterPersonByNameFlow, filterTvSerieByIdFlow, filterTvSerieByPrimaryTitleFlow}

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

 
 import akka.stream.scaladsl.{Sink, Source}
 import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics, titlePrincipalsBasics}
-import fr.natan.akkastreamfileprocessingapi.models.Models.Person
+import fr.natan.akkastreamfileprocessingapi.models.ModelsAndJsonMap.Person
 import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.buildPersonModel
 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{actorSystem, buildSource}