first commit

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

 
 @SuppressWarnings("SpellCheckingInspection")
 @RestController
-public class MovieController {
+public class TvSeriesController {
 
     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;
+    private static final int BORN_INF = 500, BORN_SUP = 5000;
 
-    public MovieController(AkkaStreamFileProcessing akkaStreamFilesProcessing) {
+    public TvSeriesController(AkkaStreamFileProcessing akkaStreamFilesProcessing) {
         this.akkaStreamFilesProcessing = akkaStreamFilesProcessing;
     }
 
     @RequestMapping(value = "/persons/id/{personID}", method = RequestMethod.GET)
-    private ResponseEntity<String> getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
+    private String getPersonByID(@PathVariable(name = "personID") String personID) throws ExecutionException, InterruptedException {
         Future<Models.Person> futurePerson = akkaStreamFilesProcessing.getPersonById(personID);
-        CompletableFuture<Models.Person> completableFuture = completableFutureResult.buildcompletableFuture(futurePerson);
+        CompletableFuture<Models.Person> completableFuture = CompletableFutureResult.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();
-        return new ResponseEntity<>(Json.toJson(person, person.personFormat()).toString(), HttpStatus.OK);
+
+        return Json.toJson(person, person.personFormat()).toString();
     }
 
     @RequestMapping(value = "/persons/name/{primaryName}", method = RequestMethod.GET)
-    private ResponseEntity<String> getPersonByName(@PathVariable(name = "primaryName") String primaryName)
+    private String getPersonByName(@PathVariable(name = "primaryName") String primaryName)
             throws ExecutionException, InterruptedException {
 
         Future<Models.Person> personFuture = akkaStreamFilesProcessing.getPersonByName(primaryName);
-        CompletableFuture<Models.Person> personCompletableFuture = completableFutureResult.buildcompletableFuture(personFuture);
+        CompletableFuture<Models.Person> personCompletableFuture = CompletableFutureResult.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();
-        return new ResponseEntity<>(Json.toJson(person, person.personFormat()).toString(), HttpStatus.OK);
+        return Json.toJson(person, person.personFormat()).toString();
     }
 
     @RequestMapping(value = "/tvseries/id/{tvSerieId}", method = RequestMethod.GET)
-    private ResponseEntity<String> getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID)
+    private String getTvSerieByID(@PathVariable(name = "tvSerieId") String tvSerieID)
             throws ExecutionException, InterruptedException {
         Future<Models.TvSerie> tvSerieFuture = akkaStreamFilesProcessing.getTvSerieById(tvSerieID);
-        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = completableFutureResult.buildcompletableFuture(tvSerieFuture);
+        CompletableFuture<Models.TvSerie> tvSerieCompletableFuture = CompletableFutureResult.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();
-        return new ResponseEntity<>(Json.toJson(tvSerie, tvSerie.tvSerieFormat()).toString(), HttpStatus.OK);
+        return Json.toJson(tvSerie, tvSerie.tvSerieFormat()).toString();
     }
 
     @RequestMapping(value = "/tvseries/title/{tvseriePrimaryTitle}", method = RequestMethod.GET)
 
         Future<IndexedSeq<Models.TvSerie>> listFuture = akkaStreamFilesProcessing.getTvSerieByPrimaryTitle(tvseriePrimaryTitle);
         CompletableFuture<IndexedSeq<Models.TvSerie>> completableFuture =
-                completableFutureResult.buildcompletableFuture_(listFuture);
+                CompletableFutureResult.buildcompletableFuture2(listFuture);
         while (!completableFuture.isDone()) {
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);
             return null;
         });
 
-        return tvSeries;
+      return tvSeries;
     }
 
-    ;
-
     @RequestMapping(value = "/persons/tvseries/title/{tvSerieTitle}", method = RequestMethod.GET)
     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);
+        CompletableFuture<IndexedSeq<Models.Person>> completableFuture = CompletableFutureResult.buildcompletableFuture2(futurePersonSeq);
         while (!completableFuture.isDone()){
             logger.info("IS PROCESSING...");
             Thread.sleep(new Random().nextInt(BORN_SUP-BORN_INF)+BORN_INF);

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

 
 
 import scala.collection.IndexedSeq;
-import scala.collection.immutable.List;
 import scala.concurrent.Future;
 
 import java.util.concurrent.CompletableFuture;
 
 public class CompletableFutureResult<T> {
 
-    public CompletableFuture<T> buildcompletableFuture(Future<T> futureT) {
+    public static<T> CompletableFuture<T> buildcompletableFuture1(Future<T> futureT) {
         CompletableFuture<T> completableFuture = new CompletableFuture<>();
        Executors.newSingleThreadExecutor().submit(() -> {
            while(!futureT.isCompleted()){
         return completableFuture;
     }
 
-
-    public CompletableFuture<IndexedSeq<T>> buildcompletableFuture_(Future<IndexedSeq<T>> futureListT) {
+    public static<T> CompletableFuture<IndexedSeq<T>> buildcompletableFuture2(Future<IndexedSeq<T>> futureListT) {
         CompletableFuture<IndexedSeq<T>> completableFuture = new CompletableFuture<>();
         Executors.newSingleThreadExecutor().submit(() -> {
             while(!futureListT.isCompleted()){

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