first commit

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

             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         Models.Person person = completableFuture.get();
-
-        return Json.toJson(person, person.personFormat()).toString();
+        JsValue personJs = Json.toJson(person, person.personFormat());
+        return Json.prettyPrint(personJs);
     }
 
     @RequestMapping(value = "/persons/name/{primaryName}", method = RequestMethod.GET)
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         Models.Person person = personCompletableFuture.get();
-        return Json.toJson(person, person.personFormat()).toString();
+        JsValue personJs = Json.toJson(person, person.personFormat());
+        return Json.prettyPrint(personJs);
     }
 
     @RequestMapping(value = "/tvseries/id/{tvSerieId}", method = RequestMethod.GET)
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         Models.TvSerie tvSerie = tvSerieCompletableFuture.get();
-        return Json.toJson(tvSerie, tvSerie.tvSerieFormat()).toString();
+        JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
+        return Json.prettyPrint(tvSerieJs);
     }
 
     @RequestMapping(value = "/tvseries/title/{tvseriePrimaryTitle}", method = RequestMethod.GET)
         List<String> tvSeries = new ArrayList<>();
         tvSerieList.foreach(tvSerie -> {
             JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
-            tvSeries.add(tvSerieJs.toString());
+            tvSeries.add(Json.prettyPrint(tvSerieJs));
             return null;
         });
 
         }
 
         IndexedSeq<Models.Person> personIndexedSeq = completableFuture.get();
-        List<String> persons = new ArrayList<>();
+        List<String> personList = new ArrayList<>();
         personIndexedSeq.foreach(person -> {
             JsValue personJs = Json.toJson(person, person.personFormat());
-            persons.add(personJs.toString());
+            personList.add(Json.prettyPrint(personJs));
             return null;
         });
 
-        return persons;
+        return personList;
     }
 
     @RequestMapping(value = "/persons/tvseries/id/{tvSerieID}", method = RequestMethod.GET)
         IndexedSeq<Models.Person> personIndexedSeq = seqCompletableFuture.get();
         List<String> personsList = new ArrayList<>();
         personIndexedSeq.foreach(person ->{
-            personsList.add(Json.toJson(person, person.personFormat()).toString());
+            JsValue personJs = Json.toJson(person, person.personFormat());
+            personsList.add(Json.prettyPrint(personJs));
             return null;
         });
 

src/main/java/fr/natan/akkastreamfileprocessingapi/futurecompleteness/CompletableFutureBuilder.java

 import scala.collection.IndexedSeq;
 import scala.concurrent.Future;
 
