Loading src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java +15 −8 Changes for src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java: 15 added lines, 8 removed lines. Original line number Diff line number Diff line Loading @@ -787,17 +787,22 @@ 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 { /** Loading @@ -806,8 +811,10 @@ public class ServiceOrderRepoService { * 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() + ")"); Loading src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java +125 −1 Changes for src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java: 125 added lines, 1 removed line. Original line number Diff line number Diff line Loading @@ -447,6 +447,121 @@ public class ServiceOrderRepoServiceTest extends BaseIT { } /** * 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) Loading Loading @@ -554,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(); Loading @@ -573,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 Loading
src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java +15 −8 Changes for src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java: 15 added lines, 8 removed lines. Original line number Diff line number Diff line Loading @@ -787,17 +787,22 @@ 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 { /** Loading @@ -806,8 +811,10 @@ public class ServiceOrderRepoService { * 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() + ")"); Loading
src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java +125 −1 Changes for src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java: 125 added lines, 1 removed line. Original line number Diff line number Diff line Loading @@ -447,6 +447,121 @@ public class ServiceOrderRepoServiceTest extends BaseIT { } /** * 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) Loading Loading @@ -554,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(); Loading @@ -573,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