Legacy Claims & Customer Support Enterprise System

com.seb4u.demo.claims

package com.seb4u.demo.claims...

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.seb4u.demo.claims</groupId>
  <artifactId>legacy-claims-customer-support-enterprise</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>Legacy Claims & Customer Support Enterprise System</name>

  <modules>
    <module>after_refactoring_modular/shared-kernel</module>
    <module>after_refactoring_modular/claim-domain</module>
    <module>after_refactoring_modular/claim-application</module>
    <module>after_refactoring_modular/claim-document</module>
    <module>after_refactoring_modular/claim-workflow</module>
    <module>after_refactoring_modular/claim-payment</module>
    <module>after_refactoring_modular/claim-audit</module>
    <module>after_refactoring_modular/claim-search</module>
    <module>after_refactoring_modular/claim-notification</module>
    <module>after_refactoring_modular/claim-infrastructure</module>
    <module>after_refactoring_modular/claim-soap-api</module>
    <module>after_refactoring_modular/claim-rest-api</module>
    <module>after_refactoring_modular/claim-batch</module>
    <module>after_refactoring_modular/claim-openapi</module>
    <module>after_refactoring_modular/migration-tests</module>
  </modules>

  <properties>
    <java.version>17</java.version>
    <maven.compiler.release>${java.version}</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
</project>

package com.seb4u.demo.claims.domain;

/**
 * Enthält reine Fachlogik für Claims.
 *
 * Verboten:
 * - javax.ejb
 * - jakarta.ejb
 * - javax.xml.ws
 * - jakarta.ws.rs
 * - java.sql
 * - JMS APIs
 * - Servlet APIs
 * - WebSphere-spezifische APIs
 *
 * Erlaubt:
 * - Fachliche Entities
 * - Value Objects
 * - Policies
 * - State Machine
 * - Domain Events
 * - Fachliche Exceptions, sofern sie keine technische Infrastruktur verstecken
 */
public final class DomainBoundary {
    private DomainBoundary() {
    }
}

package com.seb4u.demo.claims.application.port;

import com.seb4u.demo.claims.domain.model.ClaimId;
import com.seb4u.demo.claims.domain.model.DocumentId;

public interface DocumentStoragePort {
    StoredDocumentReference storeClaimDocument(ClaimId claimId, UploadedClaimDocument document);

    ClaimDocumentContent loadClaimDocument(ClaimId claimId, DocumentId documentId);

    void archiveClaimDocument(ClaimId claimId, DocumentId documentId, ArchiveReason reason);
}

package com.seb4u.demo.claims.application.port;

import com.seb4u.demo.claims.domain.model.Claim;
import com.seb4u.demo.claims.domain.model.RiskScore;

public interface FraudRiskPort {
    RiskScore evaluateFraudRisk(Claim claim);
}

package com.seb4u.demo.claims.application.port;

import com.seb4u.demo.claims.domain.model.Claim;
import com.seb4u.demo.claims.domain.model.CoverageDecision;

public interface CoveragePort {
    CoverageDecision calculateCoverage(Claim claim);
}

package com.seb4u.demo.claims.application.port;

import com.seb4u.demo.claims.domain.model.ClaimId;
import com.seb4u.demo.claims.domain.model.Money;

public interface PaymentReleasePort {
    PaymentPreparationResult preparePayment(ClaimId claimId, Money amount);

    PaymentReleaseResult releasePreparedPayment(ClaimId claimId, PaymentReference reference);
}

package com.seb4u.demo.claims.application.port;

import com.seb4u.demo.claims.domain.model.ClaimId;
import com.seb4u.demo.claims.domain.model.AuditEvent;

public interface AuditLogPort {
    void append(AuditEvent event);

    ClaimAuditTrail loadTrail(ClaimId claimId);
}

package com.seb4u.demo.claims.application.usecase;

import com.seb4u.demo.claims.application.port.AuditLogPort;
import com.seb4u.demo.claims.application.port.CoveragePort;
import com.seb4u.demo.claims.application.port.DocumentVerificationPort;
import com.seb4u.demo.claims.application.port.FraudRiskPort;
import com.seb4u.demo.claims.application.port.PaymentReleasePort;
import com.seb4u.demo.claims.domain.model.Claim;
import com.seb4u.demo.claims.domain.model.ClaimDecisionResult;
import com.seb4u.demo.claims.workflow.ClaimWorkflowOrchestrator;

public class ProcessClaimDecisionHandler {

    private final ClaimRepository claimRepository;
    private final CoveragePort coveragePort;
    private final FraudRiskPort fraudRiskPort;
    private final DocumentVerificationPort documentVerificationPort;
    private final PaymentReleasePort paymentReleasePort;
    private final AuditLogPort auditLogPort;
    private final ClaimWorkflowOrchestrator workflowOrchestrator;

    public ProcessClaimDecisionHandler(
            ClaimRepository claimRepository,
            CoveragePort coveragePort,
            FraudRiskPort fraudRiskPort,
            DocumentVerificationPort documentVerificationPort,
            PaymentReleasePort paymentReleasePort,
            AuditLogPort auditLogPort,
            ClaimWorkflowOrchestrator workflowOrchestrator
    ) {
        this.claimRepository = claimRepository;
        this.coveragePort = coveragePort;
        this.fraudRiskPort = fraudRiskPort;
        this.documentVerificationPort = documentVerificationPort;
        this.paymentReleasePort = paymentReleasePort;
        this.auditLogPort = auditLogPort;
        this.workflowOrchestrator = workflowOrchestrator;
    }

    public ClaimDecisionResult handle(ProcessClaimDecisionCommand command) {
        Claim claim = claimRepository.loadForDecision(command.claimId());

        return workflowOrchestrator.processDecision(
                claim,
                command,
                coveragePort,
                fraudRiskPort,
                documentVerificationPort,
                paymentReleasePort,
                auditLogPort
        );
    }
}

processClaimDecision(...)

