Merge pull request #24 from openMF/foundation-onboarding-workflows-setup

Foundation onboarding workflows setup

Author: IOhacker

README.md

@@ -1,5 +1,24 @@
 # mifos-workflow
 
+### Default Configuration
+
+The application uses these default credentials (you should override them with environment variables):
+
+**Database (Flowable):**
+- Username: `mifos`
+- Password: Set via `DB_PASSWORD` environment variable
+
+**Fineract API:**
+- Username: `mifos`
+- Password: Set via `FINERACT_PASSWORD` environment variable
+
+### Example Setup
+
+```bash
+export DB_PASSWORD=your_secure_db_password
+export FINERACT_PASSWORD=your_secure_fineract_password
+```
+
 ## Documentation
 
 Documentation is available in the `docs/` directory. To generate HTML documentation:

src/main/java/org/mifos/workflow/config/FineractApiConfig.java

@@ -26,6 +26,8 @@
 
 import javax.net.ssl.*;
 import java.lang.reflect.Type;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
 import java.time.LocalDate;
@@ -65,8 +67,10 @@ public X509Certificate[] getAcceptedIssuers() {
         try {
             trustAllSslContext = SSLContext.getInstance("SSL");
             trustAllSslContext.init(null, trustAllCerts, new java.security.SecureRandom());
-        } catch (Exception e) {
-            throw new RuntimeException("Failed to initialize trust-all SSL context", e);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException("SSL algorithm not available", e);
+        } catch (KeyManagementException e) {
+            throw new RuntimeException("Failed to initialize SSL key management", e);
         }
     }
 

src/main/java/org/mifos/workflow/config/WorkflowConfig.java

