Add ChangedAmount field and WithdrawalBodyChanged event handler

pom.xml

@@ -134,7 +134,7 @@
         <dependency>
             <groupId>dev.vality</groupId>
             <artifactId>swag-wallets-webhook-events-server</artifactId>
-            <version>1.43-1b943c0</version>
+            <version>1.45-4390ebb</version>
         </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>

src/main/java/dev/vality/wallets/hooker/handler/withdrawal/WithdrawalAdjustmentSucceededHandler.java

@@ -0,0 +1,58 @@
+package dev.vality.wallets.hooker.handler.withdrawal;
+
+import dev.vality.fistful.withdrawal.TimestampedChange;
+import dev.vality.fistful.withdrawal.WithdrawalState;
+import dev.vality.machinegun.eventsink.MachineEvent;
+import dev.vality.wallets.hooker.domain.enums.EventType;
+import dev.vality.wallets.hooker.service.WithdrawalClient;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class WithdrawalAdjustmentSucceededHandler implements WithdrawalEventHandler {
+
+    private final WithdrawalChangeStatusHandler withdrawalChangeStatusHandler;
+    private final WithdrawalClient withdrawalClient;
+
+    @Override
+    public boolean accept(TimestampedChange change) {
+        return change.getChange().isSetAdjustment()
+                && change.getChange().getAdjustment().isSetPayload()
+                && change.getChange().getAdjustment().getPayload().isSetStatusChanged()
+                && change.getChange().getAdjustment().getPayload().getStatusChanged().isSetStatus()
+                && change.getChange().getAdjustment().getPayload().getStatusChanged().getStatus().isSetSucceeded();
+    }
+
+    @Override
+    public void handle(TimestampedChange change, MachineEvent event) {
+        String withdrawalId = event.getSourceId();
+        WithdrawalState withdrawalState = getWithdrawalState(withdrawalId, event.getEventId());
+        if (withdrawalState != null
+                && withdrawalState.getStatus() != null
+                && withdrawalState.getStatus().isSetSucceeded()) {
+            log.info("Start handling WithdrawalAdjustmentChange: withdrawalId={} change={}", withdrawalId, change);
+
+            withdrawalChangeStatusHandler.handleChangeStatus(
+                    change,
+                    event,
+                    withdrawalId,
+                    EventType.WITHDRAWAL_SUCCEEDED,
+                    withdrawalState);
+
+            log.info("Finish handling WithdrawalAdjustmentChange: withdrawalId={}", withdrawalId);
+        }
+    }
+
+    private WithdrawalState getWithdrawalState(String withdrawalId, Long eventId) {
+        try {
+            return withdrawalClient.getWithdrawalInfo(withdrawalId, eventId);
+        } catch (Exception e) {
+            log.warn("Error getting withdrawal state for withdrawalId={}, eventId={}: {}",
+                    withdrawalId, eventId, e.getMessage());
+            return null;
+        }
+    }
+}

src/main/java/dev/vality/wallets/hooker/handler/withdrawal/WithdrawalChangeStatusHandler.java

@@ -1,7 +1,7 @@
 package dev.vality.wallets.hooker.handler.withdrawal;
 
-import dev.vality.fistful.withdrawal.StatusChange;
 import dev.vality.fistful.withdrawal.TimestampedChange;
+import dev.vality.fistful.withdrawal.WithdrawalState;
 import dev.vality.machinegun.eventsink.MachineEvent;
 import dev.vality.wallets.hooker.dao.webhook.WebHookDao;
 import dev.vality.wallets.hooker.dao.withdrawal.WithdrawalReferenceDao;