<application xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                                 http://xmlns.jcp.org/xml/ns/javaee/application_7.xsd"
             version="7">
    <display-name>Legacy Claims Customer Support EAR</display-name>

    <module>
        <ejb>legacy-claims-core-ejb.jar</ejb>
    </module>

    <module>
        <web>
            <web-uri>legacy-claims-partner-portal.war</web-uri>
            <context-root>/partner-claims</context-root>
        </web>
    </module>

    <module>
        <web>
            <web-uri>legacy-internal-claims-backoffice.war</web-uri>
            <context-root>/claims-backoffice</context-root>
        </web>
    </module>

    <module>
        <ejb>legacy-sla-escalation-scheduler.jar</ejb>
    </module>

    <library-directory>lib</library-directory>
</application>

<application-bnd
    xmlns="http://websphere.ibm.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://websphere.ibm.com/xml/ns/javaee
                        http://websphere.ibm.com/xml/ns/javaee/ibm-application-bnd_1_0.xsd"
    version="1.0">

    <security-role name="CLAIMS_AGENT">
        <group name="cn=claims-agents,ou=groups,dc=seb4u,dc=demo" />
    </security-role>

    <security-role name="CLAIMS_MANAGER">
        <group name="cn=claims-managers,ou=groups,dc=seb4u,dc=demo" />
    </security-role>

    <security-role name="PARTNER_USER">
        <group name="cn=partner-users,ou=groups,dc=seb4u,dc=demo" />
    </security-role>

    <security-role name="AUDITOR">
        <group name="cn=claims-auditors,ou=groups,dc=seb4u,dc=demo" />
    </security-role>
</application-bnd>

<ejb-jar xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/ejb-jar_3_2.xsd"
         version="3.2">

    <enterprise-beans>
        <session>
            <ejb-name>LegacyClaimFacadeBean</ejb-name>
            <ejb-class>com.seb4u.demo.claims.legacy.ejb.LegacyClaimFacadeBean</ejb-class>
            <session-type>Stateless</session-type>
            <transaction-type>Container</transaction-type>
        </session>
    </enterprise-beans>

    <assembly-descriptor>
        <method-permission>
            <role-name>CLAIMS_AGENT</role-name>
            <role-name>CLAIMS_MANAGER</role-name>
            <method>
                <ejb-name>LegacyClaimFacadeBean</ejb-name>
                <method-name>*</method-name>
            </method>
        </method-permission>

        <container-transaction>
            <method>
                <ejb-name>LegacyClaimFacadeBean</ejb-name>
                <method-name>processClaimDecision</method-name>
            </method>
            <trans-attribute>Required</trans-attribute>
        </container-transaction>
    </assembly-descriptor>
</ejb-jar>

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
                                 http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
             version="2.1">

    <persistence-unit name="claimsLegacyPU" transaction-type="JTA">
        <jta-data-source>jdbc/ClaimsOracleDS</jta-data-source>
        <class>com.seb4u.demo.claims.legacy.entity.LegacyClaimEntity</class>
        <class>com.seb4u.demo.claims.legacy.entity.LegacyClaimDocumentEntity</class>
        <class>com.seb4u.demo.claims.legacy.entity.LegacyClaimAuditEntity</class>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect" />
            <property name="hibernate.show_sql" value="false" />
            <property name="hibernate.format_sql" value="false" />
        </properties>
    </persistence-unit>
</persistence>

CREATE OR REPLACE PROCEDURE SP_PROCESS_CLAIM_DECISION (
    p_claim_id            IN NUMBER,
    p_decision_code       IN VARCHAR2,
    p_actor_user          IN VARCHAR2,
    p_reason              IN VARCHAR2,
    p_new_status          OUT VARCHAR2,
    p_audit_id            OUT NUMBER
) AS
BEGIN
    UPDATE CLAIM
       SET STATUS = CASE
            WHEN p_decision_code = 'APPROVE' THEN 'APPROVED'
            WHEN p_decision_code = 'REJECT' THEN 'REJECTED'
            WHEN p_decision_code = 'ESCALATE' THEN 'ESCALATED'
            ELSE STATUS
       END,
       LAST_UPDATED_AT = SYSTIMESTAMP,
       LAST_UPDATED_BY = p_actor_user
     WHERE CLAIM_ID = p_claim_id;

    INSERT INTO CLAIM_AUDIT (
        AUDIT_ID,
        CLAIM_ID,
        ACTION_CODE,
        ACTOR_USER,
        DESCRIPTION,
        CREATED_AT
    ) VALUES (
        CLAIM_AUDIT_SEQ.NEXTVAL,
        p_claim_id,
        p_decision_code,
        p_actor_user,
        p_reason,
        SYSTIMESTAMP
    ) RETURNING AUDIT_ID INTO p_audit_id;

    SELECT STATUS INTO p_new_status
      FROM CLAIM
     WHERE CLAIM_ID = p_claim_id;
END;
/

CREATE OR REPLACE PROCEDURE SP_REFRESH_CLAIM_REPORTING AS
BEGIN
    DELETE FROM CLAIM_REPORTING_SNAPSHOT;

    INSERT INTO CLAIM_REPORTING_SNAPSHOT (
        CLAIM_ID,
        CUSTOMER_ID,
        STATUS,
        PARTNER_ID,
        CLAIM_AMOUNT,
        RISK_SCORE,
        SLA_BREACHED,
        LAST_ACTION,
        SNAPSHOT_CREATED_AT
    )
    SELECT c.CLAIM_ID,
           c.CUSTOMER_ID,
           c.STATUS,
           c.PARTNER_ID,
           c.CLAIM_AMOUNT,
           c.RISK_SCORE,
           CASE WHEN e.ESCALATION_ID IS NOT NULL THEN 'Y' ELSE 'N' END,
           a.ACTION_CODE,
           SYSTIMESTAMP
      FROM CLAIM c
      LEFT JOIN CLAIM_ESCALATION e ON e.CLAIM_ID = c.CLAIM_ID
      LEFT JOIN CLAIM_AUDIT a ON a.CLAIM_ID = c.CLAIM_ID
     WHERE c.CREATED_AT > SYSTIMESTAMP - 365;
END;
/

package com.seb4u.demo.claims.legacy.soap;

import javax.ejb.EJB;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import com.seb4u.demo.claims.legacy.ejb.LegacyClaimFacadeBean;

