Remove the outdated ParsedTransaction class (#11)

gjong · web-flow · commit c86e074041fe · 2024-04-06T09:28:57.000+02:00
* Mark the transaction deprecated to find all uses and create build warnings.
* Move all the logic away from the old ParsedTransaction.java and towards the new TransactionDTO.
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/ProcessEngineConfiguration.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/ProcessEngineConfiguration.java
@@ -3,7 +3,7 @@
 import com.jongsoft.finance.ProcessVariable;
 import com.jongsoft.finance.bpmn.camunda.*;
 import com.jongsoft.finance.core.DataSourceMigration;
-import com.jongsoft.finance.serialized.ImportJobSettings;
+import com.jongsoft.finance.importer.api.TransactionDTO;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.annotation.Context;
 import io.micronaut.context.annotation.Factory;
@@ -58,7 +58,8 @@ public ProcessEngine processEngine() throws IOException {
         configuration.setHistoryTimeToLive("P1D");
         configuration.setResolverFactories(List.of(new MicronautBeanResolver(applicationContext)));
         configuration.setCustomPreVariableSerializers(List.of(
-                new JsonRecordSerializer<>(applicationContext.getBean(ObjectMapper.class), ProcessVariable.class)));
+                new JsonRecordSerializer<>(applicationContext.getBean(ObjectMapper.class), ProcessVariable.class),
+                new JsonRecordSerializer<>(applicationContext.getBean(ObjectMapper.class), TransactionDTO.class)));
 
         var processEngine = configuration.buildProcessEngine();
         log.info("Created camunda process engine");
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/camunda/JsonRecordSerializer.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/camunda/JsonRecordSerializer.java
@@ -27,7 +27,7 @@ public JsonRecordSerializer(ObjectMapper objectMapper, Class<T> supportedClass)
 
     @Override
     public String getName() {
-        return "record-json";
+        return supportedClass.getName();
     }
 
     @Override
