added mediator

Author: dimit

pom.xml

@@ -19,6 +19,7 @@
  </properties>
 
  <dependencies>
+
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>

src/main/java/Commands/GetClientCommand.java

@@ -0,0 +1,24 @@
+package Commands;
+
+import Pipelinr.Command;
+import io.vavr.control.Either;
+import model.Employee;
+
+import java.util.concurrent.CompletableFuture;
+
+public class GetClientCommand implements Command<CompletableFuture<Either<String, Employee>>> {
+
+ public Integer getClientId() {
+ return clientId;
+ }
+
+ private Integer clientId;
+
+ public GetClientCommand(Integer clientId) {
+ this.clientId = clientId;
+ }
+
+
+}
+
+

src/main/java/Commands/GetClientCommandHandler.java

@@ -0,0 +1,28 @@
+package Commands;
+
+import Pipelinr.Command;
+import data.MockFutureEitherClientRepository;
+import data.MockFutureEitherEmployeeRepository;
+import io.vavr.control.Either;
+import model.Client;
+import model.Employee;
+
+import java.util.concurrent.CompletableFuture;
+
+import static operators.Op.bind;
+import static operators.Op.map;
+
+public class GetClientCommandHandler implements Command.Handler<GetClientCommand, CompletableFuture<Either<String, Employee>>> {
+
+ MockFutureEitherClientRepository clients = new MockFutureEitherClientRepository();
+ MockFutureEitherEmployeeRepository employees = new MockFutureEitherEmployeeRepository();
+
+ @Override
+ public CompletableFuture<Either<String, Employee>> handle(GetClientCommand command) {
+
+ return clients
+ .getClientById(command.getClientId())
+ .thenApplyAsync(map(Client::getEmployeeId))
+ .thenComposeAsync(bind(employees::getClientById));
+ }
+}

src/main/java/com/example/demo/DemoApplication.java

@@ -1,55 +1,64 @@
 package com.example.demo;
 
-import data.MockFutureEitherClientRepository;
-import data.MockFutureEitherEmployeeRepository;
-import operators.Op;
+import Commands.GetClientCommand;
+import Commands.GetClientCommandHandler;
+import Pipelinr.Pipeline;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
 
-import static io.vavr.API.*;
-import static io.vavr.Patterns.$Left;
-import static io.vavr.Patterns.$Right;
+import java.util.stream.Stream;
+
+import static io.vavr.API.Try;
+import static operators.Op.throwableMessage;
 
 @SpringBootApplication
 @RestController
 public class DemoApplication {
-
+ static Pipeline mediator;
  public static void main(String[] args) {
  SpringApplication.run(DemoApplication.class, args);
+ mediator = new Pipelinr.Pipelinr()
+ .with(
+ () -> Stream.of(new GetClientCommandHandler())
+ );
  }
 
  @RequestMapping(value = "/search", method = RequestMethod.GET)
  public ResponseEntity<SearchViewModel> search(@RequestParam(value = "clientId", defaultValue = "0") Integer clientId) {
- try {
 
- var clients = new MockFutureEitherClientRepository();
- var employees = new MockFutureEitherEmployeeRepository();
+ return Try(mediator.send(new GetClientCommand(clientId))::get)
+ .getOrElseGet(throwableMessage())
+ .fold(
+ error -> new ResponseEntity<>(new SearchViewModel(error), HttpStatus.BAD_REQUEST),
+ value -> new ResponseEntity<>(new SearchViewModel(value.getName()), HttpStatus.OK)
+ );
 
- var eitherEmployeeFuture =
- clients.getClientById(clientId)
- .thenApplyAsync(Op.map(x -> x.getEmployeeId()))
- .thenComposeAsync(Op.bind(employees::getClientById))
- .get();
 
- var result = Match(eitherEmployeeFuture).of(
- Case($Right($()), value -> value.getName()),
- Case($Left($()), error -> error));
+ }
 
- var resultViewModel = new SearchViewModel();
- resultViewModel.setResult(result);
 
-  return new ResponseEntity<>(resultViewModel, HttpStatus.OK);
+/* public ResponseEntity<SearchViewModel> search1(Integer clientId) {
 
- } catch (Exception e) {
- return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
- }
+ var eitherEmployeeFuture = clients
+ .getClientById(clientId)
+ .thenApplyAsync(map(Client::getEmployeeId))
+ .thenComposeAsync(bind(employees::getClientById));
 
- }
+ var eitherEmployee =
+ Try(eitherEmployeeFuture::get)
+ .getOrElseGet(x -> Either.left(x.getMessage()));
+
+ var resultViewModel = Match(eitherEmployee).of(
+ Case($Right($()), value -> new ResponseEntity<>(new SearchViewModel(value.getName()), HttpStatus.OK)),
+ Case($Left($()), error -> new ResponseEntity<>(new SearchViewModel(error), HttpStatus.BAD_REQUEST)));
 
+ return resultViewModel;
 
-}
+ }*/
+}

src/main/java/com/example/demo/SearchViewModel.java

@@ -9,7 +9,8 @@ public class SearchViewModel {
  private String type;
  private String result;
 
- public SearchViewModel() {
+ public SearchViewModel(String result) {
+ this.result=result;
  }
 
  public String getType() {

src/main/java/model/Client.java

@@ -1,6 +1,5 @@
 package model;
 
-
 public class Client {
  private Integer id;
  private String name;

src/main/java/operators/Op.java

@@ -1,6 +1,11 @@
 package operators;
 
+import com.example.demo.SearchViewModel;
+import io.vavr.Value;
 import io.vavr.control.Either;
+import model.Employee;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
@@ -11,15 +16,29 @@
 import static io.vavr.Patterns.$Right;
 
 public class Op {
- public static <L, T, T1> Function<Either<L, T>, Either<L, T1>> map(Function<T, T1> fn)
- throws InterruptedException, ExecutionException {
+ public static <R> Function<Throwable,Either<String, R>> throwableMessage( ) {
+ return x->Either.left(x.getMessage());
+ }
+
+ public static <L, T, T1> Function<Either<L, T>, Either<L, T1>> map(Function<T, T1> fn) {
  return $source -> $source.map(fn);
  }
 
  public static <L, T, T1> Function<Either<L, T>, CompletableFuture<Either<L, T1>>> bind(Function<T, CompletableFuture<Either<L, T1>>> fn)
-  throws InterruptedException, ExecutionException {
+ {
  return $source -> Match($source).of(
  Case($Right($()), value -> fn.apply(value)),
  Case($Left($()), error -> CompletableFuture.completedFuture(Either.left(error))));
  }
+
+
+// public static <L, T, T1> Function<Either<L, T>, CompletableFuture<Either<L, T1>>> bind(Function<T, CompletableFuture<Either<L, T1>>> fn)
+// {
+// var resultViewModel = Match(eitherEmployee).of(
+// Case($Right($()), value -> new ResponseEntity<>(new SearchViewModel(value.getName()), HttpStatus.OK)),
+// Case($Left($()), error -> new ResponseEntity<>(new SearchViewModel(error), HttpStatus.BAD_REQUEST)));
+//
+// }
+
+
 }