@WebService(
    serviceName = "LegacyClaimService",
    portName = "LegacyClaimServicePort",
    targetNamespace = "http://legacy.claims.demo.seb4u.com"
)
public class LegacyClaimSoapEndpoint {

    @EJB
    private LegacyClaimFacadeBean claimFacade;

    @WebMethod(operationName = "createClaim")
    public LegacyCreateClaimResponse createClaim(@WebParam(name = "request") LegacyCreateClaimRequest request) {
        return claimFacade.createClaimFromSoap(request);
    }

    @WebMethod(operationName = "getClaimStatus")
    public LegacyClaimStatusResponse getClaimStatus(@WebParam(name = "request") LegacyClaimStatusRequest request) {
        return claimFacade.getClaimStatus(request);
    }

    @WebMethod(operationName = "submitClaimDocument")
    public LegacySubmitDocumentResponse submitClaimDocument(@WebParam(name = "request") LegacySubmitDocumentRequest request) {
        return claimFacade.submitClaimDocument(request);
    }

    @WebMethod(operationName = "processClaimDecision")
    public LegacyClaimDecisionResponse processClaimDecision(@WebParam(name = "request") LegacyClaimDecisionRequest request) {
        return claimFacade.processClaimDecision(request);
    }

    @WebMethod(operationName = "approveClaimPayment")
    public LegacyPaymentResponse approveClaimPayment(@WebParam(name = "request") LegacyPaymentRequest request) {
        return claimFacade.approveClaimPayment(request);
    }

    @WebMethod(operationName = "rejectClaim")
    public LegacyRejectClaimResponse rejectClaim(@WebParam(name = "request") LegacyRejectClaimRequest request) {
        return claimFacade.rejectClaim(request);
    }

    @WebMethod(operationName = "escalateClaim")
    public LegacyEscalationResponse escalateClaim(@WebParam(name = "request") LegacyEscalationRequest request) {
        return claimFacade.escalateClaim(request);
    }

    @WebMethod(operationName = "getClaimAuditTrail")
    public LegacyAuditTrailResponse getClaimAuditTrail(@WebParam(name = "request") LegacyAuditTrailRequest request) {
        return claimFacade.getClaimAuditTrail(request);
    }

    @WebMethod(operationName = "searchClaims")
    public LegacySearchClaimsResponse searchClaims(@WebParam(name = "request") LegacySearchClaimsRequest request) {
        return claimFacade.searchClaims(request);
    }

    @WebMethod(operationName = "getCustomerClaimHistory")
    public LegacyCustomerHistoryResponse getCustomerClaimHistory(@WebParam(name = "request") LegacyCustomerHistoryRequest request) {
        return claimFacade.getCustomerClaimHistory(request);
    }

    @WebMethod(operationName = "verifyClaimDocument")
    public LegacyVerifyDocumentResponse verifyClaimDocument(@WebParam(name = "request") LegacyVerifyDocumentRequest request) {
        return claimFacade.verifyClaimDocument(request);
    }

    @WebMethod(operationName = "calculateClaimCoverage")
    public LegacyCoverageResponse calculateClaimCoverage(@WebParam(name = "request") LegacyCoverageRequest request) {
        return claimFacade.calculateClaimCoverage(request);
    }
}

package com.seb4u.demo.claims.legacy.jms;

import javax.annotation.Resource;
import javax.ejb.Stateless;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

@Stateless
public class LegacyClaimEventPublisher {

    @Resource(lookup = "jms/ClaimsConnectionFactory")
    private ConnectionFactory connectionFactory;

    @Resource(lookup = "jms/ClaimsEventsQueue")
    private Queue claimsEventsQueue;

    public void publishDecisionChanged(Long claimId, String oldStatus, String newStatus, String actor, String correlationId) {
        Connection connection = null;
        Session session = null;
        try {
            connection = connectionFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageProducer producer = session.createProducer(claimsEventsQueue);

            String payload = "{" +
                "\"eventType\":\"CLAIM_DECISION_CHANGED\"," +
                "\"claimId\":" + claimId + "," +
                "\"oldStatus\":\"" + oldStatus + "\"," +
                "\"newStatus\":\"" + newStatus + "\"," +
                "\"actor\":\"" + actor + "\"," +
                "\"correlationId\":\"" + correlationId + "\"" +
                "}";

            TextMessage message = session.createTextMessage(payload);
            message.setStringProperty("eventType", "CLAIM_DECISION_CHANGED");
            message.setStringProperty("correlationId", correlationId);
            producer.send(message);
        } catch (JMSException e) {
            throw new IllegalStateException("Could not publish claim event", e);
        } finally {
            try {
                if (session != null) session.close();
                if (connection != null) connection.close();
            } catch (JMSException ignored) {
                // ignored in legacy system
            }
        }
    }
}

<ejb-jar-bnd xmlns="http://websphere.ibm.com/xml/ns/javaee"
             version="1.0">
    <message-destination-ref name="jms/ClaimsEventsQueue"
        binding-name="jms/ClaimsEventsQueue" />
    <resource-ref name="jms/ClaimsConnectionFactory"
        binding-name="jms/ClaimsConnectionFactory" />
</ejb-jar-bnd>

package com.seb4u.demo.claims.legacy.security;

import javax.annotation.Resource;
import javax.ejb.SessionContext;
import javax.ejb.Stateless;
import java.util.HashSet;
import java.util.Set;

@Stateless
public class JaasRoleChecker {

    @Resource
    private SessionContext sessionContext;

    public boolean canProcessDecision(String claimStatus, String decisionCode, String amountCategory) {
        if (sessionContext.isCallerInRole("CLAIMS_MANAGER")) {
            return true;
        }

        if (sessionContext.isCallerInRole("CLAIMS_AGENT")) {
            if ("LOW".equals(amountCategory) && "APPROVE".equals(decisionCode)) {
                return true;
            }
            if ("REJECT".equals(decisionCode) && ("NEW".equals(claimStatus) || "IN_REVIEW".equals(claimStatus))) {
                return true;
            }
        }

        if (sessionContext.isCallerInRole("PARTNER_USER")) {
            return false;
        }

        return false;
    }

