Commit a80fca2a authored by Kostis Trantzas's avatar Kostis Trantzas
Browse files

Merge branch '98-fix-service-order-validation' into 'develop' 



Fix Service Order validation

See merge request !97

(cherry picked from commit 17b7a9ed)

e51adf3f Merge branch 'develop' into 'main'
6aa4042d Preparation for Release 2025Q4
4ec5eb03 Merge branch '2025Q4_RC' into 'main'
f8626fc3  Fix Service Order Validation
896dedd9 add order item validation
61fc1c5b Fix and add unittests

Co-authored-by: Kostis Trantzas's avatarKostis Trantzas <ktrantzas@ece.upatras.gr>
parent 4ec5eb03

src/main/java/org/etsi/osl/tmf/util/ServiceCharacteristicValueValidator.java

0 → 100644
+92 −0
Original line number Diff line number Diff line 
package org.etsi.osl.tmf.util;



import org.etsi.osl.tmf.common.model.Any;

import org.etsi.osl.tmf.common.model.ERangeInterval;

import org.etsi.osl.tmf.common.model.EValueType;

import org.etsi.osl.tmf.scm633.model.ServiceSpecCharacteristicValue;

import org.etsi.osl.tmf.common.model.service.Characteristic;



import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.time.format.DateTimeParseException;

import java.util.Objects;



public class ServiceCharacteristicValueValidator {

    private final ServiceSpecCharacteristicValue serviceSpecCharacteristicValue;

    private final Characteristic characteristic;



    public ServiceCharacteristicValueValidator(ServiceSpecCharacteristicValue serviceSpecCharacteristicValue, Characteristic characteristic) {

        this.serviceSpecCharacteristicValue = serviceSpecCharacteristicValue;

        this.characteristic = characteristic;

    }



    public boolean validateType() {

        final String INTEGER_REGEX = "[-+]?\\d+";

        final String FLOAT_REGEX = "[-+]?\\d*([.,]\\d+)?([eE][-+]?\\d+)?";

        final String BOOLEAN_REGEX = "(?i)true|false";

        final DateTimeFormatter ISO_DATE_TIME = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZ");

        if (serviceSpecCharacteristicValue.getValueType() == null) {

            return true;

        }

        Any characteristicValue = characteristic.getValue();

        if (characteristicValue == null) {

            return true;

        }

        String characteristicStringValue = characteristicValue.getValue();

        if (characteristicStringValue == null || characteristicStringValue.isBlank()) {

            return true;

        }

        try {

            return switch (EValueType.getEnum(serviceSpecCharacteristicValue.getValueType())) {

                case INTEGER, SMALLINT, lONGINT -> characteristicStringValue.matches(INTEGER_REGEX);

                case FLOAT -> characteristicStringValue.matches(FLOAT_REGEX);

                case BOOLEAN -> characteristicStringValue.matches(BOOLEAN_REGEX) || characteristicStringValue.matches(INTEGER_REGEX);

                case TIMESTAMP -> {

                    try {

                        LocalDateTime.parse(characteristicStringValue, ISO_DATE_TIME);

                        yield true;

                    } catch (DateTimeParseException e) {

                        yield false;

                    }

                }

                default -> true;

            };

        } catch (IllegalArgumentException e) {

            return false;

        }

    }



    public boolean isWithinRangeInterval() {

        if (serviceSpecCharacteristicValue.getRangeInterval() == null) {

            return true;

        }

        if (!Objects.equals(serviceSpecCharacteristicValue.getValueType(), EValueType.INTEGER.getValue()) &&

                !Objects.equals(serviceSpecCharacteristicValue.getValueType(), EValueType.SMALLINT.getValue()) &&

                !Objects.equals(serviceSpecCharacteristicValue.getValueType(), EValueType.lONGINT.getValue())) {

            return true;

        }

        Any characteristicValue = characteristic.getValue();

        if (characteristicValue == null) {

            return true;

        }

        String characteristicStringValue = characteristicValue.getValue();

        if (characteristicStringValue == null || characteristicStringValue.isBlank()) {

            return true;

        }

        Integer valueFrom = serviceSpecCharacteristicValue.getValueFrom();

        Integer valueTo = serviceSpecCharacteristicValue.getValueTo();

        int specValueFrom = valueFrom != null ? valueFrom : Integer.MIN_VALUE;

        int specValueTo = valueTo != null ? valueTo : Integer.MAX_VALUE;

        try {

            int characteristicIntValue = Integer.parseInt(characteristicStringValue);

            return switch (ERangeInterval.getEnum(serviceSpecCharacteristicValue.getRangeInterval())) {

                case OPEN -> characteristicIntValue > specValueFrom && characteristicIntValue < specValueTo;

                case CLOSED -> characteristicIntValue >= specValueFrom && characteristicIntValue <= specValueTo;

                case CLOSED_BOTTOM -> characteristicIntValue >= specValueFrom && characteristicIntValue < specValueTo;

                case CLOSED_TOP -> characteristicIntValue > specValueFrom && characteristicIntValue <= specValueTo;

            };

        } catch (IllegalArgumentException e) {

            return false;

        }

    }

}

