Feature/eda (#383)

* Add eda variant support * Feature/eda (#382) * Cambios en version de asyncevents * Cambios a ejemplos * modificacion entry point --------- Co-authored-by: Jorge Espinosa <joeespin@bancolombia.com.co> Co-authored-by: jespinosas <117456623+jespinosas@users.noreply.github.com> Co-authored-by: Jorge Espinosa <joeespin@bancolombia.com.co>
bancolombia · Aug 1, 2023 · 656e8ff · 656e8ff
1 parent 51d402d
commit 656e8ff
Show file tree

Hide file tree

Showing 16 changed files with 285 additions and 23 deletions.
diff --git a/gradle.properties b/gradle.properties
@@ -1,3 +1,4 @@
 package=co.com.bancolombia
 systemProp.version=3.6.0
 simulateRest=true
+
diff --git a/src/main/java/co/com/bancolombia/Constants.java b/src/main/java/co/com/bancolombia/Constants.java
@@ -14,7 +14,7 @@ public class Constants {
   public static final String LOMBOK_VERSION = "1.18.28";
   public static final String JACOCO_VERSION = "0.8.10";
   public static final String COBERTURA_VERSION = "4.0.0";
-  public static final String RCOMMONS_ASYNC_COMMONS_STARTER_VERSION = "2.0.0";
+  public static final String RCOMMONS_ASYNC_COMMONS_STARTER_VERSION = "2.0.1";
   public static final String RCOMMONS_OBJECT_MAPPER_VERSION = "0.1.0";
   public static final String BLOCK_HOUND_VERSION = "1.0.8.RELEASE";
   public static final String PLUGIN_VERSION = "3.6.0";

diff --git a/src/main/java/co/com/bancolombia/task/GenerateDrivenAdapterTask.java b/src/main/java/co/com/bancolombia/task/GenerateDrivenAdapterTask.java
@@ -19,6 +19,7 @@ public class GenerateDrivenAdapterTask extends AbstractResolvableTypeTask {
   private DrivenAdapterBinStash.CacheMode cacheMode = DrivenAdapterBinStash.CacheMode.LOCAL;
 
   private BooleanOption secret = BooleanOption.FALSE;
+  private BooleanOption eda = BooleanOption.FALSE;
 
   @Option(option = "url", description = "Set driven adapter url when RESTCONSUMER type")
   public void setUrl(String url) {
@@ -40,6 +41,16 @@ public List<BooleanOption> getSecretOptions() {
     return Arrays.asList(BooleanOption.values());
   }
 
+  @Option(option = "eda", description = "Use EDA variant")
+  public void setEda(BooleanOption eda) {
+    this.eda = eda;
+  }
+
+  @OptionValues("eda")
+  public List<BooleanOption> getEdaOptions() {
+    return Arrays.asList(BooleanOption.values());
+  }
+
   @Option(option = "cache-mode", description = "Set value for cache type")
   public void setCacheMode(DrivenAdapterBinStash.CacheMode cacheMode) {
     this.cacheMode = cacheMode;
@@ -49,6 +60,7 @@ public void setCacheMode(DrivenAdapterBinStash.CacheMode cacheMode) {
   protected void prepareParams() {
     builder.addParam("task-param-cache-mode", cacheMode);
     builder.addParam("include-secret", secret == BooleanOption.TRUE);
+    builder.addParam("eda", eda == BooleanOption.TRUE);
     builder.addParam(DrivenAdapterRedis.PARAM_MODE, mode);
     builder.addParam("task-param-url", url);
   }

diff --git a/src/main/java/co/com/bancolombia/task/GenerateEntryPointTask.java b/src/main/java/co/com/bancolombia/task/GenerateEntryPointTask.java
@@ -19,6 +19,7 @@ public class GenerateEntryPointTask extends AbstractResolvableTypeTask {
   private Server server = Server.UNDERTOW;
   private BooleanOption router = BooleanOption.TRUE;
   private BooleanOption swagger = BooleanOption.FALSE;
+  private BooleanOption eda = BooleanOption.FALSE;
 
   @Option(
       option = "server",
@@ -42,6 +43,16 @@ public void setPathGraphql(String pathgql) {
     this.pathGraphql = pathgql;
   }
 
+  @Option(option = "eda", description = "Use EDA variant")
+  public void setEda(BooleanOption eda) {
+    this.eda = eda;
+  }
+
+  @OptionValues("eda")
+  public List<BooleanOption> getEdaOptions() {
+    return Arrays.asList(BooleanOption.values());
+  }
+
   @OptionValues("server")
   public List<Server> getServerOptions() {
     return Arrays.asList(Server.values());
@@ -63,6 +74,7 @@ protected void prepareParams() {
     builder.addParam("task-param-pathgql", pathGraphql);
     builder.addParam("task-param-router", router == BooleanOption.TRUE);
     builder.addParam("include-swagger", swagger == BooleanOption.TRUE);
+    builder.addParam("eda", eda == BooleanOption.TRUE);
   }
 
   @Override

diff --git a/src/main/resources/driven-adapter/async-event-bus/build.gradle.mustache b/src/main/resources/driven-adapter/async-event-bus/build.gradle.mustache
@@ -1,5 +1,14 @@
 dependencies {
     implementation project(':model')
+    {{^eda}}
     implementation 'org.reactivecommons:async-commons-rabbit-starter:{{asyncCommonsStarterVersion}}'
+    {{/eda}}
+    {{#eda}}
+    implementation 'org.reactivecommons:async-commons-rabbit-starter-eda:{{asyncCommonsStarterVersion}}'
+    implementation 'io.cloudevents:cloudevents-core:2.4.2'
+    implementation 'io.cloudevents:cloudevents-http-basic:2.4.2'
+    implementation 'io.cloudevents:cloudevents-json-jackson:2.4.2'
+    implementation 'io.cloudevents:cloudevents-spring:2.4.2'
+    {{/eda}}
     implementation 'org.springframework:spring-context'
 }
diff --git a/src/main/resources/driven-adapter/async-event-bus/events-gateway.java.mustache b/src/main/resources/driven-adapter/async-event-bus/events-gateway.java.mustache
@@ -3,5 +3,6 @@ package {{package}}.model.events.gateways;
 import reactor.core.publisher.Mono;
 
 public interface EventsGateway {
-    Mono<Void> emit(Object event);
+Mono<Void> emit(Object event);
+
 }
diff --git a/...main/resources/driven-adapter/async-event-bus/reactive-direct-async-gateway.java.mustache b/...main/resources/driven-adapter/async-event-bus/reactive-direct-async-gateway.java.mustache
@@ -4,13 +4,30 @@ package {{package}}.events;
 import lombok.AllArgsConstructor;
 import lombok.extern.java.Log;
 {{/lombok}}
+{{#eda}}
 import org.reactivecommons.api.domain.Command;
 import org.reactivecommons.async.api.AsyncQuery;
 import org.reactivecommons.async.api.DirectAsyncGateway;
 import org.reactivecommons.async.impl.config.annotations.EnableDirectAsyncGateway;
 import reactor.core.publisher.Mono;
+import io.cloudevents.CloudEvent;
+import io.cloudevents.core.builder.CloudEventBuilder;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
 
 import java.util.UUID;
+import java.net.URI;
+import java.time.OffsetDateTime;
+{{/eda}}
+{{^eda}}
+import org.reactivecommons.api.domain.Command;
+import org.reactivecommons.async.api.AsyncQuery;
+import org.reactivecommons.async.api.DirectAsyncGateway;
+import org.reactivecommons.async.impl.config.annotations.EnableDirectAsyncGateway;
+import reactor.core.publisher.Mono;
+
+import java.util.UUID;
+{{/eda}}
 {{#lombok}}
 import java.util.logging.Level;
 {{/lombok}}
@@ -25,25 +42,56 @@ public class ReactiveDirectAsyncGateway /* implements Gateway from domain */ {
     public static final String SOME_COMMAND_NAME = "some.command.name";
     public static final String SOME_QUERY_NAME = "some.query.name";
     private final DirectAsyncGateway gateway;
+    {{#eda}}
+    private ObjectMapper om = new ObjectMapper();
+    {{/eda}}
 
     {{^lombok}}
     public ReactiveDirectAsyncGateway(DirectAsyncGateway gateway) {
         this.gateway = gateway;
     }
     {{/lombok}}
 
-    public Mono<Void> runRemoteJob(Object command/*change for proper model*/) {
+    public Mono<Void> runRemoteJob(Object command/*change for proper model*/) throws JsonProcessingException {
         {{#lombok}}
         log.log(Level.INFO, "Sending command: {0}: {1}", new String[]{SOME_COMMAND_NAME, command.toString()});
         {{/lombok}}
-        return gateway.sendCommand(new Command<>(SOME_COMMAND_NAME, UUID.randomUUID().toString(), command),
+        {{#eda}}
+        CloudEvent commandCloudEvent = CloudEventBuilder.v1() //
+                                .withId(UUID.randomUUID().toString()) //
+                                .withSource(URI.create("https://spring.io/foos"))//
+                                .withType(SOME_COMMAND_NAME) //
+                                .withTime(OffsetDateTime.now())
+                                .withData("application/json", om.writeValueAsBytes(command))
+                                .build();
+
+        return gateway.sendCommand(new Command<CloudEvent>(SOME_COMMAND_NAME, UUID.randomUUID().toString(), commandCloudEvent),
                 TARGET_NAME);
+        {{/eda}}
+        {{^eda}}
+        return gateway.sendCommand(new Command<>(SOME_COMMAND_NAME, UUID.randomUUID().toString(), command),
+                        TARGET_NAME);
+        {{/eda}}
     }
 
-    public Mono<Object> requestForRemoteData(Object query/*change for proper model*/) {
+    public Mono<Object> requestForRemoteData(Object query/*change for proper model*/) throws JsonProcessingException {
         {{#lombok}}
         log.log(Level.INFO, "Sending query request: {0}: {1}", new String[]{SOME_QUERY_NAME, query.toString()});
         {{/lombok}}
+        {{^eda}}
         return gateway.requestReply(new AsyncQuery<>(SOME_QUERY_NAME, query), TARGET_NAME, Object.class/*change for proper model*/);
+        {{/eda}}
+        {{#eda}}
+
+        CloudEvent queryCloudEvent = CloudEventBuilder.v1() //
+                        .withId(UUID.randomUUID().toString()) //
+                        .withSource(URI.create("https://spring.io/foos"))//
+                        .withType(SOME_QUERY_NAME) //
+                        .withTime(OffsetDateTime.now())
+                        .withData("application/json", om.writeValueAsBytes(query))
+                        .build();
+
+        return gateway.requestReply(new AsyncQuery<CloudEvent>(SOME_QUERY_NAME, queryCloudEvent), TARGET_NAME, Object.class/*change for proper model*/);
+        {{/eda}}
     }
 }
diff --git a/src/main/resources/driven-adapter/async-event-bus/reactive-events-gateway.java.mustache b/src/main/resources/driven-adapter/async-event-bus/reactive-events-gateway.java.mustache
@@ -5,12 +5,28 @@ import {{package}}.model.events.gateways.EventsGateway;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.java.Log;
 {{/lombok}}
+{{#eda}}
 import org.reactivecommons.api.domain.DomainEvent;
 import org.reactivecommons.api.domain.DomainEventBus;
 import org.reactivecommons.async.impl.config.annotations.EnableDomainEventBus;
 import reactor.core.publisher.Mono;
+import io.cloudevents.CloudEvent;
+import io.cloudevents.core.builder.CloudEventBuilder;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
 
 import java.util.UUID;
+import java.net.URI;
+import java.time.OffsetDateTime;
+{{/eda}}
+{{^eda}}
+import org.reactivecommons.api.domain.DomainEvent;
+import org.reactivecommons.api.domain.DomainEventBus;
+import org.reactivecommons.async.impl.config.annotations.EnableDomainEventBus;
+import reactor.core.publisher.Mono;
+
+import java.util.UUID;
+{{/eda}}
 {{#lombok}}
 import java.util.logging.Level;
 {{/lombok}}
@@ -25,6 +41,9 @@ import static reactor.core.publisher.Mono.from;
 public class ReactiveEventsGateway implements EventsGateway {
     public static final String SOME_EVENT_NAME = "some.event.name";
     private final DomainEventBus domainEventBus;
+    {{#eda}}
+    private ObjectMapper om = new ObjectMapper();
+    {{/eda}}
 
     {{^lombok}}
     public ReactiveEventsGateway(DomainEventBus domainEventBus) {
@@ -37,6 +56,27 @@ public class ReactiveEventsGateway implements EventsGateway {
         {{#lombok}}
         log.log(Level.INFO, "Sending domain event: {0}: {1}", new String[]{SOME_EVENT_NAME, event.toString()});
         {{/lombok}}
-        return from(domainEventBus.emit(new DomainEvent<>(SOME_EVENT_NAME, UUID.randomUUID().toString(), event)));
+        CloudEvent  eventCloudEvent = null;
+        {{#eda}}
+        try{
+           eventCloudEvent = CloudEventBuilder.v1() //
+                       .withId(UUID.randomUUID().toString()) //
+                       .withSource(URI.create("https://spring.io/foos"))//
+                       .withType(SOME_EVENT_NAME) //
+                       .withDataContentType("application/json")
+                       .withTime(OffsetDateTime.now())
+                       .withData("application/json", om.writeValueAsBytes(event))
+                       .build();
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+
+
+         return from(domainEventBus.emit(new DomainEvent<CloudEvent>(SOME_EVENT_NAME, UUID.randomUUID().toString(), eventCloudEvent)));
+        {{/eda}}
+        {{^eda}}
+         return from(domainEventBus.emit(new DomainEvent<>(SOME_EVENT_NAME, UUID.randomUUID().toString(), event)));
+        {{/eda}}
+
     }
 }
diff --git a/src/main/resources/entry-point/async-event-handler/build.gradle.mustache b/src/main/resources/entry-point/async-event-handler/build.gradle.mustache
@@ -1,7 +1,16 @@
 dependencies {
     implementation project(':model')
     implementation project(':usecase')
+    {{^eda}}
     implementation 'org.reactivecommons:async-commons-rabbit-starter:{{asyncCommonsStarterVersion}}'
+    {{/eda}}
+    {{#eda}}
+    implementation 'org.reactivecommons:async-commons-rabbit-starter-eda:{{asyncCommonsStarterVersion}}'
+    implementation 'io.cloudevents:cloudevents-core:2.4.2'
+    implementation 'io.cloudevents:cloudevents-http-basic:2.4.2'
+    implementation 'io.cloudevents:cloudevents-json-jackson:2.4.2'
+    implementation 'io.cloudevents:cloudevents-spring:2.4.2'
+    {{/eda}}
     implementation 'org.springframework:spring-context'
     {{#metrics}}
     implementation 'io.micrometer:micrometer-core'

diff --git a/src/main/resources/entry-point/async-event-handler/commands-handler.java.mustache b/src/main/resources/entry-point/async-event-handler/commands-handler.java.mustache
@@ -6,6 +6,9 @@ import lombok.AllArgsConstructor;
 import org.reactivecommons.api.domain.Command;
 import org.reactivecommons.async.impl.config.annotations.EnableCommandListeners;
 import reactor.core.publisher.Mono;
+{{#eda}}
+import io.cloudevents.CloudEvent;
+{{/eda}}
 
 {{#lombok}}
 @AllArgsConstructor
@@ -19,10 +22,19 @@ public class CommandsHandler {
         //this.sampleUseCase = sampleUseCase;
     }
 {{/lombok}}
-
+{{#eda}}
+    public Mono<Void> handleCommandA(Command<CloudEvent> command) {
+        System.out.println("command received: " + command.getName() + " ->" + command.getData()); // TODO: Remove this line
+//        return sampleUseCase.doSomething(command.getData());
+        return Mono.empty();
+    }
+{{/eda}}
+{{^eda}}
     public Mono<Void> handleCommandA(Command<Object/*change for proper model*/> command) {
         System.out.println("command received: " + command.getName() + " ->" + command.getData()); // TODO: Remove this line
 //        return sampleUseCase.doSomething(command.getData());
         return Mono.empty();
     }
+{{/eda}}
+
 }
diff --git a/src/main/resources/entry-point/async-event-handler/commands-handler.test.java.mustache b/src/main/resources/entry-point/async-event-handler/commands-handler.test.java.mustache
@@ -4,6 +4,14 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.reactivecommons.api.domain.Command;
 import reactor.test.StepVerifier;
+{{#eda}}
+import io.cloudevents.CloudEvent;
+import io.cloudevents.core.builder.CloudEventBuilder;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.net.URI;
+{{/eda}}
+
 
 import java.util.UUID;
 
@@ -16,12 +24,27 @@ public class CommandsHandlerTest {
         commandsHandler = new CommandsHandler();
     }
 
-    @Test
-    void handleCommandATest(){
-        StepVerifier.create(commandsHandler.handleCommandA(
-            new Command<>("COMMAND",
-                UUID.randomUUID().toString(),
-                    "Data"))).expectComplete();
-    }
-
+    {{#eda}}
+     @Test
+        void handleCommandATest() throws JsonProcessingException{
+        ObjectMapper objectMapper = new ObjectMapper();
+        CloudEvent command = CloudEventBuilder.v1() //
+                        .withId(UUID.randomUUID().toString()) //
+                        .withSource(URI.create("https://spring.io/foos"))//
+                        .withType("command")
+                        .withData("application/json", objectMapper.writeValueAsBytes("Data"))
+                        .build();
+            StepVerifier.create(commandsHandler.handleCommandA(
+                new Command<CloudEvent>(command.getType(), command.getId(), command))).expectComplete();
+        }
+    {{/eda}}
+    {{^eda}}
+     @Test
+        void handleCommandATest(){
+            StepVerifier.create(commandsHandler.handleCommandA(
+                new Command<>("COMMAND",
+                    UUID.randomUUID().toString(),
+                        "Data"))).expectComplete();
+        }
+    {{/eda}}
 }
diff --git a/src/main/resources/entry-point/async-event-handler/events-handler.java.mustache b/src/main/resources/entry-point/async-event-handler/events-handler.java.mustache
@@ -6,6 +6,9 @@ import lombok.AllArgsConstructor;
 import org.reactivecommons.api.domain.DomainEvent;
 import org.reactivecommons.async.impl.config.annotations.EnableEventListeners;
 import reactor.core.publisher.Mono;
+{{#eda}}
+import io.cloudevents.CloudEvent;
+{{/eda}}
 
 {{#lombok}}
 @AllArgsConstructor
@@ -19,10 +22,19 @@ public class EventsHandler {
         //this.sampleUseCase = sampleUseCase;
     }
 {{/lombok}}
+{{#eda}}
+    public Mono<Void> handleEventA(DomainEvent<CloudEvent> event) {
+        System.out.println("event received: " + event.getName() + " ->" + event.getData()); // TODO: Remove this line
+//        return sampleUseCase.doSomething(event.getData());
+        return Mono.empty();
+    }
+{{/eda}}
 
+{{^eda}}
     public Mono<Void> handleEventA(DomainEvent<Object/*change for proper model*/> event) {
         System.out.println("event received: " + event.getName() + " ->" + event.getData()); // TODO: Remove this line
 //        return sampleUseCase.doSomething(event.getData());
         return Mono.empty();
     }
+{{/eda}}
 }