    public Set<String> currentRoles() {
        Set<String> roles = new HashSet<>();
        if (sessionContext.isCallerInRole("CLAIMS_AGENT")) roles.add("CLAIMS_AGENT");
        if (sessionContext.isCallerInRole("CLAIMS_MANAGER")) roles.add("CLAIMS_MANAGER");
        if (sessionContext.isCallerInRole("PARTNER_USER")) roles.add("PARTNER_USER");
        if (sessionContext.isCallerInRole("AUDITOR")) roles.add("AUDITOR");
        return roles;
    }
}

package com.seb4u.demo.claims.legacy.document;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class LegacyDocumentShareClient {

    private static final String ROOT = "//legacy-fileserver01/claims-documents";

    public String storeDocument(Long claimId, String documentType, String fileName, File uploadedFile) {
        String folder = ROOT + "/" + claimId + "/" + documentType;
        File directory = new File(folder);
        if (!directory.exists() && !directory.mkdirs()) {
            throw new IllegalStateException("Could not create document folder " + folder);
        }

        String targetPath = folder + "/" + System.currentTimeMillis() + "_" + fileName;
        try {
            Files.copy(uploadedFile.toPath(), Path.of(targetPath), StandardCopyOption.REPLACE_EXISTING);
            return targetPath;
        } catch (IOException e) {
            throw new IllegalStateException("Could not store document " + fileName, e);
        }
    }

    public byte[] readDocument(String absolutePath) {
        try (FileInputStream in = new FileInputStream(absolutePath)) {
            return in.readAllBytes();
        } catch (IOException e) {
            throw new IllegalStateException("Could not read document " + absolutePath, e);
        }
    }

    public boolean exists(String absolutePath) {
        return new File(absolutePath).exists();
    }
}

package com.seb4u.demo.claims.legacy.dao;

import javax.annotation.Resource;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.sql.DataSource;
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

@Stateless
public class LegacyClaimDao {

    @PersistenceContext(unitName = "claimsLegacyPU")
    private EntityManager entityManager;

    @Resource(lookup = "jdbc/ClaimsOracleDS")
    private DataSource dataSource;

    public LegacyClaimRecord findByIdForUpdate(Long claimId) {
        try (Connection connection = dataSource.getConnection();
             CallableStatement statement = connection.prepareCall(
                 "select CLAIM_ID, STATUS, CUSTOMER_ID, POLICY_NO, CLAIM_AMOUNT, RISK_SCORE, " +
                 "       PARTNER_ID, DOCUMENT_STATUS, PAYMENT_STATUS, SLA_DUE_AT " +
                 "  from CLAIM where CLAIM_ID = ? for update")) {

            statement.setLong(1, claimId);
            try (ResultSet rs = statement.executeQuery()) {
                if (!rs.next()) {
                    return null;
                }
                return new LegacyClaimRecord(
                    rs.getLong("CLAIM_ID"),
                    rs.getString("STATUS"),
                    rs.getString("CUSTOMER_ID"),
                    rs.getString("POLICY_NO"),
                    rs.getBigDecimal("CLAIM_AMOUNT"),
                    rs.getBigDecimal("RISK_SCORE"),
                    rs.getString("PARTNER_ID"),
                    rs.getString("DOCUMENT_STATUS"),
                    rs.getString("PAYMENT_STATUS"),
                    rs.getTimestamp("SLA_DUE_AT")
                );
            }
        } catch (SQLException e) {
            throw new IllegalStateException("Could not load claim " + claimId, e);
        }
    }

    public StoredProcedureDecisionResult callProcessClaimDecision(Long claimId, String decisionCode, String actor, String reason) {
        try (Connection connection = dataSource.getConnection();
             CallableStatement statement = connection.prepareCall("{call SP_PROCESS_CLAIM_DECISION(?,?,?,?,?,?)}")) {
            statement.setLong(1, claimId);
            statement.setString(2, decisionCode);
            statement.setString(3, actor);
            statement.setString(4, reason);
            statement.registerOutParameter(5, Types.VARCHAR);
            statement.registerOutParameter(6, Types.NUMERIC);
            statement.execute();
            return new StoredProcedureDecisionResult(
                statement.getString(5),
                statement.getLong(6)
            );
        } catch (SQLException e) {
            throw new IllegalStateException("Could not call SP_PROCESS_CLAIM_DECISION", e);
        }
    }

    public void updateRiskScore(Long claimId, BigDecimal riskScore) {
        entityManager.createNativeQuery(
            "update CLAIM set RISK_SCORE = :riskScore, LAST_UPDATED_AT = SYSTIMESTAMP where CLAIM_ID = :claimId")
            .setParameter("riskScore", riskScore)
            .setParameter("claimId", claimId)
            .executeUpdate();
    }

    public void markDocumentStatus(Long claimId, String documentStatus) {
        entityManager.createNativeQuery(
            "update CLAIM set DOCUMENT_STATUS = :status where CLAIM_ID = :claimId")
            .setParameter("status", documentStatus)
            .setParameter("claimId", claimId)
            .executeUpdate();
    }
}

package com.seb4u.demo.claims.legacy.portal;

import com.seb4u.demo.claims.legacy.ejb.LegacyClaimFacadeBean;
import com.seb4u.demo.claims.legacy.soap.LegacyCreateClaimRequest;
import com.seb4u.demo.claims.legacy.soap.LegacyCreateClaimResponse;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@MultipartConfig
public class LegacyPartnerPortalServlet extends HttpServlet {

    @EJB
    private LegacyClaimFacadeBean claimFacade;

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String partnerId = (String) request.getSession().getAttribute("partnerId");
        String customerId = request.getParameter("customerId");
        String policyNo = request.getParameter("policyNo");
        String incidentText = request.getParameter("incidentText");
        String amount = request.getParameter("claimAmount");

        LegacyCreateClaimRequest legacyRequest = new LegacyCreateClaimRequest();
        legacyRequest.setPartnerId(partnerId);
        legacyRequest.setCustomerId(customerId);
        legacyRequest.setPolicyNo(policyNo);
        legacyRequest.setIncidentDescription(incidentText);
        legacyRequest.setClaimAmount(amount);
        legacyRequest.setSourceSystem("PARTNER_PORTAL_JSP");

