diff --git a/src/main/java/org/etsi/osl/osom/management/FetchAcknowledgedProductOrders.java b/src/main/java/org/etsi/osl/osom/management/FetchAcknowledgedProductOrders.java new file mode 100644 index 0000000000000000000000000000000000000000..b4241bac2aae328fd6caa8a05fa19bdf07e1cef0 --- /dev/null +++ b/src/main/java/org/etsi/osl/osom/management/FetchAcknowledgedProductOrders.java @@ -0,0 +1,97 @@ +/*- + * ========================LICENSE_START================================= + * org.etsi.osl.osom + * %% + * Copyright (C) 2019 openslice.io + * %% + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * =========================LICENSE_END================================== + */ +package org.etsi.osl.osom.management; + +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.etsi.osl.tmf.po622.model.ProductOrder; +import org.etsi.osl.tmf.po622.model.ProductOrderStateType; +import org.etsi.osl.tmf.so641.model.ServiceOrder; +import org.etsi.osl.tmf.so641.model.ServiceOrderStateType; +import org.flowable.engine.TaskService; +import org.flowable.engine.delegate.DelegateExecution; +import org.flowable.engine.delegate.JavaDelegate; +import org.flowable.task.api.Task; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +@Component(value = "fetchAcknowledgedProductOrders") // bean name +public class FetchAcknowledgedProductOrders implements JavaDelegate { + + private static final transient Log logger = LogFactory.getLog(FetchAcknowledgedProductOrders.class.getName()); + + + @Autowired + private ProductOrderManager productOrderManager; + + @Autowired + private ServiceOrderManager serviceOrderManager; + + @Autowired + private TaskService taskService; + + + public void execute(DelegateExecution execution) { + logger.info("======================" + execution.getProcessDefinitionId() + "======================================"); + logger.info("FetchAcknowledgedProductOrders by Product Order Repository"); + + List ordersToBeProcessed = null; + if (execution.getVariable("productOrdersToBeProcessed") instanceof ArrayList) { + ordersToBeProcessed = (ArrayList) execution.getVariable("productOrdersToBeProcessed"); + for (String orderid : ordersToBeProcessed) { + logger.info("productOrdersToBeProcessed From Previous = " + orderid); + } + } else { + ordersToBeProcessed = new ArrayList<>(); + } + + List orderlist = productOrderManager.retrieveOrdersByState( ProductOrderStateType.ACKNOWLEDGED ); + + if ( orderlist != null ) { + for (String orderid : orderlist) { + if ( !ordersToBeProcessed.contains( orderid ) ) { + + + ProductOrder sor = productOrderManager.retrieveProductOrder( orderid ); + if ( sor !=null && sor.getRequestedStartDate() != null ) { + Instant instant = Instant.now() ; // Capture the current moment as seen in UTC. + boolean canStart = sor.getRequestedStartDate().toInstant().isBefore( instant ) ; + + if ( canStart ) { + logger.info("Product order is scheduled to start now, orderid= "+ orderid +" date="+ sor.getRequestedStartDate().toInstant()); + ordersToBeProcessed.add( orderid ); + } else { + logger.info("Product order is scheduled to start later, orderid= " + orderid ); + } + } + + } + } + } + + execution.setVariable("productOrdersToBeProcessed", ordersToBeProcessed); + + + + } +} diff --git a/src/main/java/org/etsi/osl/osom/management/InitializeProcessProductOrders.java b/src/main/java/org/etsi/osl/osom/management/InitializeProcessProductOrders.java new file mode 100644 index 0000000000000000000000000000000000000000..03ffa418c376f5c6052b5302dba6fe3c97bb0afe --- /dev/null +++ b/src/main/java/org/etsi/osl/osom/management/InitializeProcessProductOrders.java @@ -0,0 +1,220 @@ +/*- + * ========================LICENSE_START================================= + * org.etsi.osl.osom + * %% + * Copyright (C) 2019 openslice.io + * %% + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * =========================LICENSE_END================================== + */ +package org.etsi.osl.osom.management; + +import java.util.ArrayList; +import java.util.List; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +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.pcm620.model.ProductOffering; +import org.etsi.osl.tmf.pcm620.model.ProductOfferingRef; +import org.etsi.osl.tmf.pcm620.model.ProductSpecification; +import org.etsi.osl.tmf.po622.model.ProductOrder; +import org.etsi.osl.tmf.po622.model.ProductOrderItem; +import org.etsi.osl.tmf.po622.model.ProductOrderStateType; +import org.etsi.osl.tmf.po622.model.ProductOrderUpdate; +import org.etsi.osl.tmf.prm669.model.RelatedParty; +import org.etsi.osl.tmf.so641.model.ServiceOrder; +import org.etsi.osl.tmf.so641.model.ServiceOrderCreate; +import org.etsi.osl.tmf.so641.model.ServiceOrderItem; +import org.etsi.osl.tmf.so641.model.ServiceOrderStateType; +import org.etsi.osl.tmf.so641.model.ServiceRestriction; +import org.flowable.engine.RuntimeService; +import org.flowable.engine.delegate.DelegateExecution; +import org.flowable.engine.delegate.JavaDelegate; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; +import jakarta.validation.Valid; + +@Component(value = "initializeProcessProductOrders") // bean name +public class InitializeProcessProductOrders implements JavaDelegate { + + private static final transient Log logger = LogFactory.getLog(InitializeProcessProductOrders.class.getName()); + + @Autowired + private ProductOrderManager productOrderManager; + + + @Autowired + private ServiceOrderManager serviceOrderManager; + + + @Value("${spring.application.name}") + private String compname; + + @Autowired + private RuntimeService runtimeService; + + public void execute(DelegateExecution execution) { + + logger.info("Check if there are new Product Orders for Orchestration: " + execution.getVariables().toString()); + + + if (execution.getVariable("productOrdersToBeProcessed") instanceof ArrayList) { + + List ordersToBeProcessed = (ArrayList) execution.getVariable("productOrdersToBeProcessed"); + for (String oId : ordersToBeProcessed) { + + //process each order request + processOrderRequest( oId ); + + } + + } + + } + + /** + * For each product order create a service order and perform the neccessary references + * @param oId + */ + private void processOrderRequest(String oId) { + + //create equivalent service order + ProductOrder prodOrder = productOrderManager.retrieveProductOrder(oId); + logger.debug("Will send message that Product Order is IN-PROGRESS orderid= " + oId ); + + ServiceOrder serviceOrder = createServiceOrderFromProductOrder(prodOrder); + + if (serviceOrder==null) { + logger.error("Service Order is NULL " ); + + return; + } + + ProductOrderUpdate productOrderUpd = new ProductOrderUpdate(); + productOrderUpd.setState(ProductOrderStateType.INPROGRESS); + for (ProductOrderItem poi : prodOrder.getProductOrderItem() ) { + if ( poi.getProduct() != null ) { + Characteristic charact = new Characteristic(); + charact.setName("_SERVICE_ORDER_ID_"); + charact.setValueType("TEXT"); + charact.setValue(new Any( serviceOrder.getId() )); + poi.getProduct().addProductCharacteristicItem(charact); + } + productOrderUpd.addProductOrderItemItem(poi); + } + + productOrderManager.updateProducteOrder( oId, productOrderUpd ); + + } + + private ServiceOrder createServiceOrderFromProductOrder(ProductOrder prodOrder) { + + + ServiceOrderCreate servOrder = new ServiceOrderCreate(); + servOrder.setCategory("Automated order"); + servOrder.setDescription("Automatically created for product order " + prodOrder.getId()); + servOrder.setRequestedStartDate(prodOrder.getRequestedStartDate()); + servOrder.setRequestedCompletionDate(prodOrder.getExpectedCompletionDate()); + RelatedParty rpi = new RelatedParty(); + rpi.setName("OSOM-ProductOrder"); + rpi.setRole("REQUESTER"); + rpi.setId("OSOM-ProductOrder"); + servOrder.addRelatedPartyItem(rpi ); + + Note noteItemOrder = new Note(); + noteItemOrder.text("Automatically created for product order " + prodOrder.getId()); + noteItemOrder.setAuthor(compname); + servOrder.addNoteItem(noteItemOrder); + + for (ProductOrderItem poi : prodOrder.getProductOrderItem()) { + @Valid + ProductOfferingRef poffRefpoi = poi.getProductOffering(); + + ProductOffering pOffer = productOrderManager.retrieveProductOffering(poffRefpoi.getId()); + if (pOffer == null) { + logger.error("Product Order - ProductOffering in ProductOrderItem is NULL"); + return null; + } + + if ( poi.getProduct() == null ) { + logger.error("Product Order - Product in ProductOrderItem is NULL"); + return null; + } + + ProductSpecification pSepc = + productOrderManager.retrieveProductSpec(poi.getProduct().getProductSpecification().getId()); + if (pSepc == null) { + logger.error("Product Order - ProductSpecification in Product, ProductOrderItem is NULL"); + return null; + } + + logger.debug("Product Order - ProductOffering name= " + pOffer.getName()); + logger.debug("Product Order - ProductSpecification name= " + pSepc.getName()); + + + for (ServiceSpecificationRef serviceSpec : pSepc.getServiceSpecification()) { + ServiceOrderItem soi = new ServiceOrderItem(); + servOrder.getOrderItem().add(soi); + soi.setState(ServiceOrderStateType.ACKNOWLEDGED); + + ServiceRestriction serviceRestriction = new ServiceRestriction(); + ServiceSpecificationRef aServiceSpecificationRef = new ServiceSpecificationRef(); + aServiceSpecificationRef.setId( serviceSpec.getId() ); + aServiceSpecificationRef.setName( serviceSpec.getName()); + aServiceSpecificationRef.setVersion( serviceSpec.getVersion()); + + serviceRestriction.setServiceSpecification(aServiceSpecificationRef); + +// πρεπει να perasoyme τιμες από το product order στο service order item +// εδω debug + + for (Characteristic servChar : poi.getProduct().getProductCharacteristic() ) { + servChar.setUuid(null); + serviceRestriction.addServiceCharacteristicItem(servChar); + } + + + + Characteristic refProductOrderChar = new Characteristic(); + refProductOrderChar.setName("_PRODUCT_ORDER_ID_"); + refProductOrderChar.setValueType("TEXT"); + refProductOrderChar.setValue(new Any( prodOrder.getId() )); + serviceRestriction.addServiceCharacteristicItem(refProductOrderChar); + + Characteristic refProductOrderItemChar = new Characteristic(); + refProductOrderItemChar.setName("_PRODUCT_ORDER_ITEM_ID_"); + refProductOrderItemChar.setValueType("TEXT"); + refProductOrderItemChar.setValue(new Any( poi.getId() )); + serviceRestriction.addServiceCharacteristicItem(refProductOrderItemChar); + + soi.setService(serviceRestriction); + + } + + + } + + ServiceOrder externalSOrder = serviceOrderManager.createServiceOrder(servOrder); + + + return externalSOrder; + + + } + + +} diff --git a/src/main/java/org/etsi/osl/osom/management/OrderCompleteService.java b/src/main/java/org/etsi/osl/osom/management/OrderCompleteService.java index 8f39cd0e6f790b6032eb4d02cbfded1f29068246..039f7ae306c04d82f4e920d251061e2199d4f24c 100644 --- a/src/main/java/org/etsi/osl/osom/management/OrderCompleteService.java +++ b/src/main/java/org/etsi/osl/osom/management/OrderCompleteService.java @@ -22,13 +22,18 @@ package org.etsi.osl.osom.management; import java.time.OffsetDateTime; import java.time.ZoneOffset; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +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.ResourceRef; import org.etsi.osl.tmf.common.model.service.ServiceRef; import org.etsi.osl.tmf.common.model.service.ServiceStateType; +import org.etsi.osl.tmf.po622.model.ProductOrderStateType; +import org.etsi.osl.tmf.po622.model.ProductOrderUpdate; import org.etsi.osl.tmf.ri639.model.Resource; import org.etsi.osl.tmf.sim638.model.Service; import org.etsi.osl.tmf.sim638.model.ServiceUpdate; @@ -54,6 +59,9 @@ public class OrderCompleteService implements JavaDelegate { @Autowired private ServiceOrderManager serviceOrderManager; + + @Autowired + private ProductOrderManager productOrderManager; @Autowired @@ -112,6 +120,7 @@ public class OrderCompleteService implements JavaDelegate { boolean existsInactiveInORder= false; boolean existsTerminatedInORder= false; //boolean updateServiceOrder= false; + Map productOrderIds = new HashMap<>(); logger.info("ServiceOrder id:" + sOrder.getId()); for (ServiceOrderItem soi : sOrder.getOrderItem()) { @@ -192,6 +201,12 @@ public class OrderCompleteService implements JavaDelegate { allTerminatedItemsInOrder = allTerminatedItemsInOrder && soi.getState().equals( ServiceOrderStateType.COMPLETED ); logger.info("ServiceOrderItem state:" + sserviceState.toString() ); + + Characteristic prodOrderChar = soi.getService().findCharacteristicByName("_PRODUCT_ORDER_ID_"); + if ( prodOrderChar != null ) { + productOrderIds.put( prodOrderChar.getValue().getValue(), prodOrderChar); + } + } @@ -221,6 +236,20 @@ public class OrderCompleteService implements JavaDelegate { serviceOrderManager.updateServiceOrderOrder( sOrder.getId() , serviceOrderUpd); + //pass the state to related product orders, if any + for (String prodOredIds : productOrderIds.keySet()) { + ProductOrderUpdate productOrderUpd = new ProductOrderUpdate(); + + if ( serviceOrderUpd.getState().equals( ServiceOrderStateType.COMPLETED ) ) { + productOrderUpd.setState( ProductOrderStateType.COMPLETED ); + } else if ( serviceOrderUpd.getState().equals( ServiceOrderStateType.FAILED ) ) { + productOrderUpd.setState( ProductOrderStateType.FAILED ); + } + + + productOrderManager.updateProducteOrder(prodOredIds, productOrderUpd); + } + } } diff --git a/src/main/java/org/etsi/osl/osom/management/ProductOrderManager.java b/src/main/java/org/etsi/osl/osom/management/ProductOrderManager.java new file mode 100644 index 0000000000000000000000000000000000000000..19b9d6eaa77d998d073519511f05e319f479bee8 --- /dev/null +++ b/src/main/java/org/etsi/osl/osom/management/ProductOrderManager.java @@ -0,0 +1,175 @@ +package org.etsi.osl.osom.management; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.apache.camel.ProducerTemplate; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.etsi.osl.tmf.pcm620.model.ProductOffering; +import org.etsi.osl.tmf.pcm620.model.ProductSpecification; +import org.etsi.osl.tmf.po622.model.ProductOrder; +import org.etsi.osl.tmf.po622.model.ProductOrderStateType; +import org.etsi.osl.tmf.po622.model.ProductOrderUpdate; +import org.etsi.osl.tmf.so641.model.ServiceOrder; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import jakarta.validation.constraints.NotNull; + +@Service +public class ProductOrderManager { + + + private static final transient Log logger = + LogFactory.getLog(ProductOrderManager.class.getName()); + + + @Autowired + private ProducerTemplate template; + + @Value("${CATALOG_GET_PRODUCTORDER_IDS_BY_STATE}") + private String CATALOG_GET_PRODUCTORDER_IDS_BY_STATE = ""; + + @Value("${CATALOG_GET_PRODUCTORDER_BY_ID}") + private String CATALOG_GET_PRODUCTORDER_BY_ID = ""; + + + @Value("${CATALOG_UPD_PRODUCTORDER_BY_ID}") + private String CATALOG_UPD_PRODUCTORDER_BY_ID = ""; + + + @Value("${CATALOG_GET_PRODUCTSPEC_BY_ID}") + private String CATALOG_GET_PRODUCTSPEC_BY_ID = ""; + + + @Value("${CATALOG_GET_PRODUCTOFFERING_BY_ID}") + private String CATALOG_GET_PRODUCTOFFERING_BY_ID = ""; + + + + public List retrieveOrdersByState(ProductOrderStateType orderState) { + logger.info("will retrieve Product Orders " + orderState.toString() + " from catalog "); + try { + Map map = new HashMap<>(); + map.put("orderstate", orderState.toString()); + Object response = + template.requestBodyAndHeaders(CATALOG_GET_PRODUCTORDER_IDS_BY_STATE, "", map); + + logger.debug("will retrieve Service Orders " + orderState.toString() + + " from catalog response: " + response.getClass()); + if (!(response instanceof String)) { + logger.error("List object is wrong."); + return null; + } + // String[] sor = toJsonObj( (String)response, String[].class ); + + ArrayList sor = toJsonObj((String) response, ArrayList.class); + logger.debug("retrieveOrdersByState response is: " + response); + + // return asList(sor); + return sor; + + } catch (Exception e) { + logger.error("Cannot retrieve Listof Product Orders " + orderState.toString() + + " from catalog. " + e.toString()); + } + return null; + } + + public ProductOrder retrieveProductOrder(String orderid) { + logger.info("will retrieve Product Order from catalog orderid=" + orderid); + try { + Object response = template.requestBody(CATALOG_GET_PRODUCTORDER_BY_ID, orderid); + + if (!(response instanceof String)) { + logger.error("Product Order object is wrong."); + return null; + } + logger.debug("retrieveProductOrder response is: " + response); + ProductOrder sor = toJsonObj((String) response, ProductOrder.class); + + return sor; + + } catch (Exception e) { + logger.error("Cannot retrieve Product Order details from catalog. " + e.toString()); + } + return null; + } + + + + public ProductSpecification retrieveProductSpec(@NotNull String id) { + logger.info("will retrieve ProductSpecification from catalog orderid=" + id); + try { + Object response = template.requestBody(CATALOG_GET_PRODUCTSPEC_BY_ID, id); + + if (!(response instanceof String)) { + logger.error("ProductSpecification object is wrong."); + return null; + } + logger.debug("retrieveProductSpecification response is: " + response); + ProductSpecification sor = toJsonObj((String) response, ProductSpecification.class); + + return sor; + + } catch (Exception e) { + logger.error("Cannot retrieve ProductSpecification details from catalog. " + e.toString()); + } + return null; + } + + public ProductOffering retrieveProductOffering(@NotNull String id) { + logger.info("will retrieve ProductOffering from catalog orderid=" + id); + try { + Object response = template.requestBody(CATALOG_GET_PRODUCTOFFERING_BY_ID, id); + + if (!(response instanceof String)) { + logger.error("ProductOffering object is wrong."); + return null; + } + logger.debug("retrievProductOffering response is: " + response); + ProductOffering sor = toJsonObj((String) response, ProductOffering.class); + + return sor; + + } catch (Exception e) { + logger.error("Cannot retrieve ProductOffering details from catalog. " + e.toString()); + } + return null; + } + + + + static T toJsonObj(String content, Class valueType) throws IOException { + ObjectMapper mapper = new ObjectMapper(); + mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); + return mapper.readValue(content, valueType); + } + + static String toJsonString(Object object) throws IOException { + ObjectMapper mapper = new ObjectMapper(); + mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); + return mapper.writeValueAsString(object); + } + + public void updateProducteOrder(String orderid, ProductOrderUpdate productOrderUpd) { + logger.info("will set Product Order in progress orderid=" + orderid); + try { + + template.sendBodyAndHeader(CATALOG_UPD_PRODUCTORDER_BY_ID, toJsonString(productOrderUpd), + "orderid", orderid); + + + } catch (Exception e) { + logger.error("Cannot set Product Order status from catalog. " + e.toString()); + } + + } + + +} diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index 26208b42b49ab255e0c0af52e626a91996dc700c..5e09475fc60dd13f01d96626c78ed8023d7dffd8 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -78,6 +78,19 @@ NFV_CATALOG_GET_NSD_BY_ID: "jms:queue:NFVCATALOG.GET.NSD_BY_ID" NFV_CATALOG_UPD_DEPLOYMENT_BY_ID: "jms:queue:NFVCATALOG.UPD.DEPLOYMENT_BY_ID" NFV_CATALOG_NS_DAY2_ACTION: "jms:queue:ns.action.run" +CATALOG_GET_PRODUCTSPEC_BY_ID: "jms:queue:CATALOG.GET.PRODUCTSPEC_BY_ID" +CATALOG_ADD_PRODUCTSPEC: "jms:queue:CATALOG.ADD.PRODUCTSPEC" +CATALOG_UPD_PRODUCTSPEC: "jms:queue:CATALOG.UPD.PRODUCTSPEC" +CATALOG_UPDADD_PRODUCTSPEC: "jms:queue:CATALOG.UPDADD.PRODUCTSPEC" +CATALOG_GET_PRODUCTOFFERING_BY_ID: "jms:queue:CATALOG.GET.PRODUCTOFFERING_BY_ID" + +CATALOG_GET_PRODUCTORDERS: "jms:queue:CATALOG.GET.PRODUCTORDERS" +CATALOG_GET_PRODUCTORDER_BY_ID: "jms:queue:CATALOG.GET.PRODUCTORDER_BY_ID" +CATALOG_ADD_PRODUCTORDER: "jms:queue:CATALOG.ADD.PRODUCTORDER" +CATALOG_UPD_PRODUCTORDER_BY_ID: "jms:queue:CATALOG.UPD.PRODUCTORDER_BY_ID" +CATALOG_GET_INITIAL_PRODUCTORDERS_IDS: "jms:queue:CATALOG.GET.INITIAL_PRODUCTORDERS" +CATALOG_GET_PRODUCTORDER_IDS_BY_STATE: "jms:queue:CATALOG.GET.ACKNOWLEDGED_PRODUCTORDERS" + #NS ACTIONS NFV_CATALOG_NSACTIONS_SCALE: "jms:queue:NSACTIONS.SCALE" diff --git a/src/main/resources/processes/ProductOrderProcess.bpmn b/src/main/resources/processes/ProductOrderProcess.bpmn new file mode 100644 index 0000000000000000000000000000000000000000..8ae9ca75079f46ec2375cc3f145e07dce3a07acc --- /dev/null +++ b/src/main/resources/processes/ProductOrderProcess.bpmn @@ -0,0 +1,44 @@ + + + + + + 0 0/1 * * * ? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/java/org/etsi/osl/osom/ProcessOrderIntegrationTest.java b/src/test/java/org/etsi/osl/osom/ProcessOrderIntegrationTest.java index 7ef1c9d633fb72b3140eb9fbb2c7cc46881a8616..34e2d5a2bf8ad9055214de2120c664f3d85448a1 100644 --- a/src/test/java/org/etsi/osl/osom/ProcessOrderIntegrationTest.java +++ b/src/test/java/org/etsi/osl/osom/ProcessOrderIntegrationTest.java @@ -184,7 +184,7 @@ public class ProcessOrderIntegrationTest { assertThat(specCirros.getServiceSpecCharacteristic().size() ).isEqualTo(12); assertThat(sorder.getOrderItem().stream().findFirst().get().getService().getServiceCharacteristic().size() ).isEqualTo(2); - assertThat(repositoryService.createProcessDefinitionQuery().count()).isEqualTo(15); + assertThat(repositoryService.createProcessDefinitionQuery().count()).isEqualTo(16); assertThat(taskService.createTaskQuery().count()).isEqualTo(0); assertThat( scmocked.getRequeestedDescriptor() ).isNull();