src/main/java/org/etsi/osl/tmf/util/ServiceInventoryValidator.java

+2 −2
Original line number Diff line number Diff line
@@ -38,8 +38,8 @@ public class ServiceInventoryValidator implements Validator { 
                Set<ServiceSpecCharacteristicValue> serviceSpecCharacteristicValues = serviceSpecCharacteristic.getServiceSpecCharacteristicValue();

                characteristicParser.updateServiceSpecCharacteristicValues(serviceSpecCharacteristicValues, characteristic);

                if (serviceSpecCharacteristicValues.stream().anyMatch(value -> {

                        ServiceSpecCharacteristicValueValidator serviceSpecCharacteristicValueValidator = new ServiceSpecCharacteristicValueValidator(value);

                        return !serviceSpecCharacteristicValueValidator.validateType() || !serviceSpecCharacteristicValueValidator.isWithinRangeInterval();

                        ServiceSpecCharacteristicValueTypeValidator serviceSpecCharacteristicValueTypeValidator = new ServiceSpecCharacteristicValueTypeValidator(value);

                        return !serviceSpecCharacteristicValueTypeValidator.validateType() || !serviceSpecCharacteristicValueTypeValidator.isWithinRangeInterval();

                })) {

                    errors.reject("invalid.request");

                    return;

src/main/java/org/etsi/osl/tmf/util/ServiceOrderValidator.java

+30 −13
Original line number Diff line number Diff line
@@ -2,7 +2,6 @@ package org.etsi.osl.tmf.util; 


import org.etsi.osl.tmf.common.model.service.Characteristic;

import org.etsi.osl.tmf.scm633.model.ServiceSpecCharacteristic;

import org.etsi.osl.tmf.scm633.model.ServiceSpecCharacteristicValue;

import org.etsi.osl.tmf.scm633.model.ServiceSpecification;

import org.etsi.osl.tmf.scm633.reposervices.ServiceSpecificationRepoService;

import org.etsi.osl.tmf.so641.model.ServiceOrderCreate;
@@ -14,8 +13,6 @@ import org.springframework.stereotype.Component; 
import org.springframework.validation.Errors;

import org.springframework.validation.Validator;



import java.util.Set;



@Component

public class ServiceOrderValidator implements Validator {

    @Autowired
@@ -32,27 +29,47 @@ public class ServiceOrderValidator implements Validator { 
            return;

        }

        ServiceOrderCreate create = (ServiceOrderCreate) target;

         if (create.getOrderItem() == null || create.getOrderItem().isEmpty()) {

            errors.reject("orderItem.required", "At least one order item is required");

            return;

        }



        for (ServiceOrderItem orderItem: create.getOrderItem()) {

            if (orderItem.getService() == null) {

                errors.reject("service.required", "Service is required in order item");

                return;

            }

            

            ServiceRestriction service = orderItem.getService();

            if (service.getServiceCharacteristic() == null || service.getServiceSpecification() == null) {

            

            if (service.getServiceSpecification() == null) {

                errors.reject("serviceSpecification.required", "Service Specification is required");

                return;

            }

            

            if (service.getServiceCharacteristic() == null || service.getServiceCharacteristic().isEmpty()) {

                return;

            }

            String serviceSpecificationId = service.getServiceSpecification().getId();

            ServiceSpecification serviceSpecification = serviceSpecificationRepoService.findByUuid(serviceSpecificationId);

            CharacteristicParser characteristicParser = new CharacteristicParser();

            

            if (serviceSpecification == null) {

                errors.reject("serviceSpecification.notFound", "Service Specification not found: " + serviceSpecificationId);

                return;

            }

            

            for (Characteristic characteristic: service.getServiceCharacteristic()) {

                ServiceSpecCharacteristic serviceSpecCharacteristic = serviceSpecification.findSpecCharacteristicByName(characteristic.getName());

                if (serviceSpecCharacteristic != null) {

                    Set<ServiceSpecCharacteristicValue> serviceSpecCharacteristicValues = serviceSpecCharacteristic.getServiceSpecCharacteristicValue();

                    characteristicParser.updateServiceSpecCharacteristicValues(serviceSpecCharacteristicValues, characteristic);

                    if (serviceSpecCharacteristicValues.stream().anyMatch(value -> {

                            ServiceSpecCharacteristicValueValidator serviceSpecCharacteristicValueValidator = new ServiceSpecCharacteristicValueValidator(value);

                            return !serviceSpecCharacteristicValueValidator.validateType() || !serviceSpecCharacteristicValueValidator.isWithinRangeInterval();

                    })) {

                        errors.reject("invalid.request");

                

                if (serviceSpecCharacteristic != null && serviceSpecCharacteristic.getServiceSpecCharacteristicValue() != null) {

                    boolean isValid = serviceSpecCharacteristic.getServiceSpecCharacteristicValue().stream()

                        .anyMatch(specValue -> {

                            ServiceCharacteristicValueValidator validator = new ServiceCharacteristicValueValidator(specValue, characteristic);

                            return validator.validateType() && validator.isWithinRangeInterval();

                        });

                    

                    if (!isValid) {

                        errors.reject("serviceCharacteristics.invalid", "Service characteristic '" + characteristic.getName() + "' validation failed");

                        return;

                    }

                }

src/main/java/org/etsi/osl/tmf/util/ServiceSpecCharacteristicValueValidator.java→src/main/java/org/etsi/osl/tmf/util/ServiceSpecCharacteristicValueTypeValidator.java

+2 −2
Original line number Diff line number Diff line
@@ -10,10 +10,10 @@ import java.time.format.DateTimeFormatter; 
import java.time.format.DateTimeParseException;

import java.util.Objects;



public class ServiceSpecCharacteristicValueValidator {

public class ServiceSpecCharacteristicValueTypeValidator {

    private final ServiceSpecCharacteristicValue serviceSpecCharacteristicValue;



    public ServiceSpecCharacteristicValueValidator(ServiceSpecCharacteristicValue serviceSpecCharacteristicValue) {

    public ServiceSpecCharacteristicValueTypeValidator(ServiceSpecCharacteristicValue serviceSpecCharacteristicValue) {

        this.serviceSpecCharacteristicValue = serviceSpecCharacteristicValue;

    }

src/main/java/org/etsi/osl/tmf/util/ServiceSpecificationValidator.java

+3 −3
Original line number Diff line number Diff line
@@ -23,9 +23,9 @@ public class ServiceSpecificationValidator implements Validator { 
                .flatMap(serviceSpecCharacteristic ->

                        serviceSpecCharacteristic.getServiceSpecCharacteristicValue().stream())

                .anyMatch(serviceSpecCharacteristicValue -> {

                    ServiceSpecCharacteristicValueValidator serviceSpecCharacteristicValueValidator =

                            new ServiceSpecCharacteristicValueValidator(serviceSpecCharacteristicValue);

                    return !serviceSpecCharacteristicValueValidator.validateType() || !serviceSpecCharacteristicValueValidator.isWithinRangeInterval();

                    ServiceSpecCharacteristicValueTypeValidator serviceSpecCharacteristicValueTypeValidator =

                            new ServiceSpecCharacteristicValueTypeValidator(serviceSpecCharacteristicValue);

                    return !serviceSpecCharacteristicValueTypeValidator.validateType() || !serviceSpecCharacteristicValueTypeValidator.isWithinRangeInterval();

                });

        if (invalid) {

            errors.reject("invalid.request");