+import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 
         CompletableFuture<T> completableFuture = new CompletableFuture<>();
        Executors.newSingleThreadExecutor().submit(() -> {
            while(!futureT.isCompleted()){
-               Thread.sleep(100);
+               Thread.sleep(new Random().nextInt(500-100)+100);
            }
             completableFuture.complete(futureT.value().get().get());
             return null;

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

 import akka.actor.ActorSystem
 import akka.stream.scaladsl.{Sink, Source}
 import com.typesafe.scalalogging.slf4j.Logger
-import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{
-  nameBasics, titleBasics, titlePrincipalsBasics
-}
+import fr.natan.akkastreamfileprocessingapi.datasource.Datasource.{nameBasics, titleBasics, titlePrincipalsBasics}
 import fr.natan.akkastreamfileprocessingapi.models.Models.{Person, TvSerie}
 import fr.natan.akkastreamfileprocessingapi.models.ModelsBuilder.buildPersonModel
 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamComponents.{
 
   override def getPersonByIdFuture(personID: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
+
+    val start: Long = System.currentTimeMillis()
     val personFuture: Future[Person] = source
       .via(flow = filterPersonByIdFlow(personID = personID))
       .runWith(Sink.head)
 
     personFuture.andThen({
       case Failure(exception) => logger.info(s"$exception")
-      case Success(value:Person) => logger.info(s"$value")
+      case Success(value:Person) =>
+        logger.info(s"$value")
+        logger.info(s"SUCCESS, elapsed time:${(System.currentTimeMillis() - start) / 1000} sec")
     })
 
     personFuture
 
   override def getPersonByNameFuture(primaryName: String): Future[Person] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = nameBasics)
+
+    val start: Long = System.currentTimeMillis()
     val personFuture: Future[Person] = source
       .via(flow = filterPersonByNameFlow(primaryName = primaryName))
       .runWith(Sink.head)
     personFuture.onComplete({
       case Failure(exception) => logger.error(s"$exception")
       case Success(value: Person) => logger.info(s"$value")
-        logger.info("SUCCESS")
+        logger.info(s"SUCCESS, elapsed time:${(System.currentTimeMillis() - start) / 1000} sec")
     })
 
     personFuture
 
   override def getTvSerieByIdFuture(tvSerieID: String): Future[TvSerie] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = titleBasics)
+
+    val start: Long = System.currentTimeMillis()
     val tvSerieFuture: Future[TvSerie] = source
       .via(flow = filterTvSerieByIdFlow(tvSerieID = tvSerieID))
       .runWith(Sink.head)
 
     tvSerieFuture.onComplete({
       case Failure(exception) => logger.info(s"$exception")
-      case Success(value: TvSerie) => logger.info(s"$value")
+      case Success(value: TvSerie) =>
+        logger.info(s"$value")
+        logger.info(s"SUCCESS, elapsed time:${(System.currentTimeMillis() - start) / 1000} sec")
     })
     tvSerieFuture
   }
   override def getTvSeriesByPrimaryTitleFuture(tvSeriePrimaryTitle: String): Future[IndexedSeq[TvSerie]] = {
 
+    val start: Long = System.currentTimeMillis()
     val tvSeriesSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
-
     val tvSriesFuture: Future[IndexedSeq[TvSerie]] = tvSeriesSource
       .via(flow = filterTvSerieByPrimaryTitleFlow(tvSeriePrimaryTitle = tvSeriePrimaryTitle))
       .runWith(Sink.collection)
       case Failure(exception) => logger.info(s"$exception")
       case Success(value: IndexedSeq[TvSerie]) =>
         value.foreach((tvSrie: TvSerie) => logger.info(s"$tvSrie"))
-        logger.info("SUCCESS")
+        logger.info(s"SUCCESS, elapsed time:${(System.currentTimeMillis() - start) / 1000} sec")
     })
 
     tvSriesFuture
 
   private def getTvSerieIdByPrimaryTitle(primaryTitle: String): Future[Option[String]] = {
     val source: Source[Map[String, String], _] = buildSource(inputFile = titleBasics)
-
     val tvSerieIdFuture: Future[Option[String]] = source
       .filter((rowMap: Map[String, String]) => {
         rowMap.getOrElse(key = "primaryTitle", default = "") == primaryTitle
 
     //futures chaining
     logger.info("STEP 1/3 START")
+    val start1: Long = System.currentTimeMillis()
     val tvSerieIDFuture: Future[Option[String]] = getTvSerieIdByPrimaryTitle(primaryTitle = tvSeriePrimaryTitle)
 
     val finalFuture: Future[IndexedSeq[Person]] =
         case Failure(exception) => logger.error(s"$exception")
         case Success(value: Option[String]) =>
           logger.info(s"TvSerie ID: $value")
-          logger.info("STEP 1/3 END")
+          logger.info(s"STEP 1/3 END, elapsed time:${(System.currentTimeMillis() - start1) / 1000} sec")
       })
         .flatMap({
           _ =>
             logger.info("STEP 2/3 START")
+            val  start2: Long = System.currentTimeMillis()
             val listPersonIDsFuture: Future[IndexedSeq[Option[String]]] = getListOfPersonsIDByTvSerieID(tvSerieIdFuture = 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")
+                logger.info(s"STEP 2/3 END, elapsed time:${(System.currentTimeMillis() - start2) / 1000} sec")
             })
               .flatMap({
                 _ =>
                   logger.info("STEP 3/3 START")
+                  val start3: Long = System.currentTimeMillis()
                   val personsTeamFuture: Future[IndexedSeq[Person]] = getListOfPersonsForTvSerie(listPersonsIDsFuture = 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")
+                      logger.info(s"STEP 3/3 END, elapsed time:${(System.currentTimeMillis() - start3) / 1000} sec")
                   })
               })
         })
 
   override def getPersonsForTvSerieByTvSerieIdFuture(tvSerieId: String): Future[IndexedSeq[Person]] = {
 
-    val tvSerieIdFuture: Future[Option[String]] = getTvSerieIDFuture(tvSerieId = tvSerieId)
+    val start1: Long = System.currentTimeMillis()
     logger.info("STEP 1/3")
+    val tvSerieIdFuture: Future[Option[String]] = getTvSerieIDFuture(tvSerieId = tvSerieId)
     tvSerieIdFuture.andThen({
       case Failure(exception) => logger.error(s"${exception.printStackTrace()}")
       case Success(value:Option[String]) =>
         logger.info(s"$value")
-        logger.info("STEP 1/3")
+        logger.info(s"STEP 1/3 END, elapsed time:${(System.currentTimeMillis() - start1) / 1000} sec")
 
     })
       .flatMap({
         _ => logger.info("STEP 2/3")
+          val start2: Long = System.currentTimeMillis()
           val  listOfPersonsIDsFuture : Future[IndexedSeq[Option[String]]] = getListOfPersonsIDByTvSerieID(tvSerieIdFuture = tvSerieIdFuture)
           listOfPersonsIDsFuture.andThen({
             case Failure(exception) => logger.error(s"${exception.printStackTrace()}")
             case Success(value) =>
               value.foreach((personID: Option[String]) => logger.info(s"Person ID:$personID"))
-              logger.info("STEP 2/3 END")
+              logger.info(s"STEP 2/3 END, elapsed time:${(System.currentTimeMillis() - start2) / 1000} sec")
           })
             .flatMap({
               _ => logger.info("STEP 3/3")
+                val start3: Long = System.currentTimeMillis()
                 val personsTeamFuture: Future[IndexedSeq[Person]] = getListOfPersonsForTvSerie(listPersonsIDsFuture = listOfPersonsIDsFuture)
                 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")
+                    logger.info(s"STEP 3/3 END, elapsed time:${(System.currentTimeMillis() - start3) / 1000} sec")
                 })
             })
       })