first commit

pom.xml

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

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

 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.concurrent.Future;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
     private final AkkaStreamFileProcessing akkaStreamFilesProcessing;
     private final CompletableFutureResult completableFutureResult = new CompletableFutureResult();
     private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    private static final int BORN_INF = 1000, BORN_SUP = 5000;
+
     public MovieController(AkkaStreamFileProcessing akkaStreamFilesProcessing) {
         this.akkaStreamFilesProcessing = akkaStreamFilesProcessing;
     }
     private ResponseEntity<String> getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
         Future<Models.Person> futurePerson = akkaStreamFilesProcessing.getPersonById(personID);
         CompletableFuture<Models.Person> completableFuture = completableFutureResult.buildcompletableFuture(futurePerson);
-        while (!completableFuture.isDone()){
-           logger.info("IS PROCESSING...");
-            Thread.sleep(5000);
+        while (!completableFuture.isDone()) {
+            logger.info("IS PROCESSING...");
+            Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         Models.Person person = completableFuture.get();
         return new ResponseEntity<>(Json.toJson(person, person.personFormat()).toString(), HttpStatus.OK);
 
         Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonByName(primaryName);
         CompletableFuture<Models.Person> personCompletableFuture = completableFutureResult.buildcompletableFuture(personFuture);
-        while (!personCompletableFuture.isDone()){
+        while (!personCompletableFuture.isDone()) {
             logger.info("IS PROCESSING...");
-            Thread.sleep(5000);
+            Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         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 {
+    private ResponseEntity<String> getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID)
+            throws ExecutionException, InterruptedException {
         Future<Models.TvSerie> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieById(tvSerieID);
         CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = completableFutureResult.buildcompletableFuture(tvSerieFuture);
-        while (!tvSerieCompletableFuture.isDone()){
+        while (!tvSerieCompletableFuture.isDone()) {
             logger.info("IS PROCESSING...");
-            Thread.sleep(5000);
+            Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
         }
         Models.TvSerie tvSerie = tvSerieCompletableFuture.get();
         return new ResponseEntity<>(Json.toJson(tvSerie, tvSerie.tvSerieFormat()).toString(), HttpStatus.OK);
     }
 
     @RequestMapping(value = "/tvseries/title/{tvseriePrimaryTitle}", method = RequestMethod.GET)
-    private ResponseEntity<IndexedSeq<Models.TvSerie>> getTvserieByPrimaryTitle(
-            @PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) {
+    private List<String> getTvserieByPrimaryTitle(
+            @PathVariable(name = "tvseriePrimaryTitle") String tvseriePrimaryTitle) throws InterruptedException, ExecutionException {
 
         Future<IndexedSeq<Models.TvSerie>> listFuture = akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
-        IndexedSeq<Models.TvSerie> indexedSeq = listFuture.value().get().get();
+        CompletableFuture<IndexedSeq<Models.TvSerie>> completableFuture =
+                completableFutureResult.buildcompletableFuture_(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();
+        List<String> tvSeries = new ArrayList<>();
+        tvSerieList.foreach(tvSerie -> {
+            JsValue tvSerieJs = Json.toJson(tvSerie, tvSerie.tvSerieFormat());
+            tvSeries.add(tvSerieJs.toString());
+            return null;
+        });
 
-        return new ResponseEntity<>(indexedSeq, HttpStatus.OK);
+        return tvSeries;
     }
 
+    ;
+
     @RequestMapping(value = "/persons/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
-    private Future<IndexedSeq<Models.Person>> getPersonsForTvSerie(@PathVariable(name = "tvSerieTitle") String tvSerieTitle) {
-        return akkaStreamFilesProcessing.getTeamOfPersonsForTvSerie(tvSerieTitle);
+    private List<String> getPersonsForTvSerie(@PathVariable(name = "tvSerieTitle") String tvSerieTitle)
+            throws InterruptedException, ExecutionException {
+
+        Future<IndexedSeq<Models.Person>> futurePersonSeq = akkaStreamFilesProcessing.getTeamOfPersonsForTvSerie(tvSerieTitle);
+        CompletableFuture<IndexedSeq<Models.Person>> completableFuture = completableFutureResult.buildcompletableFuture_(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();
+        List<String> persons = new ArrayList<>();
+        personIndexedSeq.foreach(person -> {
+            JsValue personJs = Json.toJson(person, person.personFormat());
+            persons.add(personJs.toString());
+            return null;
+        });
+
+        return persons;
     }
 
     @RequestMapping(value = "/persons", method = RequestMethod.GET)

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

 package fr.natan.akkastreamfileprocessingapi.futurecompleteness;
 
 
+import scala.collection.IndexedSeq;
+import scala.collection.immutable.List;
 import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 
     public CompletableFuture<T> buildcompletableFuture(Future<T> futureT) {
         CompletableFuture<T> completableFuture = new CompletableFuture<>();
-        T tt = (T) Executors.newSingleThreadExecutor().submit(() -> {
+       Executors.newSingleThreadExecutor().submit(() -> {
            while(!futureT.isCompleted()){
-               Thread.sleep(500);
+               Thread.sleep(100);
            }
             completableFuture.complete(futureT.value().get().get());
             return null;
         return completableFuture;
     }
 
+
+    public CompletableFuture<IndexedSeq<T>> buildcompletableFuture_(Future<IndexedSeq<T>> futureListT) {
+        CompletableFuture<IndexedSeq<T>> completableFuture = new CompletableFuture<>();
+        Executors.newSingleThreadExecutor().submit(() -> {
+            while(!futureListT.isCompleted()){
+                Thread.sleep(100);
+            }
+            completableFuture.complete(futureListT.value().get().get());
+            return null;
+        });
+
+        return completableFuture;
+    }
+
 }

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

 
 object Models {
 
+  //noinspection TypeAnnotation
   final case class Person(
                            personID: String,
                            primaryName: String,
     }
   }
 
+  //noinspection TypeAnnotation
   final case class TvSerie(
                             tvSerieID: String,
                             titleType: String,

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

 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
+import scala.collection.mutable.ListBuffer
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 import scala.language.postfixOps