@@ -37,7 +37,7 @@ public String getSerializationDataformat() {
 
     @Override
     public TypedValue convertToTypedValue(UntypedValueImpl untypedValue) {
-        logger.debug("Converting untyped value to typed value: {}", untypedValue.getType());
+        logger.trace("Converting untyped value to typed value: {}", untypedValue.getValue().getClass().getSimpleName());
 
         var importJobSettings = (Record) untypedValue.getValue();
         String jsonString;
@@ -46,8 +46,9 @@ public TypedValue convertToTypedValue(UntypedValueImpl untypedValue) {
         } catch (IOException e) {
             throw new RuntimeException("Could not serialize ImportJobSettings", e);
         }
+
         return Variables.serializedObjectValue(jsonString)
-                .serializationDataFormat(getName())
+                .serializationDataFormat("application/json")
                 .create();
     }
 
@@ -59,12 +60,12 @@ public void writeValue(TypedValue typedValue, ValueFields valueFields) {
 
     @Override
     public TypedValue readValue(ValueFields valueFields, boolean b, boolean b1) {
-        logger.debug("Reading value from value fields: {}", valueFields.getName());
+        logger.trace("Reading value from value fields: {}", valueFields.getName());
         try {
             return Variables.objectValue(objectMapper.readValue(
                             new String(valueFields.getByteArrayValue()),
                             supportedClass))
-                    .serializationDataFormat(getName())
+                    .serializationDataFormat("application/json")
                     .create();
         } catch (IOException e) {
             throw new RuntimeException("Could not deserialize ImportJobSettings", e);
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ImportAccountExtractorDelegate.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ImportAccountExtractorDelegate.java
@@ -8,6 +8,14 @@
 import java.util.HashSet;
 import java.util.Set;
 
+/**
+ * Extracts account mappings from the import transaction.
+ * <p>
+ *     This delegate is used to extract account mappings from the imported transaction.
+ *     The account mappings are stored in a set of {@link ExtractionMapping} objects.
+ *     The account mappings are used to map the account names in the import transaction to the account IDs in the finance system.
+ * <p>
+ */
 @Slf4j
 public class ImportAccountExtractorDelegate implements JavaDelegate {
 
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/LocateAccountInMapping.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/LocateAccountInMapping.java
@@ -8,6 +8,18 @@
 
 import java.util.Collection;
 
+/**
+ * Locates an account in a mapping and sets the account ID as a process variable.
+ * <p>
+ *     The account name is retrieved from a process variable named {@code name}.
+ *     The account mappings are retrieved from a process variable named {@code accountMappings}
+ * </p>
+ * <p>
+ *     The account ID is set as a process variable named {@code accountId}.
+ *     If the account name does not match the account name in the mapping, a synonym is registered.
+ *     The synonym is the account name from the mapping.
+ * </p>
+ **/
 @Slf4j
 @Singleton
 public class LocateAccountInMapping implements JavaDelegate {
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ParsedTransaction.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ParsedTransaction.java
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ReadTransactionFromStorage.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ReadTransactionFromStorage.java
@@ -2,13 +2,22 @@
 
 import com.jongsoft.finance.ProcessMapper;
 import com.jongsoft.finance.StorageService;
+import com.jongsoft.finance.importer.api.TransactionDTO;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import org.camunda.bpm.engine.delegate.DelegateExecution;
 import org.camunda.bpm.engine.delegate.JavaDelegate;
 
 import java.nio.charset.StandardCharsets;
 
+/**
+ * Reads a transaction from storage.
+ * <p>
+ *     This delegate reads a transaction from storage using the {@code storageToken} provided in the process variables.
+ *     The transaction is then stored in the process variables as {@code transaction}.
+ *     The transaction is stored as a {@link TransactionDTO} object.
+ * </p>
+ */
 @Singleton
 public class ReadTransactionFromStorage implements JavaDelegate {
 
@@ -27,7 +36,7 @@ public void execute(DelegateExecution delegateExecution) throws Exception {
 
         var transaction = storageService.read(storageToken)
                 .map(byteArray -> new String(byteArray, StandardCharsets.UTF_8))
-                .map(json -> processMapper.readSafe(json, ParsedTransaction.class))
+                .map(json -> processMapper.readSafe(json, TransactionDTO.class))
                 .getOrThrow(() -> new RuntimeException("Failed to read transaction from storage"));
 
         delegateExecution.setVariableLocal("transaction", transaction);
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ReadTransactionLogDelegate.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/importer/ReadTransactionLogDelegate.java
@@ -16,6 +16,21 @@
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * Delegate to trigger the actual {@link ImporterProvider} to start the job of fetching and converting the transactions.
+ * <p>
+ *     The delegate will look up the {@link ImporterProvider} that supports the {@link ImporterConfiguration} of the
+ *     current import job and start the process of reading the transactions.
+ *     The transactions are then serialized and stored in the {@link StorageService} and the tokens are stored in the
+ *     process variables called {@code storageTokens}.
+ * </p>
+ * <p>
+ *     The delegate will also set the process variables {@code generateAccounts}, {@code applyRules} and {@code targetAccountId}
+ *     based on the {@link ImportJobSettings} of the current import job.
+ *     The delegate will log a warning if no {@link ImporterProvider} is found for the {@link ImporterConfiguration} of the
+ *     current import job.
+ * </p>
+ */
 @Slf4j
 @Singleton
 public class ReadTransactionLogDelegate implements JavaDelegate {
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/scheduler/GenerateTransactionJsonDelegate.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/scheduler/GenerateTransactionJsonDelegate.java
@@ -1,8 +1,8 @@
 package com.jongsoft.finance.bpmn.delegate.scheduler;
 
-import com.jongsoft.finance.bpmn.delegate.importer.ParsedTransaction;
+import com.jongsoft.finance.core.TransactionType;
 import com.jongsoft.finance.domain.transaction.ScheduledTransaction;
-import com.jongsoft.finance.domain.transaction.Transaction;
+import com.jongsoft.finance.importer.api.TransactionDTO;
 import com.jongsoft.finance.providers.TransactionScheduleProvider;
 import jakarta.inject.Singleton;
 import org.camunda.bpm.engine.delegate.DelegateExecution;
@@ -28,13 +28,15 @@ public void execute(DelegateExecution execution) throws Exception {
 
         transactionScheduleProvider.lookup(scheduledTransactionId)
                 .ifPresent(schedule -> {
-                    var transaction = ParsedTransaction.builder()
-                            .amount(schedule.getAmount())
-                            .type(Transaction.Type.CREDIT)
-                            .transactionDate(LocalDate.parse(isoDate))
-                            .description(generateTransactionDescription(schedule))
-                            .build();
-
+                    var transaction = new TransactionDTO(
+                            schedule.getAmount(),
+                            TransactionType.CREDIT,
+                            generateTransactionDescription(schedule),
+                            LocalDate.parse(isoDate),
+                            null,
+                            null,
+                            schedule.getDestination().getIban(),
+                            schedule.getDestination().getName());
 
                     execution.setVariable("destinationId", schedule.getDestination().getId());
                     execution.setVariable("sourceId", schedule.getSource().getId());
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/transaction/CreateTransactionDelegate.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/transaction/CreateTransactionDelegate.java
@@ -1,8 +1,8 @@
 package com.jongsoft.finance.bpmn.delegate.transaction;
 
-import com.jongsoft.finance.bpmn.delegate.importer.ParsedTransaction;
 import com.jongsoft.finance.domain.account.Account;
 import com.jongsoft.finance.domain.transaction.Transaction;
+import com.jongsoft.finance.importer.api.TransactionDTO;
 import com.jongsoft.finance.messaging.commands.transaction.CreateTransactionCommand;
 import com.jongsoft.finance.messaging.handlers.TransactionCreationHandler;
 import com.jongsoft.finance.providers.AccountProvider;
@@ -12,6 +12,23 @@
 import org.camunda.bpm.engine.delegate.JavaDelegate;
 import org.camunda.bpm.engine.variable.value.LongValue;
 
+/**
+ * Delegate for creating a transaction in the system.
+ * <p>
+ *     This delegate is responsible for creating a transaction in the system. It is used in the BPMN process to
+ *     create a transaction from the parsed transaction data.
+    * </p>
+ * <p>
+ *     The delegate expects the following variables to be present in the execution:
+ *     <ul>
+ *         <li>transaction: The parsed transaction data from the import job</li>
+ *         <li>accountId: The ID of the account to create the transaction in</li>
+ *         <li>targetAccount: The ID of the account to create the transaction for</li>
+ *         <li>importJobSlug: The slug of the import job that the transaction is part of</li>
+ *      </ul>
+ *      The delegate will create the transaction in the target account and set the {@code transactionId} in the execution.
+ * </p>
+ */
 @Slf4j
 @Singleton
 public class CreateTransactionDelegate implements JavaDelegate {
@@ -27,25 +44,31 @@ public class CreateTransactionDelegate implements JavaDelegate {
     @Override
     public void execute(DelegateExecution execution) throws Exception {
         var batchImportSlug = (String) execution.getVariable("importJobSlug");
-        var parsedTransaction = (ParsedTransaction) execution.getVariableLocal("transaction");
+        var parsedTransaction = (TransactionDTO) execution.getVariableLocal("transaction");
         var toAccount = lookupAccount(execution, "accountId");
         var targetAccount = lookupAccount(execution, "targetAccount");
 
         log.debug("{}: Creating transaction into {} from {} with amount {}",
                 execution.getCurrentActivityName(),
                 targetAccount.getName(),
                 toAccount.getName(),
-                parsedTransaction.getAmount());
+                parsedTransaction.amount());
+
+        var type = switch (parsedTransaction.type()) {
+            case DEBIT -> Transaction.Type.DEBIT;
+            case CREDIT -> Transaction.Type.CREDIT;
+            case TRANSFER -> Transaction.Type.TRANSFER;
+        };
 
         Transaction transaction = targetAccount.createTransaction(
                 toAccount,
-                parsedTransaction.getAmount(),
-                parsedTransaction.getType(),
+                parsedTransaction.amount(),
+                type,
                 t -> t.currency(targetAccount.getCurrency())
-                        .date(parsedTransaction.getTransactionDate())
-                        .bookDate(parsedTransaction.getBookDate())
-                        .interestDate(parsedTransaction.getInterestDate())
-                        .description(parsedTransaction.getDescription())
+                        .date(parsedTransaction.transactionDate())
+                        .bookDate(parsedTransaction.bookDate())
+                        .interestDate(parsedTransaction.interestDate())
+                        .description(parsedTransaction.description())
                         .importSlug(batchImportSlug));
 
         long transactionId = creationHandler.handleCreatedEvent(new CreateTransactionCommand(transaction));
diff --git a/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/transaction/PrepareAccountGenerationDelegate.java b/bpmn-process/src/main/java/com/jongsoft/finance/bpmn/delegate/transaction/PrepareAccountGenerationDelegate.java
@@ -1,7 +1,9 @@
 package com.jongsoft.finance.bpmn.delegate.transaction;
 
 import com.jongsoft.finance.ProcessMapper;
-import com.jongsoft.finance.bpmn.delegate.importer.ParsedTransaction;
+import com.jongsoft.finance.core.TransactionType;
+import com.jongsoft.finance.importer.api.TransactionDTO;
+import com.jongsoft.finance.serialized.AccountJson;
 import jakarta.inject.Singleton;
 import lombok.extern.slf4j.Slf4j;
 import org.camunda.bpm.engine.delegate.DelegateExecution;
@@ -23,15 +25,22 @@ public class PrepareAccountGenerationDelegate implements JavaDelegate {
 
     @Override
     public void execute(DelegateExecution execution) throws Exception {
-        var transaction = (ParsedTransaction) execution.getVariableLocal("transaction");
+        var transaction = (TransactionDTO) execution.getVariableLocal("transaction");
 
         log.debug("{}: Extracting the account to be created from the transaction {}.",
                 execution.getCurrentActivityName(),
-                transaction.getAccount().getName());
+                transaction.opposingName());
+
+        var accountJson = AccountJson.builder()
+                .name(transaction.opposingName())
+                .iban(transaction.opposingIBAN())
+                .type(transaction.type() == TransactionType.CREDIT ? "creditor" : "debtor")
+                .currency("EUR")// todo this needs to be fixed later on
+                .build();
 
         execution.setVariableLocal(
                 "accountJson",
-                mapper.writeSafe(transaction.getAccount()));
+                mapper.writeSafe(accountJson));
     }
 
 }
diff --git a/bpmn-process/src/main/resources/bpmn/transaction/import-job.bpmn b/bpmn-process/src/main/resources/bpmn/transaction/import-job.bpmn
@@ -217,7 +217,7 @@ When calling the flow the following variables must be set:
       <bpmn:userTask id="user_create_account" name="User create account">
         <bpmn:extensionElements>
           <camunda:inputOutput>
-            <camunda:inputParameter name="accountName">${transaction.opposingName}</camunda:inputParameter>
+            <camunda:inputParameter name="accountName">${transaction.opposingName()}</camunda:inputParameter>
             <camunda:inputParameter name="basedOnAccount">${targetAccountId}</camunda:inputParameter>
             <camunda:outputParameter name="accountId">${accountId}</camunda:outputParameter>
           </camunda:inputOutput>
@@ -230,7 +230,7 @@ When calling the flow the following variables must be set:
       <bpmn:serviceTask id="locate_account_mapping" name="Locate account in mapping" camunda:modelerTemplate="com.jongsoft.finance.bpmn.delegate.importer.LocateAccountInMapping" camunda:modelerTemplateVersion="1" camunda:delegateExpression="${locateAccountInMapping}">
         <bpmn:extensionElements>
           <camunda:inputOutput>
-            <camunda:inputParameter name="name">${transaction.opposingName}</camunda:inputParameter>
+            <camunda:inputParameter name="name">${transaction.opposingName()}</camunda:inputParameter>
             <camunda:outputParameter name="accountId">${accountId}</camunda:outputParameter>
           </camunda:inputOutput>
         </bpmn:extensionElements>
@@ -297,7 +297,7 @@ When calling the flow the following variables must be set:
           <camunda:inputOutput>
             <camunda:inputParameter name="iban" />
             <camunda:inputParameter name="id" />
-            <camunda:inputParameter name="name">${transaction.opposingName}</camunda:inputParameter>
+            <camunda:inputParameter name="name">${transaction.opposingName()}</camunda:inputParameter>
             <camunda:outputParameter name="accountId">${id}</camunda:outputParameter>
           </camunda:inputOutput>
         </bpmn:extensionElements>
