Loading src/main/java/org/etsi/osl/tmf/so641/api/ServiceOrderApiController.java +5 Viewed 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 Loading @@ -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')" ) Loading src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java +65 −18 Viewed 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 Loading @@ -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(); Loading Loading @@ -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; Loading Loading @@ -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() + ")"); } } } Loading Loading @@ -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"; } Loading src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java +277 −1 Viewed 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 Loading @@ -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; Loading @@ -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; Loading Loading @@ -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 { Loading Loading @@ -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(); Loading @@ -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 Loading
src/main/java/org/etsi/osl/tmf/so641/api/ServiceOrderApiController.java +5 Viewed 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 Loading @@ -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')" ) Loading
src/main/java/org/etsi/osl/tmf/so641/reposervices/ServiceOrderRepoService.java +65 −18 Viewed 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 Loading @@ -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(); Loading Loading @@ -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; Loading Loading @@ -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() + ")"); } } } Loading Loading @@ -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"; } Loading
src/test/java/org/etsi/osl/services/api/so641/ServiceOrderRepoServiceTest.java +277 −1 Viewed 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 Loading @@ -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; Loading @@ -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; Loading Loading @@ -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 { Loading Loading @@ -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(); Loading @@ -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