BPMN 2.0 — Business Process Model and Notation

<!-- None Start Event -->
<startEvent id="start" name="Start Process"/>
 
<!-- Timer Start Event: chạy mỗi ngày lúc 8:00 AM -->
<startEvent id="timerStart" name="Daily Trigger">
   <timerEventDefinition>
       <timeCycle>0 0 8 * * ?</timeCycle>
   </timerEventDefinition>
</startEvent>
 
<!-- Message Start Event -->
<startEvent id="msgStart" name="Order Received">
   <messageEventDefinition messageRef="orderMessage"/>
</startEvent>

<!-- Timer Intermediate (wait/delay) -->
<intermediateCatchEvent id="wait3days" name="Wait 3 Days">
   <timerEventDefinition>
       <timeDuration>P3D</timeDuration>  <!-- ISO 8601: 3 days -->
   </timerEventDefinition>
</intermediateCatchEvent>
 
<!-- Message Intermediate Catch (wait for message) -->
<intermediateCatchEvent id="waitApproval" name="Wait for Approval">
   <messageEventDefinition messageRef="approvalMessage"/>
</intermediateCatchEvent>
 
<!-- Signal Throw (broadcast to all processes listening) -->
<intermediateThrowEvent id="notifyAll" name="Notify All">
   <signalEventDefinition signalRef="processCompleteSignal"/>
</intermediateThrowEvent>
 
<!-- Boundary Timer (attached to task — deadline/timeout) -->
<boundaryEvent id="deadline" attachedToRef="reviewTask" cancelActivity="true">
   <timerEventDefinition>
       <timeDuration>PT48H</timeDuration>  <!-- 48 hours timeout -->
   </timerEventDefinition>
</boundaryEvent>
<!-- Nếu reviewTask không xong trong 48h → cancel task, đi đường khác -->

<!-- Normal End -->
<endEvent id="end" name="Process Complete"/>
 
<!-- Terminate End: kill tất cả parallel paths -->
<endEvent id="terminateEnd" name="Abort All">
   <terminateEventDefinition/>
</endEvent>
 
<!-- Error End: throw error lên parent process -->
<endEvent id="errorEnd" name="Payment Failed">
   <errorEventDefinition errorRef="paymentError"/>
</endEvent>

<userTask id="approveRequest" name="Approve Loan Request"
         activiti:assignee="${applicant}"
         activiti:candidateGroups="loan-approvers">
   <documentation>Review loan application and approve/reject</documentation>
 
   <!-- Form properties (hiển thị form cho user) -->
   <extensionElements>
       <activiti:formProperty id="decision" name="Decision"
           type="enum" required="true">
           <activiti:value id="approve" name="Approve"/>
           <activiti:value id="reject" name="Reject"/>
       </activiti:formProperty>
       <activiti:formProperty id="comments" name="Comments"
           type="string" required="false"/>
   </extensionElements>
</userTask>

<!-- Java Delegate -->
<serviceTask id="calculateScore" name="Calculate Credit Score"
            activiti:class="com.example.bpm.delegate.CreditScoreDelegate"/>
 
<!-- Expression (call Spring bean method) -->
<serviceTask id="sendNotification" name="Send Email"
            activiti:expression="${notificationService.sendEmail(execution)}"/>
 
<!-- Delegate Expression (Spring bean) -->
<serviceTask id="processPayment" name="Process Payment"
            activiti:delegateExpression="${paymentDelegate}"/>
 
<!-- HTTP Task (REST call) -->
<serviceTask id="callExternalApi" name="Verify Identity"
            activiti:type="http">
   <extensionElements>
       <activiti:field name="requestMethod" stringValue="POST"/>
       <activiti:field name="requestUrl"
           stringValue="http://identity-service/api/v1/verify"/>
       <activiti:field name="requestBody"
           expression="${execution.getVariable('requestPayload')}"/>
   </extensionElements>
</serviceTask>

@Component("creditScoreDelegate")
@RequiredArgsConstructor
@Slf4j
public class CreditScoreDelegate implements JavaDelegate {
 
   private final CreditScoringService scoringService;
 