        try {
            LegacyCreateClaimResponse legacyResponse = claimFacade.createClaimFromSoap(legacyRequest);
            request.setAttribute("claimId", legacyResponse.getClaimId());
            request.setAttribute("message", "Schaden wurde erfasst");
            request.getRequestDispatcher("/WEB-INF/jsp/claimStatus.jsp").forward(request, response);
        } catch (Exception ex) {
            request.setAttribute("error", ex.getMessage());
            request.getRequestDispatcher("/WEB-INF/jsp/createClaim.jsp").forward(request, response);
        }
    }
}

package com.seb4u.demo.claims.legacy.backoffice;

import com.seb4u.demo.claims.legacy.ejb.LegacyClaimFacadeBean;
import com.seb4u.demo.claims.legacy.soap.LegacyClaimDecisionRequest;
import com.seb4u.demo.claims.legacy.soap.LegacyClaimDecisionResponse;

import javax.ejb.EJB;
import javax.ejb.Stateless;
import java.util.Map;

@Stateless
public class InternalClaimsBackofficeBean {

    @EJB
    private LegacyClaimFacadeBean claimFacade;

    public LegacyClaimDecisionResponse submitDecisionForm(Map<String, String> form, String currentUser) {
        LegacyClaimDecisionRequest request = new LegacyClaimDecisionRequest();
        request.setClaimId(Long.valueOf(form.get("claimId")));
        request.setDecisionCode(form.get("decisionCode"));
        request.setReason(form.get("reason"));
        request.setActorUser(currentUser);
        request.setForcePayment("on".equals(form.get("forcePayment")));
        request.setManualOverride("on".equals(form.get("manualOverride")));
        request.setBackofficeComment(form.get("comment"));
        request.setCorrelationId(form.get("correlationId"));
        return claimFacade.processClaimDecision(request);
    }
}

package com.seb4u.demo.claims.legacy.soap;

import javax.xml.ws.WebServiceRef;
import java.math.BigDecimal;

public class FraudRiskSoapClient {

    @WebServiceRef(wsdlLocation = "META-INF/wsdl/FraudRiskService.wsdl")
    private FraudRiskService fraudRiskService;

    public FraudRiskLegacyResponse checkRisk(Long claimId, String customerId, String policyNo, BigDecimal amount) {
        FraudRiskLegacyRequest request = new FraudRiskLegacyRequest();
        request.setClaimId(String.valueOf(claimId));
        request.setCustomerId(customerId);
        request.setPolicyNumber(policyNo);
        request.setClaimAmount(amount.toPlainString());
        request.setRequestMode("FULL_SYNC_CHECK");
        request.setCaller("LEGACY_CLAIMS_EJB");

        try {
            return fraudRiskService.getFraudRiskServicePort().checkRisk(request);
        } catch (Exception e) {
            FraudRiskLegacyResponse fallback = new FraudRiskLegacyResponse();
            fallback.setScore("999");
            fallback.setRiskCategory("TECHNICAL_ERROR_TREATED_AS_HIGH_RISK");
            fallback.setManualReviewRequired(true);
            fallback.setMessage(e.getMessage());
            return fallback;
        }
    }
}

package com.seb4u.demo.claims.legacy.soap;

import javax.xml.ws.WebServiceRef;
import java.math.BigDecimal;

public class PolicyCoverageSoapClient {

    @WebServiceRef(wsdlLocation = "META-INF/wsdl/PolicyCoverageService.wsdl")
    private PolicyCoverageService policyCoverageService;

    public LegacyCoverageResult calculateCoverage(String policyNo, String claimType, BigDecimal amount) {
        LegacyCoverageRequest request = new LegacyCoverageRequest();
        request.setPolicyNumber(policyNo);
        request.setClaimType(claimType);
        request.setRequestedAmount(amount.toPlainString());
        request.setLegacyTariffMode("Y");

        return policyCoverageService.getPolicyCoverageServicePort().calculateClaimCoverage(request);
    }
}

package com.seb4u.demo.claims.legacy.soap;

import javax.xml.ws.WebServiceRef;
import java.math.BigDecimal;

public class PaymentReleaseSoapClient {

    @WebServiceRef(wsdlLocation = "META-INF/wsdl/PaymentReleaseService.wsdl")
    private PaymentReleaseService paymentReleaseService;

    public LegacyPaymentReleaseResponse releasePayment(Long claimId, String customerId, BigDecimal amount, String actor) {
        LegacyPaymentReleaseRequest request = new LegacyPaymentReleaseRequest();
        request.setClaimReference("CLAIM-" + claimId);
        request.setCustomerNumber(customerId);
        request.setAmount(amount.toPlainString());
        request.setCurrency("EUR");
        request.setReleasedBy(actor);
        request.setReason("CLAIM_APPROVED");
        return paymentReleaseService.getPaymentReleaseServicePort().releasePayment(request);
    }
}

package com.seb4u.demo.claims.legacy.ejb;

import com.seb4u.demo.claims.legacy.dao.LegacyClaimDao;
import com.seb4u.demo.claims.legacy.dao.LegacyClaimRecord;
import com.seb4u.demo.claims.legacy.dao.StoredProcedureDecisionResult;
import com.seb4u.demo.claims.legacy.document.LegacyDocumentShareClient;
import com.seb4u.demo.claims.legacy.jms.LegacyClaimEventPublisher;
import com.seb4u.demo.claims.legacy.security.JaasRoleChecker;
import com.seb4u.demo.claims.legacy.soap.*;

import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.ejb.SessionContext;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;

@Stateless
public class LegacyClaimFacadeBean {

    @EJB
    private LegacyClaimDao claimDao;

    @EJB
    private LegacyClaimAuditBean auditBean;

    @EJB
    private LegacyClaimDocumentBean documentBean;

    @EJB
    private LegacyClaimPaymentBean paymentBean;

    @EJB
    private JaasRoleChecker roleChecker;