@@ -35,7 +35,8 @@ public void handleChangeStatus(
             TimestampedChange change,
             MachineEvent event,
             String withdrawalId,
-            EventType eventType) {
+            EventType eventType,
+            WithdrawalState withdrawalState) {
         try {
             var reference = waitReferenceWithdrawal(withdrawalId);
             Long parentId = Long.valueOf(reference.getEventId());
@@ -44,13 +45,14 @@ public void handleChangeStatus(
                     .filter(webHook -> webHook.getWalletId() == null
                             || webHook.getWalletId().equals(reference.getWalletId()))
                     .map(webhook -> generateWithdrawalStatusChangeHookMsg(
-                            change.getChange().getStatusChanged(),
+                            change,
                             webhook,
                             withdrawalId,
                             event.getEventId(),
                             parentId,
                             event.getCreatedAt(),
-                            reference.getExternalId()))
+                            reference.getExternalId(),
+                            withdrawalState))
                     .forEach(webHookMessageSenderService::send);
         } catch (Exception e) {
             log.error("Error while handling WithdrawalStatusChangedChange: {}, withdrawalId: {}",
@@ -76,22 +78,24 @@ private WithdrawalReference waitReferenceWithdrawal(String withdrawalId) {
     }
 
     private WebhookMessage generateWithdrawalStatusChangeHookMsg(
-            StatusChange statusChanged,
+            TimestampedChange change,
             WebHookModel webhook,
             String withdrawalId,
             long eventId,
             Long parentId,
             String createdAt,
-            String externalId) {
+            String externalId,
+            WithdrawalState withdrawalState) {
         MessageGenParams messageGenParams = MessageGenParams.builder()
                 .sourceId(withdrawalId)
                 .eventId(eventId)
                 .parentId(parentId)
                 .createdAt(createdAt)
                 .externalId(externalId)
+                .withdrawalState(withdrawalState)
                 .build();
 
-        return withdrawalStatusChangedHookMessageGenerator.generate(statusChanged, webhook, messageGenParams);
+        return withdrawalStatusChangedHookMessageGenerator.generate(change, webhook, messageGenParams);
     }
 
 }

src/main/java/dev/vality/wallets/hooker/handler/withdrawal/WithdrawalFailedHandler.java

@@ -1,8 +1,10 @@
 package dev.vality.wallets.hooker.handler.withdrawal;
 
 import dev.vality.fistful.withdrawal.TimestampedChange;
+import dev.vality.fistful.withdrawal.WithdrawalState;
 import dev.vality.machinegun.eventsink.MachineEvent;
 import dev.vality.wallets.hooker.domain.enums.EventType;
+import dev.vality.wallets.hooker.service.WithdrawalClient;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
@@ -14,6 +16,7 @@ public class WithdrawalFailedHandler implements WithdrawalEventHandler {
 
     private final WithdrawalChangeStatusHandler withdrawalChangeStatusHandler;
 
+
     @Override
     public boolean accept(TimestampedChange change) {
         return change.getChange().isSetStatusChanged()
@@ -30,8 +33,10 @@ public void handle(TimestampedChange change, MachineEvent event) {
                 change,
                 event,
                 withdrawalId,
-                EventType.WITHDRAWAL_FAILED);
+                EventType.WITHDRAWAL_FAILED,
+                null);
 
         log.info("Finish handling WithdrawalFailedChange: withdrawalId={}", withdrawalId);
     }
+
 }

src/main/java/dev/vality/wallets/hooker/handler/withdrawal/WithdrawalSucceededHandler.java

@@ -1,8 +1,10 @@
 package dev.vality.wallets.hooker.handler.withdrawal;
 
 import dev.vality.fistful.withdrawal.TimestampedChange;
+import dev.vality.fistful.withdrawal.WithdrawalState;
 import dev.vality.machinegun.eventsink.MachineEvent;
 import dev.vality.wallets.hooker.domain.enums.EventType;
+import dev.vality.wallets.hooker.service.WithdrawalClient;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
@@ -13,6 +15,7 @@
 public class WithdrawalSucceededHandler implements WithdrawalEventHandler {
 
     private final WithdrawalChangeStatusHandler withdrawalChangeStatusHandler;
+    private final WithdrawalClient withdrawalClient;
 
     @Override
     public boolean accept(TimestampedChange change) {
@@ -24,14 +27,27 @@ public boolean accept(TimestampedChange change) {
     @Override
     public void handle(TimestampedChange change, MachineEvent event) {
         String withdrawalId = event.getSourceId();
+        WithdrawalState withdrawalState = getWithdrawalState(withdrawalId, event.getEventId());
+
         log.info("Start handling WithdrawalSucceededChange: withdrawalId={} change={}", withdrawalId, change);
 
         withdrawalChangeStatusHandler.handleChangeStatus(
                 change,
                 event,
                 withdrawalId,
-                EventType.WITHDRAWAL_SUCCEEDED);
+                EventType.WITHDRAWAL_SUCCEEDED,
+                withdrawalState);
 
         log.info("Finish handling WithdrawalSucceededChange: withdrawalId={}", withdrawalId);
     }
-}
+
+    private WithdrawalState getWithdrawalState(String withdrawalId, Long eventId) {
+        try {
+            return withdrawalClient.getWithdrawalInfo(withdrawalId, eventId);
+        } catch (Exception e) {
+            log.warn("Error getting withdrawal state for withdrawalId={}, eventId={}: {}",
+                    withdrawalId, eventId, e.getMessage());
+            return null;
+        }
+    }
+}