   @Override
   public void execute(DelegateExecution execution) {
       String customerId = (String) execution.getVariable("customerId");
       BigDecimal loanAmount = (BigDecimal) execution.getVariable("loanAmount");
 
       log.info("Calculating credit score | customerId={} | loanAmount={}",
           customerId, loanAmount);
 
       CreditScore score = scoringService.calculate(customerId, loanAmount);
 
       // Set process variables cho downstream tasks
       execution.setVariable("creditScore", score.getValue());
       execution.setVariable("riskLevel", score.getRiskLevel().name());
       execution.setVariable("autoApproved", score.getValue() >= 750);
   }
}

<!-- Embedded Sub-Process: nhóm related tasks, shared error handling -->
<subProcess id="paymentSubProcess" name="Payment Processing">
   <startEvent id="payStart"/>
   <serviceTask id="validatePayment" name="Validate"/>
   <serviceTask id="executePayment" name="Execute"/>
   <serviceTask id="confirmPayment" name="Confirm"/>
   <endEvent id="payEnd"/>
 
   <!-- Sequence flows within sub-process -->
   <sequenceFlow sourceRef="payStart" targetRef="validatePayment"/>
   <sequenceFlow sourceRef="validatePayment" targetRef="executePayment"/>
   <sequenceFlow sourceRef="executePayment" targetRef="confirmPayment"/>
   <sequenceFlow sourceRef="confirmPayment" targetRef="payEnd"/>
 
   <!-- Error boundary on entire sub-process -->
   <boundaryEvent id="paymentError" attachedToRef="paymentSubProcess">
       <errorEventDefinition errorRef="paymentFailedError"/>
   </boundaryEvent>
</subProcess>

<!-- Sequential: process items one by one -->
<serviceTask id="processItem" name="Process Item"
            activiti:delegateExpression="${itemProcessor}">
   <multiInstanceLoopCharacteristics isSequential="true"
       activiti:collection="${orderItems}"
       activiti:elementVariable="currentItem"/>
</serviceTask>
 
<!-- Parallel: process ALL items simultaneously -->
<userTask id="approveByAll" name="Approve By All Managers"
         activiti:candidateGroups="managers">
   <multiInstanceLoopCharacteristics isSequential="false"
       activiti:collection="${approverList}"
       activiti:elementVariable="approver">
       <!-- Complete when 60% approved -->
       <completionCondition>${nrOfCompletedInstances / nrOfInstances >= 0.6}</completionCondition>
   </multiInstanceLoopCharacteristics>
</userTask>

<exclusiveGateway id="decisionGateway" name="Approve or Reject?"/>
 
<sequenceFlow sourceRef="decisionGateway" targetRef="approvedPath">
   <conditionExpression xsi:type="tFormalExpression">
       ${decision == 'approve'}
   </conditionExpression>
</sequenceFlow>
 
<sequenceFlow sourceRef="decisionGateway" targetRef="rejectedPath">
   <conditionExpression xsi:type="tFormalExpression">
       ${decision == 'reject'}
   </conditionExpression>
</sequenceFlow>
 
<!-- Default flow (khi không condition nào match) -->
<sequenceFlow sourceRef="decisionGateway" targetRef="manualReview"
             id="defaultFlow"/>
<exclusiveGateway id="decisionGateway" default="defaultFlow"/>

<!-- Fork: split into parallel paths -->
<parallelGateway id="forkGateway"/>
<sequenceFlow sourceRef="forkGateway" targetRef="sendEmail"/>
<sequenceFlow sourceRef="forkGateway" targetRef="updateInventory"/>
<sequenceFlow sourceRef="forkGateway" targetRef="generateInvoice"/>
 
<!-- Tất cả 3 tasks chạy ĐỒNG THỜI -->
 
<!-- Join: wait for ALL to complete -->
<parallelGateway id="joinGateway"/>
<sequenceFlow sourceRef="sendEmail" targetRef="joinGateway"/>
<sequenceFlow sourceRef="updateInventory" targetRef="joinGateway"/>
<sequenceFlow sourceRef="generateInvoice" targetRef="joinGateway"/>
 
