InitializationException: The EN 16931 VES are missing when using PeppolValidation2025_05 error

[ahmedhomrani]

Hello everyone,

I'm encountering an error when trying to run a simple PEPPOL validation example using the phive-rules-peppol version 3.2.14 or bellow to 3.2.5. The exception I'm seeing is:

Exception in thread "main" java.lang.ExceptionInInitializerError  
	at billing.PeppolValidationExample.main(PeppolValidationExample.java:7)  
Caused by: com.helger.commons.exception.InitializationException: The EN 16931 VES are missing  
	at com.helger.phive.peppol.PeppolValidation2025_03.init(PeppolValidation2025_03.java:82)  
	at com.helger.phive.peppol.PeppolValidationBisEurope.init(PeppolValidationBisEurope.java:68)  
	at com.helger.phive.peppol.PeppolValidation.initStandard(PeppolValidation.java:58)  
	at billing.PeppolXmlValidator.initializeValidator(PeppolXmlValidator.java:50)  
	at billing.PeppolXmlValidator.<clinit>(PeppolXmlValidator.java:43)  
	... 1 more

From what I understand, it seems that the validator can't find the EN 16931 Validation Artefacts (DVRCoord), but I'm not sure what the correct way is to include or register them.

I'm using the following version of the PEPPOL libraries:

       <dependency>
            <groupId>com.helger.commons</groupId>
            <artifactId>ph-commons</artifactId>
            <version>11.2.6</version>
        </dependency>
        <dependency>
            <groupId>com.helger.phive.rules</groupId>
            <artifactId>phive-rules-peppol</artifactId>
            <version>3.2.14</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.helger.diver</groupId>
            <artifactId>ph-diver-api</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.helger.phive</groupId>
            <artifactId>phive-xml</artifactId>
            <version>10.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.helger.phive</groupId>
            <artifactId>phive-api</artifactId>
            <version>10.1.1</version>
        </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>2.0.16</version>
            </dependency>
            <dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>4.0.2</version>
</dependency>
<!-- JAXB Runtime -->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>4.0.5</version>
</dependency>
<!-- Schematron SVRL JAXB -->
<dependency>
    <groupId>com.helger.schematron</groupId>
    <artifactId>ph-schematron-xslt</artifactId>
    <version>7.1.1</version>
</dependency>
<dependency>
    <groupId>com.helger.schematron</groupId>
    <artifactId>ph-schematron-api</artifactId>
    <version>7.1.1</version>
</dependency>

I would appreciate any guidance on:

How to correctly include or reference the EN 16931 VES

Whether I need to manually download and register certain Schematron or XML files

Or if there’s a preferred way to bootstrap PeppolValidation2025_03

Here my code

package billing;
package billing;
import com.helger.commons.error.list.ErrorList;
import com.helger.commons.io.resource.inmemory.ReadableResourceString;
import com.helger.diver.api.coord.DVRCoordinate;
import com.helger.phive.api.execute.ValidationExecutionManager;
import com.helger.phive.api.executorset.IValidationExecutorSet;
import com.helger.phive.api.executorset.IValidationExecutorSetRegistry;
import com.helger.phive.api.executorset.ValidationExecutorSetRegistry;
import com.helger.phive.api.result.ValidationResultList;
import com.helger.phive.peppol.PeppolValidation;
import com.helger.phive.peppol.PeppolValidation2024_05;
import com.helger.phive.peppol.PeppolValidation2025_05;
import com.helger.phive.xml.source.IValidationSourceXML;
import com.helger.phive.xml.source.ValidationSourceXML;
import org.w3c.dom.Document;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;

import static java.util.Collections.emptyList;

public class PeppolXmlValidator {

    private static IValidationExecutorSetRegistry<IValidationSourceXML> validationExecutorSetRegistry;
    private static DVRCoordinate vesid_invoice;
    private static DVRCoordinate vesid_creditNote;
    private static DVRCoordinate vesid_order;
    private static DVRCoordinate vesid_orderResponse;
    private static DVRCoordinate vesid_despatchAdvice;

    static {
        initializeValidator();
    }

    private static void initializeValidator() {
        validationExecutorSetRegistry = new ValidationExecutorSetRegistry<>();
        
        // Initialize PEPPOL validation rules
        PeppolValidation.initStandard(validationExecutorSetRegistry);
        
        // Set up document type VESIDs (Validation Executor Set IDs)
        vesid_invoice = PeppolValidation2025_05.VID_OPENPEPPOL_INVOICE_UBL_V3;
        vesid_creditNote = PeppolValidation2025_05.VID_OPENPEPPOL_CREDIT_NOTE_UBL_V3;
        vesid_order = PeppolValidation2025_05.VID_OPENPEPPOL_ORDER_V3;
        vesid_orderResponse = PeppolValidation2025_05.VID_OPENPEPPOL_ORDER_RESPONSE_V3;
        vesid_despatchAdvice = PeppolValidation2025_05.VID_OPENPEPPOL_DESPATCH_ADVICE_V3;
    }

    /**
     * Validates XML file from project directory
     */
    public ValidationResult validateFile(String filePath) {
        try {
            File xmlFile = new File(filePath);
            if (!xmlFile.exists()) {
                throw new IllegalArgumentException("File not found: " + filePath);
            }
            
            String xmlContent = new String(Files.readAllBytes(xmlFile.toPath()), StandardCharsets.UTF_8);
            return validateXmlContent(xmlContent);
            
        } catch (Exception e) {
            return new DefaultValidationResult(Validity.INVALID, 
                List.of("Failed to read or validate file: " + e.getMessage()), 
                emptyList());
        }
    }