src/main/java/dev/vality/wallets/hooker/handler/withdrawal/generator/WithdrawalStatusChangedHookMessageGenerator.java

@@ -3,22 +3,17 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import dev.vality.fistful.base.Cash;
+import dev.vality.fistful.withdrawal.TimestampedChange;
 import dev.vality.fistful.withdrawal.WithdrawalState;
-import dev.vality.fistful.withdrawal.StatusChange;
 import dev.vality.fistful.withdrawal.status.Status;
-import dev.vality.swag.wallets.webhook.events.model.Event;
-import dev.vality.swag.wallets.webhook.events.model.Fee;
-import dev.vality.swag.wallets.webhook.events.model.WithdrawalBody;
-import dev.vality.swag.wallets.webhook.events.model.WithdrawalFailed;
-import dev.vality.swag.wallets.webhook.events.model.WithdrawalSucceeded;
+import dev.vality.swag.wallets.webhook.events.model.*;
 import dev.vality.wallets.hooker.domain.WebHookModel;
 import dev.vality.wallets.hooker.domain.enums.EventType;
 import dev.vality.wallets.hooker.exception.GenerateMessageException;
 import dev.vality.wallets.hooker.handler.AdditionalHeadersGenerator;
 import dev.vality.wallets.hooker.model.MessageGenParams;
 import dev.vality.wallets.hooker.service.BaseHookMessageGenerator;
 import dev.vality.wallets.hooker.service.WebHookMessageGeneratorServiceImpl;
-import dev.vality.wallets.hooker.service.WithdrawalClient;
 import dev.vality.wallets.hooker.utils.CashFlowUtils;
 import dev.vality.webhook.dispatcher.WebhookMessage;
 import lombok.extern.slf4j.Slf4j;
@@ -30,41 +25,41 @@
 
 @Slf4j
 @Component