<!-- Chỉ tiếp tục khi cả 3 xong -->
<sequenceFlow sourceRef="joinGateway" targetRef="completeOrder"/>

<inclusiveGateway id="notifyGateway" name="Notification Channels"/>
 
<!-- Chạy tất cả paths có condition true -->
<sequenceFlow sourceRef="notifyGateway" targetRef="sendSms">
   <conditionExpression>${customer.phoneVerified == true}</conditionExpression>
</sequenceFlow>
<sequenceFlow sourceRef="notifyGateway" targetRef="sendEmail">
   <conditionExpression>${customer.email != null}</conditionExpression>
</sequenceFlow>
<sequenceFlow sourceRef="notifyGateway" targetRef="pushNotification">
   <conditionExpression>${customer.deviceToken != null}</conditionExpression>
</sequenceFlow>
 
<!-- Merge: chờ tất cả activated paths hoàn thành -->
<inclusiveGateway id="notifyJoin"/>

<!-- Chờ: hoặc customer respond, hoặc timeout 7 ngày -->
<eventBasedGateway id="waitGateway"/>
 
<sequenceFlow sourceRef="waitGateway" targetRef="customerResponse"/>
<intermediateCatchEvent id="customerResponse">
   <messageEventDefinition messageRef="responseMessage"/>
</intermediateCatchEvent>
 
<sequenceFlow sourceRef="waitGateway" targetRef="timeout"/>
<intermediateCatchEvent id="timeout">
   <timerEventDefinition>
       <timeDuration>P7D</timeDuration>
   </timerEventDefinition>
</intermediateCatchEvent>
<!-- Event nào đến TRƯỚC → đi path đó, cancel paths còn lại -->

// Set variable khi start process
Map<String, Object> variables = new HashMap<>();
variables.put("applicantName", "Nguyen Van A");
variables.put("loanAmount", new BigDecimal("500000000"));
variables.put("applicationDate", LocalDate.now());
variables.put("documents", documentList);
 
ProcessInstance instance = runtimeService.startProcessInstanceByKey(
   "loan-approval", businessKey, variables);
 
// Read/write trong Java Delegate
@Override
public void execute(DelegateExecution execution) {
   BigDecimal amount = (BigDecimal) execution.getVariable("loanAmount");
   execution.setVariable("interestRate", calculateRate(amount));
 
   // Transient variable (không persist, chỉ tồn tại trong memory)
   execution.setTransientVariable("tempCalculation", intermediateResult);
}
 
// Expression trong BPMN XML
// UEL (Unified Expression Language)
${applicantName}                          // Read variable
${loanAmount > 1000000000}                // Condition
${riskLevel == 'HIGH' ? 'manual' : 'auto'} // Ternary
${orderService.calculateTotal(orderId)}    // Call Spring bean method
#{execution.getVariable('status')}         // Alternative syntax

<userTask id="approveTask" name="Approve">
   <extensionElements>
       <!-- Chạy khi task START -->
       <activiti:executionListener event="start"
           delegateExpression="${taskAuditListener}"/>
       <!-- Chạy khi task END -->
       <activiti:executionListener event="end"
           expression="${metricsService.recordTaskCompletion(execution)}"/>
   </extensionElements>
</userTask>
 
<!-- Process-level listener -->
<process id="loanProcess">
   <extensionElements>
       <activiti:executionListener event="start"
           delegateExpression="${processStartListener}"/>
       <activiti:executionListener event="end"
           delegateExpression="${processEndListener}"/>
   </extensionElements>
</process>

<userTask id="reviewTask">
   <extensionElements>
       <!-- Khi task được CREATE (assigned to someone) -->
       <activiti:taskListener event="create"
           delegateExpression="${taskAssignmentListener}"/>
       <!-- Khi task COMPLETE -->
       <activiti:taskListener event="complete"
           expression="${notificationService.notifyCompletion(task)}"/>
       <!-- Khi task bị DELETE (cancelled) -->
       <activiti:taskListener event="delete"
           delegateExpression="${taskCancellationListener}"/>
   </extensionElements>
</userTask>

@Component("taskAssignmentListener")
@RequiredArgsConstructor
@Slf4j
public class TaskAssignmentListener implements TaskListener {
 
