first commit

pom.xml

     <name>akka-stream-file-processing-api</name>
     <description>akka-stream-file-processing-api</description>
     <properties>
-        <java.version>11</java.version>
+        <java.version>8</java.version>
         <scala.version>2.12.10</scala.version>
     </properties>
     <dependencies>

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

 import fr.natan.akkastreamfileprocessingapi.futurecompleteness.CompletableFutureResult;
 import fr.natan.akkastreamfileprocessingapi.models.Models;
 import fr.natan.akkastreamfileprocessingapi.service.AkkaStreamFileProcessing;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
-import play.api.libs.json.JsValue;
 import play.api.libs.json.Json;
 import scala.collection.IndexedSeq;
-import scala.collection.immutable.List;
 import scala.concurrent.Future;
 
 import java.util.concurrent.CompletableFuture;
 public class MovieController {
 
     private final AkkaStreamFileProcessing akkaStreamFilesProcessing;
-    private final CompletableFutureResult completableFutureResult;
+    private final CompletableFutureResult completableFutureResult = new CompletableFutureResult();
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
     public MovieController(AkkaStreamFileProcessing akkaStreamFilesProcessing) {
         this.akkaStreamFilesProcessing = akkaStreamFilesProcessing;
-        completableFutureResult = new CompletableFutureResult();
     }
 
     @RequestMapping(value = "/persons/id/{personID}", method = RequestMethod.GET)
     private ResponseEntity<String> getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
-        Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonById(personID);
-        CompletableFuture<Models.Person> personCompletableFuture = this.completableFutureResult.buildcompletableFuture(personFuture);
-        Models.Person person = personCompletableFuture.get();
-        JsValue personJs = Json.toJson(person, person.personFormat());
-        return new ResponseEntity<>(personJs.toString(), HttpStatus.OK);
+        Future<Models.Person> futurePerson = akkaStreamFilesProcessing.getPersonById(personID);
+        CompletableFuture<Models.Person> completableFuture = completableFutureResult.buildcompletableFuture(futurePerson);
+        while (!completableFuture.isDone()){
+           logger.info("IS PROCESSING...");
+            Thread.sleep(5000);
+        }
+        Models.Person person = completableFuture.get();
+        return new ResponseEntity<>(Json.toJson(person, person.personFormat()).toString(), HttpStatus.OK);
     }
 
     @RequestMapping(value = "/persons/name/{primaryName}", method = RequestMethod.GET)
             throws ExecutionException, InterruptedException {
 
         Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonByName(primaryName);
-        CompletableFuture completableFutureResult = this.completableFutureResult.buildcompletableFuture(personFuture);
-       Models.Person person = (Models.Person) completableFutureResult.get();
-       JsValue personJs = Json.toJson(person, person.personFormat());
-        return new ResponseEntity<>(personJs.toString(), HttpStatus.OK);
+        CompletableFuture<Models.Person> personCompletableFuture = completableFutureResult.buildcompletableFuture(personFuture);
+        while (!personCompletableFuture.isDone()){
+            logger.info("IS PROCESSING...");
+            Thread.sleep(5000);
+        }
+        Models.Person person = personCompletableFuture.get();
+        return new ResponseEntity<>(Json.toJson(person, person.personFormat()).toString(), HttpStatus.OK);
     }
 
     @RequestMapping(value = "/tvseries/id/{tvSerieId}", method = RequestMethod.GET)
     private ResponseEntity<String> getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID) throws ExecutionException, InterruptedException {
         Future<Models.TvSerie> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieById(tvSerieID);
-        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = this.completableFutureResult.buildcompletableFuture(tvSerieFuture);
+        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = completableFutureResult.buildcompletableFuture(tvSerieFuture);
+        while (!tvSerieCompletableFuture.isDone()){
+            logger.info("IS PROCESSING...");
+            Thread.sleep(5000);
+        }
         Models.TvSerie tvSerie = tvSerieCompletableFuture.get();
-        JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
-
-        return new ResponseEntity<>(tvSerieJs.toString(), HttpStatus.OK);
+        return new ResponseEntity<>(Json.toJson(tvSerie, tvSerie.tvSerieFormat()).toString(), HttpStatus.OK);
     }
 
     @RequestMapping(value = "/tvseries/title/{tvseriePrimaryTitle}", method = RequestMethod.GET)
