Resolve "An existing service order currently cannot be amended with a new order item"

Closes #105

Merge request reports

Loading
+5
Changes for src/main/java/org/etsi/osl/tmf/so641/api/ServiceOrderApiController.java: 5 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -218,9 +218,14 @@ public class ServiceOrderApiController implements ServiceOrderApi {
			Principal principal,			
			@Parameter(description = "Identifier of the ServiceOrder", required = true) @PathVariable("id") String id,
			@Parameter(description = "The ServiceOrder to be updated", required = true) @Valid @RequestBody ServiceOrderUpdate serviceOrder) {
		try {
			ServiceOrder c = serviceOrderRepoService.updateServiceOrder(id, serviceOrder);

			return new ResponseEntity<ServiceOrder>(c, HttpStatus.OK);
		} catch (NotFoundException e) {
			log.error("Couldn't update Service Order. ", e);
			return new ResponseEntity<ServiceOrder>(HttpStatus.BAD_REQUEST);
		}
	}

	@PreAuthorize("hasAnyAuthority('ROLE_USER')" )
+65 −18
Changes for src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java: 65 added lines, 18 removed lines.
Original line number Diff line number Diff line
@@ -462,14 +462,7 @@ public class ServiceOrderRepoService {
		// Ensure that all Services Specifications exist
		List <ServiceOrderItem> serviceOrderItemList = serviceOrderCreate.getOrderItem();
		for (ServiceOrderItem serviceOrderItem: serviceOrderItemList) {
			ServiceRestriction serviceRestriction = serviceOrderItem.getService();
			ServiceSpecificationRef serviceSpecificationRef = serviceRestriction.getServiceSpecification();
			String serviceSpecificationId = serviceSpecificationRef.getId();

			ServiceSpecification serviceSpecification = serviceSpecRepoService.findByUuid(serviceSpecificationId);

			if (serviceSpecification == null)
				throw new NotFoundException(400, "There is no Service Specification with Id: " + serviceSpecificationId);
			checkServiceSpecificationExists(serviceOrderItem);
		}

		ServiceOrder so = new ServiceOrder();
@@ -701,12 +694,41 @@ public class ServiceOrderRepoService {
		
	}

	/**
	 * Ensures that the order item references an existing Service Specification
	 *
	 * @param soi
	 * @throws NotFoundException (400) if the item has no service specification or it does not exist
	 */
	private void checkServiceSpecificationExists(ServiceOrderItem soi) throws NotFoundException {
		ServiceSpecificationRef serviceSpecificationRef = ( soi.getService() != null ) ? soi.getService().getServiceSpecification() : null;
		String serviceSpecificationId = ( serviceSpecificationRef != null ) ? serviceSpecificationRef.getId() : null;

		if ( ( serviceSpecificationId == null ) || ( serviceSpecRepoService.findByUuid(serviceSpecificationId) == null ) ) {
			throw new NotFoundException(400, "There is no Service Specification with Id: " + serviceSpecificationId);
		}
	}

	@Transactional
	public ServiceOrder updateServiceOrder(String id, @Valid ServiceOrderUpdate serviceOrderUpd) {
	public ServiceOrder updateServiceOrder(String id, @Valid ServiceOrderUpdate serviceOrderUpd) throws NotFoundException {

		logger.info("Will updateServiceOrder:" + id);

		ServiceOrder so = this.findByUuid(id);

		/**
		 * Order items to be appended are validated before anything is changed: the order is managed,
		 * and a checked exception does not roll the transaction back, so a later throw would still
		 * commit the part of the update applied until then
		 */
		if ( serviceOrderUpd.getOrderItem() != null ) {
			for (ServiceOrderItem soiUpd :  serviceOrderUpd.getOrderItem()) {
				if ( so.findOrderItemById( soiUpd.getId() ) == null ) {
					checkServiceSpecificationExists( soiUpd );
				}
			}
		}

		boolean stateChanged = false;
		boolean expectedCompletionDateChanged = false;

@@ -765,18 +787,37 @@ public class ServiceOrderRepoService {
			for (ServiceOrderItem soiUpd :  serviceOrderUpd.getOrderItem()) {
				ServiceOrderItem soiOrigin = so.findOrderItemById( soiUpd.getId() );
				if (soiOrigin!=null) {
					updateOrderItem(soiOrigin, soiUpd);
					/**
					 * When we patch the order and see a MODIFY or DELETE action, we set the state to ACKNOWLEDGED
					 * An existing order item can only be modified or deleted, it cannot be added again.
					 * An ADD action is dropped, so that the item keeps its current action.
					 */
					if ( soiOrigin.getAction().equals( ServiceOrderActionType.MODIFY ) ||
							soiOrigin.getAction().equals( ServiceOrderActionType.DELETE )) {
						soiOrigin.setState( ServiceOrderStateType.ACKNOWLEDGED  );
						so.setState( ServiceOrderStateType.ACKNOWLEDGED );
						
						
					if ( ServiceOrderActionType.ADD.equals( soiUpd.getAction() ) ) {
						soiUpd.setAction( null );
					}
					updateOrderItem(soiOrigin, soiUpd);
					/**
					 * 2026-09-24: removed the automatic ACKNOWLEDGED of the order item and of the order, which
					 * was applied when the patch carried a MODIFY or DELETE action.
					 * An order may still be in planning: e.g. it starts next week and is kept in INITIAL while
					 * its items are added or modified. Acknowledging it on the first such change would start
					 * its processing too early. The order is moved to ACKNOWLEDGED explicitly, by setting its
					 * state, once its items are final.
					 */

				} else {
					/**
					 * An order item the order does not carry yet: append it, so that an existing order
					 * can be amended with a new item. The item must arrive transient (no uuid), so that
					 * the uuid2 generator assigns it a fresh identifier. ServiceOrder.orderItem cascades
					 * PERSIST/MERGE and ServiceOrderItem.service cascades ALL, so the item's
					 * ServiceRestriction and its characteristics are persisted along with it.
					 * A new order item is always an ADD, whatever action it arrives with.
					 */
					soiUpd.setUuid( null );
					soiUpd.setAction( ServiceOrderActionType.ADD );
					so.addOrderItemItem( soiUpd );
					logger.info("Order item appended to service order " + id
							+ " (action=" + soiUpd.getAction() + ", state=" + soiUpd.getState() + ")");
				}
			}
		}
@@ -1155,7 +1196,13 @@ public class ServiceOrderRepoService {
		for (String lane : lanes.keySet()) {
			charvalue += "lane " + lanes.get(lane).name  + " {\r\n";
			for ( Note aNote : lanes.get(lane).boxes) {
				charvalue += aNote.getUuid() +" [label = \"" + aNote.getDateString() + "\r\n "+ aNote.getText()  +"\", color = \"#2596be\"]\r\n";
			    String txt = aNote.getText();
			    if ( txt.length()>40 )
			      txt = txt.substring(0, 40);
				charvalue += aNote.getUuid() +" [label = \"" + aNote.getDateString() + "\r\n " 
				    + txt 
				    +"\", color = \"#2596be\"]\r\n";
				
			}
			charvalue += "}\r\n";
		}
+277 −1
Changes for src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java: 277 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ import org.apache.commons.io.IOUtils;
import org.etsi.osl.services.api.BaseIT;
import org.etsi.osl.tmf.JsonUtils;
import java.util.stream.Collectors;
import org.etsi.osl.tmf.common.model.Any;
import org.etsi.osl.tmf.common.model.service.Characteristic;
import org.etsi.osl.tmf.common.model.service.Note;
import org.etsi.osl.tmf.common.model.service.ServiceSpecificationRef;
import org.etsi.osl.tmf.common.model.service.ServiceStateType;
@@ -29,6 +31,7 @@ import org.etsi.osl.tmf.so641.repo.ServiceOrderRepository;
import org.etsi.osl.tmf.scm633.model.ServiceSpecification;
import org.etsi.osl.tmf.scm633.model.ServiceSpecificationCreate;
import org.etsi.osl.tmf.so641.model.ServiceOrder;
import org.etsi.osl.tmf.so641.model.ServiceOrderActionType;
import org.etsi.osl.tmf.so641.model.ServiceOrderCreate;
import org.etsi.osl.tmf.so641.model.ServiceOrderItem;
import org.etsi.osl.tmf.so641.model.ServiceOrderRelationship;
@@ -342,6 +345,270 @@ public class ServiceOrderRepoServiceTest extends BaseIT {
    }


    /**
     * An existing order is amended with one new order item via PATCH (#105).
     * Before the fix, an item the order did not carry was silently dropped.
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderAppendsNewOrderItem() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(createServiceOrder(), ServiceOrder.class);
        String soId = createdServiceOrder.getId();
        ServiceOrderItem originalItem = createdServiceOrder.getOrderItem().iterator().next();
        String specId = originalItem.getService().getServiceSpecification().getId();

        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.addOrderItemItem(newOrderItem(specId, "addedRestriction", "addedValue"));
        patchServiceOrder(soId, servOrderUpd);

        ServiceOrder updatedServiceOrder = JsonUtils.toJsonObj(
                serviceOrderRepoService.getServiceOrderEagerAsString(soId), ServiceOrder.class);

        assertThat(updatedServiceOrder.getOrderItem()).hasSize(2);
        assertThat(updatedServiceOrder.findOrderItemById(originalItem.getId())).isNotNull();

        ServiceOrderItem addedItem = updatedServiceOrder.getOrderItem().stream()
                .filter(soi -> !soi.getId().equals(originalItem.getId())).findFirst().orElseThrow();
        assertThat(addedItem.getId()).isNotNull();
        assertThat(addedItem.getAction()).isEqualTo(ServiceOrderActionType.ADD);
        assertThat(addedItem.getService().getName()).isEqualTo("addedRestriction");
        assertThat(addedItem.getService().getServiceSpecification().getId()).isEqualTo(specId);
        assertThat(addedItem.getService().findCharacteristicByName("addedChar").getValue().getValue())
                .isEqualTo("addedValue");
    }


    /**
     * An existing order is amended with two new order items in the same PATCH (#105).
     * The first appended item is still transient (no uuid) while the second one is looked up,
     * which threw a NullPointerException in ServiceOrder.findOrderItemById before model.tmf #39.
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderAppendsTwoNewOrderItems() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(createServiceOrder(), ServiceOrder.class);
        String soId = createdServiceOrder.getId();
        ServiceOrderItem originalItem = createdServiceOrder.getOrderItem().iterator().next();
        String specId = originalItem.getService().getServiceSpecification().getId();

        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.addOrderItemItem(newOrderItem(specId, "firstAddedRestriction", "firstValue"));
        servOrderUpd.addOrderItemItem(newOrderItem(specId, "secondAddedRestriction", "secondValue"));
        patchServiceOrder(soId, servOrderUpd);

        ServiceOrder updatedServiceOrder = JsonUtils.toJsonObj(
                serviceOrderRepoService.getServiceOrderEagerAsString(soId), ServiceOrder.class);

        assertThat(updatedServiceOrder.getOrderItem()).hasSize(3);
        assertThat(updatedServiceOrder.findOrderItemById(originalItem.getId())).isNotNull();
        assertThat(updatedServiceOrder.getOrderItem().stream().map(ServiceOrderItem::getId).distinct().count())
                .isEqualTo(3);

        List<ServiceOrderItem> addedItems = updatedServiceOrder.getOrderItem().stream()
                .filter(soi -> !soi.getId().equals(originalItem.getId())).collect(Collectors.toList());
        assertThat(addedItems).extracting(soi -> soi.getService().getName())
                .containsExactlyInAnyOrder("firstAddedRestriction", "secondAddedRestriction");
        assertThat(addedItems).extracting(soi -> soi.getService().findCharacteristicByName("addedChar").getValue().getValue())
                .containsExactlyInAnyOrder("firstValue", "secondValue");
    }


    /**
     * A new order item must reference an existing Service Specification, as on order creation.
     * The PATCH is rejected with 400 and none of it is applied, not even the other attributes it carries.
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderRejectsNewOrderItemWithUnknownSpec() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(createServiceOrder(), ServiceOrder.class);
        String soId = createdServiceOrder.getId();

        // a service specification that does not exist
        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.setDescription("Should not be applied");
        servOrderUpd.addOrderItemItem(newOrderItem("no-such-spec", "rejectedRestriction", "rejectedValue"));
        patchServiceOrderExpectingBadRequest(soId, servOrderUpd);

        // no service specification at all
        ServiceOrderUpdate servOrderUpdNoSpec = new ServiceOrderUpdate();
        servOrderUpdNoSpec.setDescription("Should not be applied");
        ServiceOrderItem noSpecItem = new ServiceOrderItem();
        noSpecItem.setService(new ServiceRestriction());
        servOrderUpdNoSpec.addOrderItemItem(noSpecItem);
        patchServiceOrderExpectingBadRequest(soId, servOrderUpdNoSpec);

        ServiceOrder unchangedServiceOrder = JsonUtils.toJsonObj(
                serviceOrderRepoService.getServiceOrderEagerAsString(soId), ServiceOrder.class);
        assertThat(unchangedServiceOrder.getOrderItem()).hasSize(1);
        assertThat(unchangedServiceOrder.getDescription()).isEqualTo("A Test Service Order");
    }


    /**
     * A new order item is always an ADD, whatever action it arrives with
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderNewOrderItemIsAlwaysAdd() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(createServiceOrder(), ServiceOrder.class);
        String soId = createdServiceOrder.getId();
        ServiceOrderItem originalItem = createdServiceOrder.getOrderItem().iterator().next();
        String specId = originalItem.getService().getServiceSpecification().getId();

        ServiceOrderItem modifyItem = newOrderItem(specId, "modifyRestriction", "modifyValue");
        modifyItem.setAction(ServiceOrderActionType.MODIFY);
        ServiceOrderItem deleteItem = newOrderItem(specId, "deleteRestriction", "deleteValue");
        deleteItem.setAction(ServiceOrderActionType.DELETE);

        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.addOrderItemItem(modifyItem);
        servOrderUpd.addOrderItemItem(deleteItem);
        patchServiceOrder(soId, servOrderUpd);

        ServiceOrder updatedServiceOrder = serviceOrderFromDb(soId);
        assertThat(updatedServiceOrder.getOrderItem()).hasSize(3);
        assertThat(updatedServiceOrder.getOrderItem().stream()
                .filter(soi -> !soi.getId().equals(originalItem.getId())))
                .extracting(ServiceOrderItem::getAction)
                .containsExactly(ServiceOrderActionType.ADD, ServiceOrderActionType.ADD);
    }


    /**
     * An existing order item takes a MODIFY or DELETE action, while an ADD is ignored and the item
     * keeps its current action
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderExistingOrderItemIgnoresAdd() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(createServiceOrder(), ServiceOrder.class);
        String soId = createdServiceOrder.getId();
        String itemId = createdServiceOrder.getOrderItem().iterator().next().getId();

        patchServiceOrder(soId, existingItemUpdate(itemId, ServiceOrderActionType.MODIFY));
        assertThat(serviceOrderFromDb(soId).findOrderItemById(itemId).getAction())
                .isEqualTo(ServiceOrderActionType.MODIFY);

        patchServiceOrder(soId, existingItemUpdate(itemId, ServiceOrderActionType.ADD));
        ServiceOrder afterAdd = serviceOrderFromDb(soId);
        assertThat(afterAdd.getOrderItem()).hasSize(1);
        assertThat(afterAdd.findOrderItemById(itemId).getAction()).isEqualTo(ServiceOrderActionType.MODIFY);

        patchServiceOrder(soId, existingItemUpdate(itemId, ServiceOrderActionType.DELETE));
        assertThat(serviceOrderFromDb(soId).findOrderItemById(itemId).getAction())
                .isEqualTo(ServiceOrderActionType.DELETE);
    }


    /**
     * The order is no longer acknowledged automatically on a MODIFY or DELETE. An order in planning
     * stays INITIAL while its items are added or modified, until its state is set explicitly.
     */
    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testUpdateServiceOrderDoesNotAutoAcknowledge() throws Exception {

        ServiceOrder createdServiceOrder = JsonUtils.toJsonObj(
                createServiceOrder(ServiceOrderStateType.INITIAL), ServiceOrder.class);
        String soId = createdServiceOrder.getId();
        ServiceOrderItem originalItem = createdServiceOrder.getOrderItem().iterator().next();
        String itemId = originalItem.getId();
        String specId = originalItem.getService().getServiceSpecification().getId();
        assertThat(createdServiceOrder.getState()).isEqualTo(ServiceOrderStateType.INITIAL);

        // modify, then delete, an existing item and append a new one
        patchServiceOrder(soId, existingItemUpdate(itemId, ServiceOrderActionType.MODIFY));
        patchServiceOrder(soId, existingItemUpdate(itemId, ServiceOrderActionType.DELETE));
        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.addOrderItemItem(newOrderItem(specId, "plannedRestriction", "plannedValue"));
        patchServiceOrder(soId, servOrderUpd);

        ServiceOrder plannedServiceOrder = serviceOrderFromDb(soId);
        assertThat(plannedServiceOrder.getState()).isEqualTo(ServiceOrderStateType.INITIAL);
        assertThat(plannedServiceOrder.getOrderItem()).hasSize(2);
        assertThat(plannedServiceOrder.findOrderItemById(itemId).getState())
                .isNotEqualTo(ServiceOrderStateType.ACKNOWLEDGED);

        // the order is acknowledged once its state is set
        ServiceOrderUpdate ackUpd = new ServiceOrderUpdate();
        ackUpd.setState(ServiceOrderStateType.ACKNOWLEDGED);
        patchServiceOrder(soId, ackUpd);
        assertThat(serviceOrderFromDb(soId).getState()).isEqualTo(ServiceOrderStateType.ACKNOWLEDGED);
    }


    /**
     * An update of an existing order item that carries only its id and an action
     */
    private ServiceOrderUpdate existingItemUpdate(String itemId, ServiceOrderActionType action) {

        ServiceOrderItem soi = new ServiceOrderItem();
        soi.setUuid(itemId);
        soi.setAction(action);

        ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate();
        servOrderUpd.addOrderItemItem(soi);
        return servOrderUpd;
    }


    private ServiceOrder serviceOrderFromDb(String soId) throws Exception {
        return JsonUtils.toJsonObj(serviceOrderRepoService.getServiceOrderEagerAsString(soId), ServiceOrder.class);
    }


    private void patchServiceOrderExpectingBadRequest(String soId, ServiceOrderUpdate servOrderUpd) throws Exception {

        mvc.perform(MockMvcRequestBuilders.patch("/serviceOrdering/v4/serviceOrder/" + soId)
                        .with( SecurityMockMvcRequestPostProcessors.csrf())
                        .contentType(MediaType.APPLICATION_JSON)
                        .content( JsonUtils.toJson( servOrderUpd ) ))
                .andExpect(status().isBadRequest() );
    }


    /**
     * A new order item as a client would send it: no uuid, so the order does not carry it yet
     */
    private ServiceOrderItem newOrderItem(String specId, String restrictionName, String charValue) {

        ServiceOrderItem soi = new ServiceOrderItem();
        soi.setAction(ServiceOrderActionType.ADD);
        soi.setState(ServiceOrderStateType.ACKNOWLEDGED);

        ServiceSpecificationRef aServiceSpecificationRef = new ServiceSpecificationRef();
        aServiceSpecificationRef.setId(specId);

        ServiceRestriction serviceRestriction = new ServiceRestriction();
        serviceRestriction.setServiceSpecification(aServiceSpecificationRef);
        serviceRestriction.setName(restrictionName);

        Characteristic aCharacteristic = new Characteristic();
        aCharacteristic.setName("addedChar");
        aCharacteristic.setValue(new Any(charValue, charValue));
        serviceRestriction.addServiceCharacteristicItem(aCharacteristic);

        soi.setService(serviceRestriction);
        return soi;
    }


    private void patchServiceOrder(String soId, ServiceOrderUpdate servOrderUpd) throws Exception {

        mvc.perform(MockMvcRequestBuilders.patch("/serviceOrdering/v4/serviceOrder/" + soId)
                        .with( SecurityMockMvcRequestPostProcessors.csrf())
                        .contentType(MediaType.APPLICATION_JSON)
                        .content( JsonUtils.toJson( servOrderUpd ) ))
                .andExpect(status().isOk() )
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON));
    }


    @WithMockUser(username="osadmin", roles = {"ADMIN","USER"})
    @Test
    public void testGetServiceOrderEagerAsString() throws Exception {
@@ -402,6 +669,15 @@ public class ServiceOrderRepoServiceTest extends BaseIT {


    private String createServiceOrder() throws Exception {
        return createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED);
    }


    /**
     * Creates a service order with one item in the given state. The order is acknowledged at creation
     * only when its item is, since the mock user has no ROLE_OSL_AUTOACK_ORDER.
     */
    private String createServiceOrder(ServiceOrderStateType itemState) throws Exception {

        int currSize = serviceOrderRepoService.findAll().size();

@@ -421,7 +697,7 @@ public class ServiceOrderRepoServiceTest extends BaseIT {

        ServiceOrderItem soi = new ServiceOrderItem();
        serviceOrder.getOrderItem().add(soi);
        soi.setState(ServiceOrderStateType.ACKNOWLEDGED);
        soi.setState(itemState);

        ServiceRestriction serviceRestriction = new ServiceRestriction();
        ServiceSpecificationRef aServiceSpecificationRef = new ServiceSpecificationRef();
Loading