Document the code of analytics and customer microservices

Author: BOURGUI07

analytics-service/src/main/java/com/example/analytics_service/config/ProductEventConsumerConfig.java

@@ -17,6 +17,15 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+/**
+ * The Catalog-Microservice will emit product-events
+ * among these events, ViewedProductEvents
+ * The Analytics-Microservice gonna receive those events wrapped in Message formats
+ * Then it will convert them into custom Records
+ * Consumer the Record message (or the Message payload)
+ * Then acknowledge the messages.
+ */
+
 @Configuration
 @RequiredArgsConstructor
 @Slf4j

analytics-service/src/main/java/com/example/analytics_service/consumer/ProductViewConsumerImpl.java

@@ -8,6 +8,10 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+/**
+ * The Analytics-Microservice gonna consume ViewedProductEvents
+ */
+
 @Service
 @RequiredArgsConstructor
 @Slf4j

analytics-service/src/main/java/com/example/analytics_service/events/ProductEvent.java

@@ -2,10 +2,15 @@
 
 import lombok.Builder;
 
+
 public sealed interface ProductEvent {
 
     String code();
 
+    /**
+     * This ViewedProductEvent gonna be emitted by the catalog-microservice
+     */
+
     @Builder
     record View(String code) implements ProductEvent {}
 }

analytics-service/src/main/java/com/example/analytics_service/service/ProductViewService.java

@@ -26,12 +26,20 @@ public class ProductViewService {
 
     private final ProductViewRepo repo;
 
+    /**
+     * Return the top 5 most viewed products in descending order
+     */
     public Flux<ProductViewDTO> products() {
        return  repo.findTop5ByOrderByViewCountDesc()
                 .map(Mapper.toDTO());
     }
 
-
+    /**
+     * Find the product by code
+     * if it does exist, increase its viewing count by one
+     * if it doesn't, create a new one with 1 as view count
+     * then save into the DB
+     */
     public Function<ProductEvent.View,Mono<Void>> consume(){
         return event -> repo.findByProductCode(event.code())
                 .doOnNext(p -> p.setViewCount(p.getViewCount()+1))

customer-service/src/main/java/com/example/customer_service/config/CustomerEventPublisherConfig.java

@@ -14,6 +14,14 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+/**
+ * The Customer-Microservice gonna emit CustomerEvents.
+ * Before emitting them, it will wrap them in Message format
+ * As the Notification-Microservice will eventually need the customer infos
+ * such as username and email, it will consumer these customer-events
+ * to be able to send emails.
+ */
+
 @Configuration
 @RequiredArgsConstructor
 @Slf4j

customer-service/src/main/java/com/example/customer_service/config/OrderEventProcessorConfig.java

@@ -14,6 +14,15 @@
 
 import java.util.function.Function;
 
+/**
+ * The Order-Microservice gonna emit order-events.
+ * Among the service that gonna process those events, is the Customer-Microservice
+ * It will convert the Message of events into Record of events.
+ * Process the Records messages (or the Message payloads)
+ * then as a reaction, will publish customer-events wrapped into messages
+ */
+
+
 @Slf4j
 @Configuration
 @RequiredArgsConstructor

customer-service/src/main/java/com/example/customer_service/events/EventProcessor.java

@@ -2,6 +2,12 @@
 
 import reactor.core.publisher.Mono;
 
+/**
+ * The Event process gonna process order-events which are order-saga
+ * then publish customer-events which are order-saga as well
+ */
+
+
 public interface EventProcessor<T extends OrderSaga, R extends OrderSaga> {
     Mono<R> process(T event);
 }

customer-service/src/main/java/com/example/customer_service/events/OrderEventProcessor.java

@@ -2,6 +2,11 @@
 
 import reactor.core.publisher.Mono;
 
+/**
+ * The customer-Microservice gonna process each order-event
+ * be it created, completed, or cancelled
+ */
+
 public interface OrderEventProcessor extends EventProcessor<OrderEvent,PaymentEvent> {
 
     @Override

customer-service/src/main/java/com/example/customer_service/processor/OrderEventProcessorImpl.java

@@ -20,6 +20,15 @@
 public class OrderEventProcessorImpl implements OrderEventProcessor {
     private final PaymentService service;
 
+    /**
+     * if the OrderEvent received is Created, then it will convert it into
+     * PaymentRequest DTO so that the payment-service will be able to process it
+     * After processing, the payment-service will return a PaymentResponse.DTO
+     * the latter will be converted into DeductedPaymentEvent.
+     * If a duplicate event exception is raised, then do nothing
+     * A DeclinedPaymentEvent will be returned if either CustomerNotFoundException or NotEnoughBalanceException is raised
+     */
+
     @Override
     public Mono<PaymentEvent> handle(OrderEvent.Created event) {
         return service.processPayment().apply(((PaymentDTO.Request) EventMapper.toRequest().apply(event)))
@@ -31,11 +40,22 @@ public Mono<PaymentEvent> handle(OrderEvent.Created event) {
                 .onErrorResume(NotEnoughBalanceException.class, ex -> EventMapper.toDeclined().apply(ex,event));
     }
 
+    /**
+     * If the order is completed, we basically have to do nothing
+     */
+
     @Override
     public Mono<PaymentEvent> handle(OrderEvent.Completed event) {
         return Mono.empty();
     }
 
+
+    /**
+     * If the order is cancelled, we basically have to refund the payment.
+     * we will only need event orderId to process the refund request.
+     * The payment-service will return a PaymentResponseDTO
+     * will converted to RefundedPaymentEvent
+     */
     @Override
     public Mono<PaymentEvent> handle(OrderEvent.Cancelled event) {
         return service.refund().apply(event.orderId())

customer-service/src/main/java/com/example/customer_service/publisher/CustomerEventPublisherImpl.java

@@ -8,6 +8,14 @@
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 
+/**
+ * These customer-events will be published so that
+ * the notification-Microservice can consume them
+ * here we've used the EventCarriedStateTransfer pattern
+ * to avoid network calls
+ */
+
+
 @Service
 @RequiredArgsConstructor
 @Slf4j