   private final NotificationService notificationService;
 
   @Override
   public void notify(DelegateTask task) {
       String assignee = task.getAssignee();
       String taskName = task.getName();
       String processId = task.getProcessInstanceId();
 
       log.info("Task assigned | task={} | assignee={} | processId={}",
           taskName, assignee, processId);
 
       notificationService.sendTaskNotification(assignee,
           "New task assigned: " + taskName);
   }
}

<serviceTask id="callPayment" name="Process Payment"
            activiti:delegateExpression="${paymentDelegate}"/>
 
<!-- Boundary error event: catch payment failure -->
<boundaryEvent id="paymentFailed" attachedToRef="callPayment">
   <errorEventDefinition errorRef="PAYMENT_FAILED"/>
</boundaryEvent>
 
<!-- Khi paymentDelegate throw BpmnError("PAYMENT_FAILED") -->
<sequenceFlow sourceRef="paymentFailed" targetRef="handlePaymentFailure"/>
<serviceTask id="handlePaymentFailure" name="Handle Payment Failure"
            activiti:delegateExpression="${paymentFailureHandler}"/>

@Component("paymentDelegate")
public class PaymentDelegate implements JavaDelegate {
   @Override
   public void execute(DelegateExecution execution) {
       try {
           paymentService.process(execution.getVariable("paymentId"));
       } catch (PaymentDeclinedException e) {
           // Throw BpmnError → caught by boundary error event
           throw new BpmnError("PAYMENT_FAILED", e.getMessage());
       }
       // Các exceptions KHÔNG phải BpmnError → escalate lên process level
   }
}

<!-- Task đã complete thành công -->
<serviceTask id="reserveInventory" name="Reserve Inventory"
            activiti:delegateExpression="${inventoryReserveDelegate}"/>
 
<!-- Compensation handler: undo reservation nếu process cần rollback -->
<boundaryEvent id="compensateReserve" attachedToRef="reserveInventory">
   <compensateEventDefinition/>
</boundaryEvent>
<serviceTask id="cancelReservation" name="Cancel Reservation"
            isForCompensation="true"
            activiti:delegateExpression="${inventoryReleaseDelegate}"/>
<association sourceRef="compensateReserve" targetRef="cancelReservation"/>
 
<!-- Trigger compensation khi cần undo -->
<intermediateThrowEvent id="undoAll" name="Compensate All">
   <compensateEventDefinition/>
</intermediateThrowEvent>

@Configuration
public class ActivitiConfig {
 
   @Bean
   public SpringProcessEngineConfiguration processEngineConfiguration(
           DataSource dataSource,
           PlatformTransactionManager transactionManager) {
 
       SpringProcessEngineConfiguration config = new SpringProcessEngineConfiguration();
       config.setDataSource(dataSource);
       config.setTransactionManager(transactionManager);
       config.setDatabaseSchemaUpdate("true");
       config.setAsyncExecutorActivate(true);
       config.setHistoryLevel(HistoryLevel.FULL);
       return config;
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class ProcessService {
 
   private final RepositoryService repositoryService;
   private final RuntimeService runtimeService;
   private final TaskService taskService;
   private final HistoryService historyService;
 
   // Deploy process definition
   public String deploy(String bpmnXml, String processName) {
       Deployment deployment = repositoryService.createDeployment()
           .name(processName)
           .addString(processName + ".bpmn20.xml", bpmnXml)
           .deploy();
       return deployment.getId();
   }
 
   // Start process instance
   public String startProcess(String processKey, Map<String, Object> variables) {
       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           processKey, UUID.randomUUID().toString(), variables);
       log.info("Process started | key={} | instanceId={}", processKey, instance.getId());
       return instance.getId();
   }
 
   // Complete user task
   public void completeTask(String taskId, Map<String, Object> variables) {
       taskService.complete(taskId, variables);
   }
 
   // Query active tasks for user
   public List<TaskDTO> getMyTasks(String userId) {
       return taskService.createTaskQuery()
           .taskAssignee(userId)
           .orderByTaskCreateTime().desc()
           .list()
           .stream()
           .map(this::toDTO)
           .toList();
   }
}