    /**
     * Validates XML content string
     */
    public ValidationResult validateXmlContent(String xmlContent) {
        try {
            // Parse XML to determine document type
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setNamespaceAware(true);
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse(new java.io.ByteArrayInputStream(xmlContent.getBytes(StandardCharsets.UTF_8)));
            
            // Determine document type and get appropriate validation executor set
            IValidationExecutorSet<IValidationSourceXML> aVES = getValidationExecutorSet(document);
            
            if (aVES != null) {
                return doValidation(aVES, xmlContent);
            } else {
                return new DefaultValidationResult(Validity.INVALID, 
                    List.of("Unsupported PEPPOL document type or invalid XML structure"), 
                    emptyList());
            }
            
        } catch (Exception e) {
            return new DefaultValidationResult(Validity.INVALID, 
                List.of("Failed to parse or validate XML: " + e.getMessage()), 
                emptyList());
        }
    }

    /**
     * Validates XML Document object
     */
    public ValidationResult validateDocument(Document document) {
        try {
            // Convert Document to XML string
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            StringWriter writer = new StringWriter();
            transformer.transform(new DOMSource(document), new StreamResult(writer));
            String xmlContent = writer.toString();
            
            return validateXmlContent(xmlContent);
            
        } catch (Exception e) {
            return new DefaultValidationResult(Validity.INVALID, 
                List.of("Failed to convert document to XML: " + e.getMessage()), 
                emptyList());
        }
    }

    /**
     * Determines the appropriate validation executor set based on document type
     */
    private IValidationExecutorSet<IValidationSourceXML> getValidationExecutorSet(Document document) {
        String rootElementName = document.getDocumentElement().getLocalName();
        String namespaceURI = document.getDocumentElement().getNamespaceURI();
        
        // Check for UBL 2.1 namespace
        if (namespaceURI != null && namespaceURI.contains("urn:oasis:names:specification:ubl:schema:xsd:")) {
            switch (rootElementName) {
                case "Invoice":
                    return validationExecutorSetRegistry.getOfID(vesid_invoice);
                case "CreditNote":
                    return validationExecutorSetRegistry.getOfID(vesid_creditNote);
                case "Order":
                    return validationExecutorSetRegistry.getOfID(vesid_order);
                case "OrderResponse":
                    return validationExecutorSetRegistry.getOfID(vesid_orderResponse);
                case "DespatchAdvice":
                    return validationExecutorSetRegistry.getOfID(vesid_despatchAdvice);
            }
        }
        
        // Fallback: check namespace endings (for compatibility)
        if (namespaceURI != null) {
            if (namespaceURI.endsWith("Invoice-2")) {
                return validationExecutorSetRegistry.getOfID(vesid_invoice);
            }
            if (namespaceURI.endsWith("CreditNote-2")) {
                return validationExecutorSetRegistry.getOfID(vesid_creditNote);
            }
        }
        
        return null;
    }

    /**
     * Performs the actual validation using PEPPOL rules
     */
    private ValidationResult doValidation(IValidationExecutorSet<IValidationSourceXML> aVES, String xmlContent) {
        try {
            // Create validation source from XML content
            final IValidationSourceXML validationSourceXML = ValidationSourceXML.create(
                new ReadableResourceString(xmlContent, StandardCharsets.UTF_8));

            // Execute validation
            final ValidationResultList vResult = ValidationExecutionManager.executeValidation(aVES, validationSourceXML);
            
            // Process results
            if (vResult.containsAtLeastOneError()) {
                return new DefaultValidationResult(Validity.INVALID, 
                    getTextFrom(vResult.getAllErrors()), 
                    getTextFrom(vResult.getAllFailures()));
            } else if (vResult.containsAtLeastOneFailure()) {
                return new DefaultValidationResult(Validity.WITH_WARNINGS, 
                    emptyList(), 
                    getTextFrom(vResult.getAllFailures()));
            } else {
                return new DefaultValidationResult(Validity.VALID, emptyList(), emptyList());
            }
            
        } catch (Exception e) {
            return new DefaultValidationResult(Validity.INVALID, 
                List.of("Validation execution failed: " + e.getMessage()), 
                emptyList());
        }
    }

    /**
     * Converts ErrorList to List of String messages
     */
    private List<String> getTextFrom(ErrorList errorList) {
        return errorList.stream()
            .map(error -> error.getAsString(Locale.getDefault()))
            .collect(Collectors.toList());
    }

    /**
     * Gets available PEPPOL document types
     */
    public static List<String> getSupportedDocumentTypes() {
        return List.of("Invoice", "CreditNote", "Order", "OrderResponse", "DespatchAdvice", "ReceiptAdvice");
    }

    /**
     * Utility method to check if a document type is supported
     */
    public static boolean isDocumentTypeSupported(String documentType) {
        return getSupportedDocumentTypes().contains(documentType);
    }
}

Thanks in advance!

[phax]

Hi @ahmedhomrani,
Simply add

EN16931Validation.initEN16931 (validationExecutorSetRegistry);

before

PeppolValidation.initStandard(validationExecutorSetRegistry);

and the problem will be resolved.
The addition of BIS Self-Billing introduced this requirement.

[ahmedhomrani]

Thank you problem resolved !