@@ -15,6 +15,8 @@ public class WorkflowConfig {
 
     private Engine engine = new Engine();
     private Fineract fineract = new Fineract();
+    private Authentication authentication = new Authentication();
+    private Process process = new Process();
 
     @Data
     public static class Engine {
@@ -26,14 +28,40 @@ public static class Engine {
     public static class Flowable {
         private boolean asyncExecutorEnabled = true;
         private boolean databaseSchemaUpdate = true;
+        private boolean historyEnabled = true;
+        private String databaseType = "mysql";
+        private String databaseUrl;
+        private String databaseUsername;
+        private String databasePassword;
     }
 
     @Data
     public static class Fineract {
-        private String baseUrl = "http://localhost:8443/fineract-provider/api/v1/";
-        private String username = "mifos";
-        private String password = "password";
-        private String tenantId = "default";
+        private String baseUrl;
+        private String username;
+        private String password;
+        private String tenantId;
+        private boolean testEnabled;
+        private int connectionTimeout = 30000;
+        private int readTimeout = 30000;
     }
 
+    @Data
+    public static class Authentication {
+        private boolean enabled = true;
+        private String authKeyHeader = "Authorization";
+        private String authKeyPrefix = "Basic ";
+        private int tokenRefreshInterval = 3600;
+        private boolean autoRefresh = true;
+    }
+
+    @Data
+    public static class Process {
+        private String defaultAssignee = "system";
+        private boolean autoDeploy = true;
+        private String processLocation = "classpath:processes/";
+        private boolean enableProcessHistory = true;
+        private int maxProcessInstances = 1000;
+        private int processTimeout = 86400;
+    }
 }

src/main/java/org/mifos/workflow/core/engine/WorkflowEngineFactory.java

@@ -9,7 +9,6 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-
 /**
  * Factory class for creating instances of WorkflowEngine based on configuration.
  * This implements the factory pattern to support dynamic selection of workflow engines.
@@ -20,30 +19,32 @@ public class WorkflowEngineFactory {
     private static final Logger logger = LoggerFactory.getLogger(WorkflowEngineFactory.class);
 
     private final WorkflowConfig properties;
+    private final FlowableWorkflowEngine flowableWorkflowEngine;
 
     @Getter
     private WorkflowEngine workflowEngine;
 
     @Autowired
-    public WorkflowEngineFactory(WorkflowConfig properties) {
+    public WorkflowEngineFactory(WorkflowConfig properties, FlowableWorkflowEngine flowableWorkflowEngine) {
         this.properties = properties;
+        this.flowableWorkflowEngine = flowableWorkflowEngine;
     }
 
     @PostConstruct
     private void init() {
-        String engineType = properties.getEngine().getType().toLowerCase();
+        String engineType = properties.getEngine().getType().trim().toLowerCase();
         logger.info("Initializing workflow engine of type: {}", engineType);
         switch (engineType) {
             case "flowable":
-                this.workflowEngine = new FlowableWorkflowEngine(properties);
+                this.workflowEngine = flowableWorkflowEngine;
                 break;
             case "temporal":
                 logger.warn("Temporal engine not yet implemented, falling back to Flowable");
+                this.workflowEngine = flowableWorkflowEngine;
                 break;
             default:
                 logger.error("Unsupported workflow engine type: {}", engineType);
                 throw new IllegalArgumentException("Unsupported workflow engine type: " + engineType);
         }
     }
-
 }

src/main/java/org/mifos/workflow/core/engine/delegates/AccountVerificationDelegate.java

@@ -0,0 +1,31 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for verifying client accounts in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class AccountVerificationDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(AccountVerificationDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement account verification logic
+        logger.info("AccountVerificationDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        Long clientId = (Long) execution.getVariable("clientId");
+        if (clientId == null) {
+            throw new IllegalArgumentException("clientId is missing from process variables");
+        }
+        // String clientIdStr = clientId.toString();
+        logger.info("Would verify accounts for client {}", clientId);
+    }
+} 

src/main/java/org/mifos/workflow/core/engine/delegates/ClientActivationDelegate.java

@@ -0,0 +1,31 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for activating a client in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class ClientActivationDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(ClientActivationDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement client activation logic
+        logger.info("ClientActivationDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        Long clientId = (Long) execution.getVariable("clientId");
+        if (clientId == null) {
+            throw new IllegalArgumentException("clientId is missing from process variables");
+        }
+        // String clientIdStr = clientId.toString();
+        logger.info("Would activate client with ID: {}", clientId);
+    }
+} 

src/main/java/org/mifos/workflow/core/engine/delegates/ClientClosureDelegate.java

@@ -0,0 +1,34 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for closing a client in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class ClientClosureDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(ClientClosureDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement client closure logic
+        logger.info("ClientClosureDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        Long clientId = (Long) execution.getVariable("clientId");
+        if (clientId == null) {
+            throw new IllegalArgumentException("clientId is missing from process variables");
+        }
+        Long closureReasonId = (Long) execution.getVariable("closureReasonId");
+        if (closureReasonId == null) {
+            throw new IllegalArgumentException("closureReasonId is missing from process variables");
+        }
+        logger.info("Would close client {} with reason ID: {}", clientId, closureReasonId);
+    }
+} 

src/main/java/org/mifos/workflow/core/engine/delegates/ClientCreationDelegate.java

@@ -0,0 +1,26 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for creating a new client in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class ClientCreationDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(ClientCreationDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement client creation logic
+        logger.info("ClientCreationDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        execution.setVariable("clientId", System.currentTimeMillis());
+    }
+} 

src/main/java/org/mifos/workflow/core/engine/delegates/ClientRejectionDelegate.java

@@ -0,0 +1,31 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for rejecting a client in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class ClientRejectionDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(ClientRejectionDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement client rejection logic
+        logger.info("ClientRejectionDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        Long clientId = (Long) execution.getVariable("clientId");
+        if (clientId == null) {
+            throw new IllegalArgumentException("clientId is missing from process variables");
+        }
+        String rejectionReason = (String) execution.getVariable("rejectionReason");
+        logger.info("Would reject client with ID: {} for reason: {}", clientId, rejectionReason);
+    }
+} 

src/main/java/org/mifos/workflow/core/engine/delegates/ClientTransferDelegate.java

@@ -0,0 +1,34 @@
+package org.mifos.workflow.core.engine.delegates;
+
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegate for transferring a client in the Fineract system.
+ * This is a placeholder implementation.
+ * Full implementation will be provided later.
+ */
+public class ClientTransferDelegate implements JavaDelegate {
+
+    private static final Logger logger = LoggerFactory.getLogger(ClientTransferDelegate.class);
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        // TODO: Implement client transfer logic
+        logger.info("ClientTransferDelegate.execute() called - placeholder implementation");
+        logger.info("Process instance ID: {}", execution.getProcessInstanceId());
+        logger.info("Variables: {}", execution.getVariables());
+
+        Long clientId = (Long) execution.getVariable("clientId");
+        if (clientId == null) {
+            throw new IllegalArgumentException("clientId is missing from process variables");
+        }
+        Long destinationOfficeId = (Long) execution.getVariable("destinationOfficeId");
+        if (destinationOfficeId == null) {
+            throw new IllegalArgumentException("destinationOfficeId is missing from process variables");
+        }
+        logger.info("Would transfer client {} to office {}", clientId, destinationOfficeId);
+    }
+}