-public class WithdrawalStatusChangedHookMessageGenerator extends BaseHookMessageGenerator<StatusChange> {
+public class WithdrawalStatusChangedHookMessageGenerator extends BaseHookMessageGenerator<TimestampedChange> {
 
-    private final WebHookMessageGeneratorServiceImpl<StatusChange> generatorService;
+    private final WebHookMessageGeneratorServiceImpl<TimestampedChange> generatorService;
     private final ObjectMapper objectMapper;
     private final AdditionalHeadersGenerator additionalHeadersGenerator;
-    private final WithdrawalClient withdrawalClient;
 
     public WithdrawalStatusChangedHookMessageGenerator(
-            WebHookMessageGeneratorServiceImpl<StatusChange> generatorService,
+            WebHookMessageGeneratorServiceImpl<TimestampedChange> generatorService,
             ObjectMapper objectMapper,
             AdditionalHeadersGenerator additionalHeadersGenerator,
-            WithdrawalClient withdrawalClient,
             @Value("${parent.not.exist.id}") Long parentId) {
         super(parentId);
         this.generatorService = generatorService;
         this.objectMapper = objectMapper;
         this.additionalHeadersGenerator = additionalHeadersGenerator;
-        this.withdrawalClient = withdrawalClient;
     }
 
     @Override
     protected WebhookMessage generateMessage(
-            StatusChange event,
+            TimestampedChange event,
             WebHookModel model,
             MessageGenParams messageGenParams) {
         try {
             String message = initRequestBody(
-                    event.getStatus(),
+                    event.getChange().isSetStatusChanged()
+                            ? event.getChange().getStatusChanged().getStatus()
+                            : messageGenParams.getWithdrawalState().getStatus(),
                     messageGenParams.getSourceId(),
                     messageGenParams.getEventId(),
                     messageGenParams.getCreatedAt(),
-                    messageGenParams.getExternalId());
+                    messageGenParams.getExternalId(),
+                    messageGenParams.getWithdrawalState());
 
             WebhookMessage webhookMessage = generatorService.generate(event, model, messageGenParams);
-            webhookMessage.setParentEventId(initPatenId(model, messageGenParams.getParentId()));
+            webhookMessage.setParentEventId(initParenId(model, messageGenParams.getParentId()));
             webhookMessage.setRequestBody(message.getBytes());
             webhookMessage.setAdditionalHeaders(additionalHeadersGenerator.generate(model, message));
 
@@ -82,7 +77,7 @@ protected WebhookMessage generateMessage(
 
     }
 
-    private Long initPatenId(WebHookModel model, Long parentId) {
+    private Long initParenId(WebHookModel model, Long parentId) {
         if (model.getEventTypes() != null && model.getEventTypes().contains(EventType.WITHDRAWAL_CREATED)) {
             return parentId;
         }
@@ -95,7 +90,8 @@ private String initRequestBody(
             String withdrawalId,
             Long eventId,
             String createdAt,
-            String externalId) throws JsonProcessingException {
+            String externalId,
+            WithdrawalState withdrawalState) throws JsonProcessingException {
         if (status.isSetFailed()) {
             WithdrawalFailed withdrawalFailed = new WithdrawalFailed()
                     .withdrawalID(withdrawalId)
@@ -106,7 +102,6 @@ private String initRequestBody(
             withdrawalFailed.setTopic(Event.TopicEnum.WITHDRAWAL_TOPIC);
             return objectMapper.writeValueAsString(withdrawalFailed);
         } else if (status.isSetSucceeded()) {
-            WithdrawalState withdrawalState = getWithdrawalState(withdrawalId, eventId);
             Fee fee = calculateFee(withdrawalId, eventId, withdrawalState);
             WithdrawalSucceeded withdrawalSucceeded = new WithdrawalSucceeded()
                     .withdrawalID(withdrawalId)
@@ -127,16 +122,6 @@ private String initRequestBody(
         }
     }
 
-    private WithdrawalState getWithdrawalState(String withdrawalId, Long eventId) {
-        try {
-            return withdrawalClient.getWithdrawalInfo(withdrawalId, eventId);
-        } catch (Exception e) {
-            log.warn("Error getting withdrawal state for withdrawalId={}, eventId={}: {}",
-                    withdrawalId, eventId, e.getMessage());
-            return null;
-        }
-    }
-
     private Fee calculateFee(String withdrawalId, Long eventId, WithdrawalState withdrawalState) {
         if (withdrawalState != null
                 && withdrawalState.getEffectiveFinalCashFlow() != null
@@ -154,18 +139,19 @@ private WithdrawalBody initNewBody(WithdrawalState withdrawalState) {
         if (!amountChanged(withdrawalState)) {
             return null;
         }
-        return initBody(withdrawalState.getNewBody());
+        return initBody(withdrawalState.getNewBody(), withdrawalState.getBody());
     }
 
     private boolean amountChanged(WithdrawalState withdrawalState) {
         return withdrawalState != null
                 && withdrawalState.isSetNewBody();
     }
 
-    private WithdrawalBody initBody(Cash body) {
+    private WithdrawalBody initBody(Cash newBody, Cash oldBody) {
         var withdrawalBody = new WithdrawalBody();
-        withdrawalBody.setAmount(body.getAmount());
-        withdrawalBody.setCurrency(body.getCurrency().getSymbolicCode());
+        withdrawalBody.setAmount(oldBody.getAmount());
+        withdrawalBody.setChangedAmount(newBody.getAmount());
+        withdrawalBody.setCurrency(newBody.getCurrency().getSymbolicCode());
         return withdrawalBody;
     }
 

src/main/java/dev/vality/wallets/hooker/model/MessageGenParams.java

@@ -1,5 +1,6 @@
 package dev.vality.wallets.hooker.model;
 
+import dev.vality.fistful.withdrawal.WithdrawalState;
 import lombok.Builder;
 import lombok.Data;
 
@@ -17,4 +18,6 @@ public class MessageGenParams {
 
     private String externalId;
 
+    private WithdrawalState withdrawalState;
+
 }