-    private ResponseEntity<Future<List<Models.TvSerie>>> getTvserieByPrimaryTitle(@PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) {
-       Future<List<Models.TvSerie>> listFuture = akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
+    private ResponseEntity<IndexedSeq<Models.TvSerie>> getTvserieByPrimaryTitle(
+            @PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) {
+
+        Future<IndexedSeq<Models.TvSerie>> listFuture = akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
+        IndexedSeq<Models.TvSerie> indexedSeq = listFuture.value().get().get();
 
-       return new ResponseEntity<>(listFuture, HttpStatus.OK);
+        return new ResponseEntity<>(indexedSeq, HttpStatus.OK);
     }
 
     @RequestMapping(value = "/persons/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)

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

 package fr.natan.akkastreamfileprocessingapi.futurecompleteness;
 
+
 import scala.concurrent.Future;
+import scala.concurrent.duration.Duration;
 
-import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 
 
+
 public class CompletableFutureResult<T> {
 
-    public CompletableFuture<T> buildcompletableFuture(Future<T> future){
+    public CompletableFuture<T> buildcompletableFuture(Future<T> futureT) {
         CompletableFuture<T> completableFuture = new CompletableFuture<>();
-        Executors.newSingleThreadExecutor().submit(()->{
-            Thread.sleep(new Random().nextInt(500-200)+200);
-            return completableFuture.complete(future.value().get().get());
+        T tt = (T) Executors.newSingleThreadExecutor().submit(() -> {
+           while(!futureT.isCompleted()){
+               Thread.sleep(500);
+           }
+            completableFuture.complete(futureT.value().get().get());
+            return null;
         });
 
         return completableFuture;

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

   def getPersonByName(primaryName: String): Future[Person]
 
   def getTvSerieById(tvSerieID: String): Future[TvSerie]
-  def getTvSerieByPrimaryTitle(tvSerieTitle: String):Future[List[TvSerie]]
+  def getTvSerieByPrimaryTitle(tvSerieTitle: String):Future[IndexedSeq[TvSerie]]
 
   def getTeamOfPersonsForTvSerie(tvSeriePrimaryTitle: String): Future[IndexedSeq[Person]]
   def getAllTvSeries(): Unit

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

 package fr.natan.akkastreamfileprocessingapi.service
 
+import akka.Done
 import akka.actor.ActorSystem
-import akka.stream.scaladsl.{Flow, Sink, Source}
-import akka.{Done, NotUsed}
+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.models.Models.{Person, TvSerie}
 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}
 
       .via(flow = filterPersonByIdFlow(personID = personID))
       .runWith(Sink.head)
 
-    res.onComplete({
+    res.andThen({
       case Failure(exception) => logger.info(s"$exception")
       case Success(value:Person) => logger.info(s"$value")
     })
     })
     res
   }
-  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String): Future[List[TvSerie]] = {
+  override def getTvSerieByPrimaryTitle(tvSeriePrimaryTitle: String): Future[IndexedSeq[TvSerie]] = {
 
     val tvSeriesSource: Source[Map[String, String], _] = buildAndValidateSource(inputFile = titleBasics)
 
-    val tvSries: Future[List[TvSerie]] = tvSeriesSource
+    val tvSries: Future[IndexedSeq[TvSerie]] = tvSeriesSource
       .via(flow = filterTvSerieByPrimaryTitleFlow(tvSeriePrimaryTitle = tvSeriePrimaryTitle))
       .runWith(Sink.collection)
 
     tvSries.onComplete({
       case Failure(exception) => logger.info(s"$exception")
-      case Success(value: List[TvSerie]) =>
+      case Success(value: IndexedSeq[TvSerie]) =>
         value.foreach((tvSrie: TvSerie) => logger.info(s"$tvSrie"))
         logger.info("SUCCESS")
     })