    @EJB
    private LegacyClaimEventPublisher eventPublisher;

    @EJB
    private LegacyClaimSearchBean searchBean;

    @EJB
    private LegacyNotificationSenderBean notificationSender;

    @Resource
    private SessionContext sessionContext;

    private FraudRiskSoapClient fraudRiskSoapClient = new FraudRiskSoapClient();
    private PolicyCoverageSoapClient policyCoverageSoapClient = new PolicyCoverageSoapClient();
    private CustomerMasterDataSoapClient customerMasterDataSoapClient = new CustomerMasterDataSoapClient();
    private DocumentVerificationSoapClient documentVerificationSoapClient = new DocumentVerificationSoapClient();
    private PaymentReleaseSoapClient paymentReleaseSoapClient = new PaymentReleaseSoapClient();
    private LegacyDocumentShareClient documentShareClient = new LegacyDocumentShareClient();

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public LegacyClaimDecisionResponse processClaimDecision(LegacyClaimDecisionRequest request) {
        long started = System.currentTimeMillis();
        List<String> technicalWarnings = new ArrayList<>();
        List<String> businessWarnings = new ArrayList<>();

        if (request == null) {
            throw new IllegalArgumentException("request must not be null");
        }
        if (request.getClaimId() == null) {
            throw new IllegalArgumentException("claimId must not be null");
        }
        if (request.getDecisionCode() == null || request.getDecisionCode().trim().isEmpty()) {
            throw new IllegalArgumentException("decisionCode must not be empty");
        }
        if (request.getActorUser() == null || request.getActorUser().trim().isEmpty()) {
            request.setActorUser(sessionContext.getCallerPrincipal().getName());
        }
        if (request.getCorrelationId() == null || request.getCorrelationId().trim().isEmpty()) {
            request.setCorrelationId("LEGACY-" + System.currentTimeMillis() + "-" + request.getClaimId());
        }

        auditBean.writeTechnicalAudit(
            request.getClaimId(),
            "PROCESS_DECISION_STARTED",
            request.getActorUser(),
            "Started decision " + request.getDecisionCode() + " with correlation " + request.getCorrelationId()
        );

        LegacyClaimRecord claim = claimDao.findByIdForUpdate(request.getClaimId());
        if (claim == null) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "PROCESS_DECISION_FAILED",
                request.getActorUser(),
                "Claim not found"
            );
            throw new IllegalStateException("Claim not found: " + request.getClaimId());
        }

        String oldStatus = claim.getStatus();
        String amountCategory;
        if (claim.getClaimAmount() == null) {
            amountCategory = "UNKNOWN";
        } else if (claim.getClaimAmount().compareTo(new BigDecimal("500")) <= 0) {
            amountCategory = "LOW";
        } else if (claim.getClaimAmount().compareTo(new BigDecimal("5000")) <= 0) {
            amountCategory = "MEDIUM";
        } else {
            amountCategory = "HIGH";
        }

        if (!roleChecker.canProcessDecision(oldStatus, request.getDecisionCode(), amountCategory)) {
            auditBean.writeSecurityAudit(
                request.getClaimId(),
                "DECISION_FORBIDDEN",
                request.getActorUser(),
                "roles=" + roleChecker.currentRoles() + ", status=" + oldStatus + ", decision=" + request.getDecisionCode()
            );
            throw new SecurityException("User is not allowed to process decision");
        }

        if ("CLOSED".equals(oldStatus) || "ARCHIVED".equals(oldStatus)) {
            auditBean.writeBusinessAudit(
                request.getClaimId(),
                "DECISION_REJECTED_INVALID_STATUS",
                request.getActorUser(),
                "Cannot process decision for status " + oldStatus
            );
            throw new IllegalStateException("Cannot process already closed or archived claim");
        }

        if ("APPROVE".equals(request.getDecisionCode()) && "NEW".equals(oldStatus)) {
            businessWarnings.add("Approving a NEW claim is unusual and may require manual review");
            if (!request.isManualOverride()) {
                throw new IllegalStateException("NEW claim cannot be approved without manual override");
            }
        }

        LegacyCustomerResponse customerResponse;
        try {
            customerResponse = customerMasterDataSoapClient.getCustomer(claim.getCustomerId());
            if (customerResponse == null || customerResponse.getCustomerId() == null) {
                auditBean.writeBusinessAudit(request.getClaimId(), "CUSTOMER_NOT_FOUND", request.getActorUser(), claim.getCustomerId());
                throw new IllegalStateException("Customer not found in master data");
            }
            if ("DECEASED".equals(customerResponse.getCustomerStatus())) {
                businessWarnings.add("Customer is marked as deceased in master data");
            }
            if (customerResponse.getAddressQuality() != null && customerResponse.getAddressQuality().compareTo(new BigDecimal("0.5")) < 0) {
                businessWarnings.add("Customer address quality is low");
            }
        } catch (Exception ex) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "CUSTOMER_SERVICE_ERROR",
                request.getActorUser(),
                ex.getClass().getName() + ": " + ex.getMessage()
            );
            throw new IllegalStateException("Customer master data service failed", ex);
        }

        LegacyCoverageResult coverageResult;
        try {
            coverageResult = policyCoverageSoapClient.calculateCoverage(
                claim.getPolicyNo(),
                request.getClaimType() == null ? "UNKNOWN" : request.getClaimType(),
                claim.getClaimAmount()
            );
            if (coverageResult == null) {
                throw new IllegalStateException("Coverage service returned null");
            }
            if (!coverageResult.isCovered()) {
                if ("APPROVE".equals(request.getDecisionCode())) {
                    auditBean.writeBusinessAudit(
                        request.getClaimId(),
                        "APPROVAL_BLOCKED_NO_COVERAGE",
                        request.getActorUser(),
                        "policyNo=" + claim.getPolicyNo()
                    );
                    throw new IllegalStateException("Cannot approve claim without policy coverage");
                }
                businessWarnings.add("Claim is not covered by policy");
            }
            if (coverageResult.getDeductibleAmount() != null && coverageResult.getDeductibleAmount().compareTo(BigDecimal.ZERO) > 0) {
                businessWarnings.add("Deductible amount applies: " + coverageResult.getDeductibleAmount());
            }
        } catch (RuntimeException ex) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "COVERAGE_SERVICE_ERROR",
                request.getActorUser(),
                ex.getMessage()
            );
            throw ex;
        } catch (Exception ex) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "COVERAGE_SERVICE_ERROR",
                request.getActorUser(),
                ex.getMessage()
            );
            throw new IllegalStateException("Coverage service failed", ex);
        }

        FraudRiskLegacyResponse fraudResponse;
        try {
            fraudResponse = fraudRiskSoapClient.checkRisk(
                claim.getClaimId(),
                claim.getCustomerId(),
                claim.getPolicyNo(),
                claim.getClaimAmount()
            );
            BigDecimal riskScore = new BigDecimal(fraudResponse.getScore());
            claimDao.updateRiskScore(claim.getClaimId(), riskScore);
            if (riskScore.compareTo(new BigDecimal("800")) >= 0) {
                if ("APPROVE".equals(request.getDecisionCode()) && !request.isManualOverride()) {
                    auditBean.writeBusinessAudit(
                        request.getClaimId(),
                        "APPROVAL_BLOCKED_HIGH_RISK",
                        request.getActorUser(),
                        "riskScore=" + riskScore
                    );
                    throw new IllegalStateException("High fraud risk requires manual override");
                }
                businessWarnings.add("High fraud risk score: " + riskScore);
            }
            if (fraudResponse.isManualReviewRequired() && !request.isManualOverride()) {
                auditBean.writeBusinessAudit(
                    request.getClaimId(),
                    "MANUAL_REVIEW_REQUIRED",
                    request.getActorUser(),
                    fraudResponse.getRiskCategory()
                );
                if ("APPROVE".equals(request.getDecisionCode())) {
                    throw new IllegalStateException("Manual fraud review required before approval");
                }
            }
        } catch (Exception ex) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "FRAUD_SERVICE_ERROR",
                request.getActorUser(),
                ex.getClass().getName() + ": " + ex.getMessage()
            );
            if ("APPROVE".equals(request.getDecisionCode())) {
                throw new IllegalStateException("Cannot approve because fraud service failed", ex);
            }
            technicalWarnings.add("Fraud service failed: " + ex.getMessage());
            fraudResponse = new FraudRiskLegacyResponse();
            fraudResponse.setScore("999");
            fraudResponse.setRiskCategory("UNKNOWN_TECHNICAL_ERROR");
            fraudResponse.setManualReviewRequired(true);
        }

        if ("APPROVE".equals(request.getDecisionCode()) || "REJECT".equals(request.getDecisionCode())) {
            List<LegacyDocumentMetadata> documents = documentBean.findDocumentsForClaim(request.getClaimId());
            if (documents == null || documents.isEmpty()) {
                if ("APPROVE".equals(request.getDecisionCode())) {
                    auditBean.writeBusinessAudit(
                        request.getClaimId(),
                        "APPROVAL_BLOCKED_NO_DOCUMENTS",
                        request.getActorUser(),
                        "No documents found"
                    );
                    throw new IllegalStateException("Cannot approve without documents");
                }
                businessWarnings.add("No documents found");
            } else {
                boolean allDocumentsReadable = true;
                boolean allDocumentsVerified = true;
                for (LegacyDocumentMetadata doc : documents) {
                    if (doc.getAbsolutePath() == null || !documentShareClient.exists(doc.getAbsolutePath())) {
                        allDocumentsReadable = false;
                        auditBean.writeTechnicalAudit(
                            request.getClaimId(),
                            "DOCUMENT_FILE_MISSING",
                            request.getActorUser(),
                            "documentId=" + doc.getDocumentId() + ", path=" + doc.getAbsolutePath()
                        );
                    } else {
                        try {
                            LegacyDocumentVerificationResult result = documentVerificationSoapClient.verify(
                                doc.getDocumentId(),
                                doc.getAbsolutePath(),
                                doc.getDocumentType()
                            );
                            if (result == null || !result.isVerified()) {
                                allDocumentsVerified = false;
                                auditBean.writeBusinessAudit(
                                    request.getClaimId(),
                                    "DOCUMENT_NOT_VERIFIED",
                                    request.getActorUser(),
                                    "documentId=" + doc.getDocumentId()
                                );
                            }
                        } catch (Exception ex) {
                            technicalWarnings.add("Document verification failed for " + doc.getDocumentId());
                            allDocumentsVerified = false;
                            auditBean.writeTechnicalAudit(
                                request.getClaimId(),
                                "DOCUMENT_VERIFICATION_ERROR",
                                request.getActorUser(),
                                ex.getMessage()
                            );
                        }
                    }
                }

                if (!allDocumentsReadable && "APPROVE".equals(request.getDecisionCode())) {
                    throw new IllegalStateException("Cannot approve because some document files are missing");
                }
                if (!allDocumentsVerified && "APPROVE".equals(request.getDecisionCode()) && !request.isManualOverride()) {
                    throw new IllegalStateException("Cannot approve because some documents are not verified");
                }
                claimDao.markDocumentStatus(request.getClaimId(), allDocumentsVerified ? "VERIFIED" : "MANUAL_REVIEW");
            }
        }

        String effectiveDecision = request.getDecisionCode();
        if ("APPROVE".equals(effectiveDecision)) {
            if (coverageResult.getApprovedAmount() != null && coverageResult.getApprovedAmount().compareTo(BigDecimal.ZERO) <= 0) {
                auditBean.writeBusinessAudit(
                    request.getClaimId(),
                    "APPROVAL_BLOCKED_ZERO_AMOUNT",
                    request.getActorUser(),
                    "approvedAmount=" + coverageResult.getApprovedAmount()
                );
                throw new IllegalStateException("Approved amount must be positive");
            }
            if ("HIGH".equals(amountCategory) && !roleChecker.currentRoles().contains("CLAIMS_MANAGER")) {
                throw new SecurityException("High amount approval requires CLAIMS_MANAGER");
            }
        } else if ("REJECT".equals(effectiveDecision)) {
            if (request.getReason() == null || request.getReason().length() < 20) {
                throw new IllegalArgumentException("Reject reason must contain at least 20 characters");
            }
        } else if ("ESCALATE".equals(effectiveDecision)) {
            if (request.getReason() == null || request.getReason().trim().isEmpty()) {
                request.setReason("Escalated from backoffice without detailed reason");
            }
        } else if ("REQUEST_MORE_INFO".equals(effectiveDecision)) {
            if (request.getPartnerMessage() == null || request.getPartnerMessage().trim().isEmpty()) {
                throw new IllegalArgumentException("Partner message required for more info request");
            }
        } else {
            throw new IllegalArgumentException("Unknown decision code: " + effectiveDecision);
        }

        StoredProcedureDecisionResult storedProcedureResult = claimDao.callProcessClaimDecision(
            request.getClaimId(),
            effectiveDecision,
            request.getActorUser(),
            request.getReason()
        );
        String newStatus = storedProcedureResult.getNewStatus();

        auditBean.writeBusinessAudit(
            request.getClaimId(),
            "DECISION_PROCESSED",
            request.getActorUser(),
            "oldStatus=" + oldStatus + ", newStatus=" + newStatus + ", decision=" + effectiveDecision
        );

        if ("APPROVE".equals(effectiveDecision)) {
            try {
                BigDecimal approvedAmount = coverageResult.getApprovedAmount() == null
                    ? claim.getClaimAmount()
                    : coverageResult.getApprovedAmount();

                if (coverageResult.getDeductibleAmount() != null) {
                    approvedAmount = approvedAmount.subtract(coverageResult.getDeductibleAmount());
                }
                if (approvedAmount.compareTo(BigDecimal.ZERO) < 0) {
                    approvedAmount = BigDecimal.ZERO;
                }

                if (request.isForcePayment() || approvedAmount.compareTo(BigDecimal.ZERO) > 0) {
                    LegacyPaymentReleaseResponse paymentResponse = paymentReleaseSoapClient.releasePayment(
                        request.getClaimId(),
                        claim.getCustomerId(),
                        approvedAmount,
                        request.getActorUser()
                    );
                    if (paymentResponse == null || !"OK".equals(paymentResponse.getStatus())) {
                        auditBean.writeTechnicalAudit(
                            request.getClaimId(),
                            "PAYMENT_RELEASE_FAILED",
                            request.getActorUser(),
                            paymentResponse == null ? "null response" : paymentResponse.getErrorMessage()
                        );
                        throw new IllegalStateException("Payment release failed");
                    }
                    paymentBean.markPaymentReleased(request.getClaimId(), paymentResponse.getPaymentReference(), approvedAmount);
                }
            } catch (Exception ex) {
                auditBean.writeTechnicalAudit(
                    request.getClaimId(),
                    "PAYMENT_ERROR",
                    request.getActorUser(),
                    ex.getMessage()
                );
                throw new IllegalStateException("Claim approved but payment failed", ex);
            }
        }

        try {
            eventPublisher.publishDecisionChanged(
                request.getClaimId(),
                oldStatus,
                newStatus,
                request.getActorUser(),
                request.getCorrelationId()
            );
        } catch (Exception ex) {
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "EVENT_PUBLISH_FAILED",
                request.getActorUser(),
                ex.getMessage()
            );
            throw ex;
        }

        try {
            if ("APPROVE".equals(effectiveDecision)) {
                notificationSender.sendClaimApprovedNotification(request.getClaimId(), claim.getCustomerId(), claim.getPartnerId());
            } else if ("REJECT".equals(effectiveDecision)) {
                notificationSender.sendClaimRejectedNotification(request.getClaimId(), claim.getCustomerId(), claim.getPartnerId(), request.getReason());
            } else if ("ESCALATE".equals(effectiveDecision)) {
                notificationSender.sendEscalationNotification(request.getClaimId(), request.getActorUser(), request.getReason());
            } else if ("REQUEST_MORE_INFO".equals(effectiveDecision)) {
                notificationSender.sendMoreInfoRequest(request.getClaimId(), claim.getPartnerId(), request.getPartnerMessage());
            }
        } catch (Exception ex) {
            technicalWarnings.add("Notification failed: " + ex.getMessage());
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "NOTIFICATION_FAILED",
                request.getActorUser(),
                ex.getMessage()
            );
        }

        try {
            searchBean.refreshClaimSearchCache(request.getClaimId());
        } catch (Exception ex) {
            technicalWarnings.add("Search refresh failed: " + ex.getMessage());
            auditBean.writeTechnicalAudit(
                request.getClaimId(),
                "SEARCH_REFRESH_FAILED",
                request.getActorUser(),
                ex.getMessage()
            );
        }

        if ("ESCALATE".equals(effectiveDecision)) {
            try {
                claimDao.createEscalationRecord(
                    request.getClaimId(),
                    request.getActorUser(),
                    request.getReason(),
                    Instant.now().plusSeconds(86400).toString()
                );
            } catch (Exception ex) {
                auditBean.writeTechnicalAudit(
                    request.getClaimId(),
                    "ESCALATION_RECORD_FAILED",
                    request.getActorUser(),
                    ex.getMessage()
                );
                throw new IllegalStateException("Could not create escalation record", ex);
            }
        }

        long duration = System.currentTimeMillis() - started;
        auditBean.writeTechnicalAudit(
            request.getClaimId(),
            "PROCESS_DECISION_FINISHED",
            request.getActorUser(),
            "durationMs=" + duration + ", technicalWarnings=" + technicalWarnings + ", businessWarnings=" + businessWarnings
        );

        LegacyClaimDecisionResponse response = new LegacyClaimDecisionResponse();
        response.setClaimId(request.getClaimId());
        response.setOldStatus(oldStatus);
        response.setNewStatus(newStatus);
        response.setDecisionCode(effectiveDecision);
        response.setAuditId(storedProcedureResult.getAuditId());
        response.setCorrelationId(request.getCorrelationId());
        response.setTechnicalWarnings(technicalWarnings);
        response.setBusinessWarnings(businessWarnings);
        response.setMessage("Decision processed with status " + newStatus);
        return response;
    }
}