restTemplate.exchange(callURI, HttpMethod.GET, buildRequestHeader(), byte[].class);
LOGGER.info("response status : " + response.getStatusCodeValue());
if (!response.getStatusCode().equals(HttpStatus.OK)) {
- LOGGER.warn(HTTP_CALL_SDC_ON + callURI.toString() + " returns " + response.getStatusCodeValue() + ", "
+ LOGGER.error(HTTP_CALL_SDC_ON + callURI.toString() + " returns " + response.getStatusCodeValue() + ", "
+ response.getBody().toString());
}
return response;
LOGGER.debug("response body : " + response.getBody().toString());
LOGGER.info("response status : " + response.getStatusCodeValue());
if (!response.getStatusCode().equals(HttpStatus.OK)) {
- LOGGER.warn("HTTP call on " + callURL + " returns " + response.getStatusCodeValue() + ", "
+ LOGGER.error("HTTP call on " + callURL + " returns " + response.getStatusCodeValue() + ", "
+ response.getBody().toString());
}
return response;
}
- public void putCustomer(SubscriberInfo subscriberInfo) {
+ public boolean putCustomer(SubscriberInfo subscriberInfo) {
Map<String, String> param = new HashMap<>();
param.put("global-customer-id", subscriberInfo.getGlobalSubscriberId());
param.put("subscriber-name", subscriberInfo.getSubscriberName());
String callURL =
aaiHost + OnapComponentsUrlPaths.AAI_GET_CUSTOMER_PATH + subscriberInfo.getGlobalSubscriberId();
- putRequest(param, callURL, buildRequestHeaderForAAI());
+ ResponseEntity<Object> response = putRequest(param, callURL, buildRequestHeaderForAAI());
+ if (response != null && response.getStatusCode().equals(HttpStatus.CREATED)) {
+ return true;
+ }
+ return false;
}
return null;
}
- public void putServiceType(String globalSubscriberId, String serviceName) {
+ public boolean putServiceType(String globalSubscriberId, String serviceName) {
Map<String, String> param = new HashMap<>();
param.put("service-type", serviceName);
String callURL = aaiHost + OnapComponentsUrlPaths.AAI_PUT_SERVICE_FOR_CUSTOMER_PATH + serviceName;
String callUrlFormated = callURL.toString().replace("$customerId", globalSubscriberId);
- putRequest(param, callUrlFormated, buildRequestHeaderForAAI());
+ ResponseEntity<Object> response = putRequest(param, callUrlFormated, buildRequestHeaderForAAI());
+ if (response != null && response.getStatusCode().equals(HttpStatus.CREATED)) {
+ return true;
+ }
+ return false;
}
- private void putRequest(Map<String, String> param, String callUrl, HttpHeaders httpHeaders) {
+ private ResponseEntity<Object> putRequest(Map<String, String> param, String callUrl, HttpHeaders httpHeaders) {
try {
ResponseEntity<Object> response =
restTemplate.exchange(callUrl, HttpMethod.PUT, new HttpEntity<>(param, httpHeaders), Object.class);
LOGGER.warn("HTTP call on " + callUrl + " returns " + response.getStatusCodeValue() + ", "
+ response.getBody().toString());
}
+ return response;
} catch (BackendFunctionalException e) {
LOGGER.error("error on calling " + callUrl + " ," + e);
+ return null;
}
}
LOGGER.debug("response body : " + response.getBody().toString());
LOGGER.info("response status : " + response.getStatusCodeValue());
if (!response.getStatusCode().equals(HttpStatus.OK)) {
- LOGGER.warn("HTTP call on " + callURL + " returns " + response.getStatusCodeValue() + ", "
+ LOGGER.error("HTTP call on " + callURL + " returns " + response.getStatusCodeValue() + ", "
+ response.getBody().toString());
}
return response;
import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
import org.onap.nbi.apis.serviceorder.model.StateType;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.workflow.CheckOrderConsistenceManager;
import org.onap.nbi.apis.serviceorder.workflow.CreateAAICustomerManager;
@Autowired
SOTaskManager serviceOrchestratorManager;
- @Autowired
- ServiceOrderInfoRepository serviceOrderInfoRepository;
-
@Autowired
MultiCriteriaRequestBuilder multiCriteriaRequestBuilder;
headers.add("X-Total-Count", String.valueOf(totalCount));
headers.add("X-Result-Count", String.valueOf(serviceOrders.size()));
- ResponseEntity<Object> response = this.findResponse(serviceOrders, filter, headers);
- return response;
+ return this.findResponse(serviceOrders, filter, headers);
}
changeServiceOrderState(serviceOrder, StateType.COMPLETED);
} else {
serviceOrderRepository.save(serviceOrder);
- createAAICustomer.createAAICustomer(serviceOrderInfo);
- createAAIServiceType.createAAIServiceType(serviceOrder, serviceOrderInfo);
- serviceOrchestratorManager.registerServiceOrder(serviceOrder, serviceOrderInfo);
+ createAAICustomer.createAAICustomer(serviceOrder,serviceOrderInfo);
+ if(StateType.ACKNOWLEDGED==serviceOrder.getState()) {
+ createAAIServiceType.createAAIServiceType(serviceOrder, serviceOrderInfo);
+ if(StateType.ACKNOWLEDGED==serviceOrder.getState()) {
+ serviceOrchestratorManager.registerServiceOrder(serviceOrder, serviceOrderInfo);
+ }
+ }
+
}
}
}
/**
- * Copyright (c) 2018 Orange
+ * Copyright (c) 2018 Orange
*
- * 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
+ * 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
+ * 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.
+ * 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.
*/
package org.onap.nbi.apis.serviceorder.model.orchestrator;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
-import javax.persistence.OneToOne;
+import javax.persistence.Lob;
@Entity
public class ExecutionTask {
private Date lastAttemptDate;
- @OneToOne
- private ServiceOrderInfoJson serviceOrderInfoJson;
+ @Lob
+ private String serviceOrderInfoJson;
- public ServiceOrderInfoJson getServiceOrderInfoJson() {
+ public String getServiceOrderInfoJson() {
return serviceOrderInfoJson;
}
- public void setServiceOrderInfoJson(ServiceOrderInfoJson serviceOrderInfoJson) {
+ public void setServiceOrderInfoJson(String serviceOrderInfoJson) {
this.serviceOrderInfoJson = serviceOrderInfoJson;
}
@Override
public boolean equals(Object o) {
- if (this == o)
+ if (this == o) {
return true;
- if (o == null || getClass() != o.getClass())
+ }
+ if (o == null || getClass() != o.getClass()) {
return false;
+ }
ExecutionTask that = (ExecutionTask) o;
return nbRetries == that.nbRetries && Objects.equals(internalId, that.internalId)
- && Objects.equals(orderItemId, that.orderItemId) && Objects.equals(reliedTasks, that.reliedTasks)
- && Objects.equals(lastAttemptDate, that.lastAttemptDate)
- && Objects.equals(serviceOrderInfoJson, that.serviceOrderInfoJson);
+ && Objects.equals(orderItemId, that.orderItemId) && Objects.equals(reliedTasks, that.reliedTasks)
+ && Objects.equals(lastAttemptDate, that.lastAttemptDate)
+ && Objects.equals(serviceOrderInfoJson, that.serviceOrderInfoJson);
}
@Override
private boolean useServiceOrderCustomer;
private SubscriberInfo subscriberInfo;
private Map<String, ServiceOrderItemInfo> serviceOrderItemInfos = new HashMap<>();
- private boolean allItemsInAdd;
+ private boolean allItemsInAdd= true;
private boolean allItemsCompleted;
- private boolean serviceOrderRejected;
+ private boolean serviceOrderRejected= false;
+ private String serviceOrderId;
+
+ public String getServiceOrderId() {
+ return serviceOrderId;
+ }
+
+ public void setServiceOrderId(String serviceOrderId) {
+ this.serviceOrderId = serviceOrderId;
+ }
public boolean isAllItemsInAdd() {
return allItemsInAdd;
+++ /dev/null
-/**
- * Copyright (c) 2018 Orange
- *
- * 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.
- */
-package org.onap.nbi.apis.serviceorder.model.orchestrator;
-
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-
-@Entity
-public class ServiceOrderInfoJson {
-
- @Id
- @GeneratedValue(strategy = GenerationType.AUTO)
- private Long internalId;
-
- private String serviceOrderId;
-
- @Lob
- private String serviceOrderInfoJson;
-
- public ServiceOrderInfoJson() {}
-
- public ServiceOrderInfoJson(String serviceOrderId, String serviceOrderInfoJson) {
- this.serviceOrderId = serviceOrderId;
- this.serviceOrderInfoJson = serviceOrderInfoJson;
- }
-
- public String getServiceOrderId() {
- return serviceOrderId;
- }
-
- public void setServiceOrderId(String serviceOrderId) {
- this.serviceOrderId = serviceOrderId;
- }
-
- public String getServiceOrderInfoJson() {
- return serviceOrderInfoJson;
- }
-
- public void setServiceOrderInfoJson(String serviceOrderInfoJson) {
- this.serviceOrderInfoJson = serviceOrderInfoJson;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2018 Orange
- *
- * 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.
- */
-package org.onap.nbi.apis.serviceorder.repositories;
-
-
-import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfoJson;
-import org.springframework.data.repository.CrudRepository;
-
-public interface ServiceOrderInfoRepository extends CrudRepository<ServiceOrderInfoJson, String> {
-
-}
/**
- * Copyright (c) 2018 Orange
- * <p>
- * 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
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * 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.
+ * Copyright (c) 2018 Orange <p> 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 <p>
+ * http://www.apache.org/licenses/LICENSE-2.0 <p> 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.
*/
package org.onap.nbi.apis.serviceorder.workflow;
+import java.util.LinkedHashMap;
import org.onap.nbi.apis.serviceorder.MultiClient;
import org.onap.nbi.apis.serviceorder.model.RelatedParty;
import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
-import java.util.LinkedHashMap;
-
@Service
public class CheckOrderConsistenceManager {
@Autowired
private MultiClient serviceOrderConsumerService;
+ private static final Logger LOGGER = LoggerFactory.getLogger(CheckOrderConsistenceManager.class);
+
public ServiceOrderInfo checkServiceOrder(ServiceOrder serviceOrder) {
ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
+ serviceOrderInfo.setServiceOrderId(serviceOrder.getId());
manageCustomer(serviceOrder, serviceOrderInfo);
int nbItemsCompleted = 0;
- boolean isServiceOrderRejected = false;
- boolean isAllItemsInAdd = true;
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
ServiceOrderItemInfo serviceOrderItemInfo = new ServiceOrderItemInfo();
- serviceOrderItemInfo.setId(serviceOrderItem.getId());
handleServiceFromCatalog(serviceOrderItem, serviceOrderItemInfo);
- switch (serviceOrderItem.getAction()) {
- case ADD:
- if (existServiceInCatalog(serviceOrderItemInfo)
- && StringUtils.isEmpty(serviceOrderItem.getService().getId())
- && serviceOrderConsumerService.isTenantIdPresentInAAI()) {
- serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
- } else {
- isServiceOrderRejected = true;
- serviceOrderItem.setState(StateType.REJECTED);
- }
- break;
- case MODIFY:
- case DELETE:
- isAllItemsInAdd = false;
- if (isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo)
- && existServiceInInventory(serviceOrderItem, serviceOrderItemInfo,
- serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
- serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
- } else {
- isServiceOrderRejected = true;
- serviceOrderItem.setState(StateType.REJECTED);
- }
- break;
- case NOCHANGE:
- isAllItemsInAdd = false;
- serviceOrderItem.setState(StateType.COMPLETED);
- nbItemsCompleted++;
- break;
+ if (!existServiceInCatalog(serviceOrderItemInfo)) {
+ serviceOrderInfo.setIsServiceOrderRejected(true);
+ serviceOrderItem.setState(StateType.REJECTED);
+ LOGGER.error(
+ "service order item {0} of service order {1} rejected cause no service catalog found for id {2}",
+ serviceOrderItem.getId(), serviceOrder.getId(),
+ serviceOrderItem.getService().getServiceSpecification().getId());
+ } else {
+ switch (serviceOrderItem.getAction()) {
+ case ADD:
+ handleServiceOrderItemInAdd(serviceOrderInfo, serviceOrderItem, serviceOrderItemInfo);
+ break;
+ case MODIFY:
+ case DELETE:
+ handleServiceOrderItemInChange(serviceOrderInfo, serviceOrderItem, serviceOrderItemInfo);
+ break;
+ case NOCHANGE:
+ serviceOrderInfo.setAllItemsInAdd(false);
+ serviceOrderItem.setState(StateType.COMPLETED);
+ nbItemsCompleted++;
+ break;
+ }
}
+
}
+
if (serviceOrder.getOrderItem().size() != nbItemsCompleted) {
serviceOrderInfo.setAllItemsCompleted(false);
} else {
serviceOrderInfo.setAllItemsCompleted(true);
}
- serviceOrderInfo.setAllItemsInAdd(isAllItemsInAdd);
- serviceOrderInfo.setIsServiceOrderRejected(isServiceOrderRejected);
return serviceOrderInfo;
}
+ private void handleServiceOrderItemInChange(ServiceOrderInfo serviceOrderInfo, ServiceOrderItem serviceOrderItem,
+ ServiceOrderItemInfo serviceOrderItemInfo) {
+ serviceOrderInfo.setAllItemsInAdd(false);
+ if (shouldAcceptServiceOrderItemToChange(serviceOrderInfo, serviceOrderItem,
+ serviceOrderItemInfo)) {
+ serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
+ } else {
+ serviceOrderInfo.setIsServiceOrderRejected(true);
+ serviceOrderItem.setState(StateType.REJECTED);
+ }
+ }
+
+ private void handleServiceOrderItemInAdd(ServiceOrderInfo serviceOrderInfo, ServiceOrderItem serviceOrderItem,
+ ServiceOrderItemInfo serviceOrderItemInfo) {
+ if (shouldAcceptServiceOrderItemToAdd(serviceOrderItem, serviceOrderInfo.getServiceOrderId())) {
+ serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
+ } else {
+ serviceOrderInfo.setIsServiceOrderRejected(true);
+ serviceOrderItem.setState(StateType.REJECTED);
+ }
+ }
+
+ private boolean shouldAcceptServiceOrderItemToAdd(ServiceOrderItem serviceOrderItem,
+ String serviceOrderId) {
+ if (!StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
+ LOGGER
+ .error("serviceOrderItem {0} for serviceorder {1} rejected cause service.id must be empty in add action",
+ serviceOrderItem.getId(), serviceOrderId);
+ return false;
+ } else if (!serviceOrderConsumerService.isTenantIdPresentInAAI()) {
+ LOGGER.error("serviceOrderItem {0} for serviceOrder {1} rejected cause tenantId not found in AAI",
+ serviceOrderItem.getId(), serviceOrderId);
+ return false;
+ }
+ return true;
+ }
+
+ private boolean shouldAcceptServiceOrderItemToChange(ServiceOrderInfo serviceOrderInfo,
+ ServiceOrderItem serviceOrderItem,
+ ServiceOrderItemInfo serviceOrderItemInfo) {
+
+ if (StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
+ LOGGER.error(
+ "serviceOrderItem {0} for serviceOrder {1} rejected cause service.id is mandatory in delete/change action",
+ serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
+ return false;
+ } else if (!isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo)) {
+ LOGGER
+ .error("serviceOrderItem {0} for serviceOrder {1} rejected cause customer not found in inventory",
+ serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
+ return false;
+ } else if (!existServiceInInventory(serviceOrderItem, serviceOrderItemInfo,
+ serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
+ LOGGER
+ .error("serviceOrderItem {0} for serviceOrder {1} rejected cause service id {2} not found in inventory",
+ serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId(),
+ serviceOrderItem.getService().getId());
+ return false;
+ }
+ return true;
+ }
+
private void manageCustomer(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
RelatedParty customerFromServiceOrder = getCustomerFromServiceOrder(serviceOrder);
SubscriberInfo subscriberInfo = new SubscriberInfo();
private boolean isCustomerFromServiceOrderPresentInInventory(ServiceOrderInfo serviceOrderInfo) {
if (serviceOrderInfo.isUseServiceOrderCustomer()) {
-
- boolean customerPresentInAAI = serviceOrderConsumerService
- .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
- return customerPresentInAAI;
+ return serviceOrderConsumerService
+ .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
}
return true;
}
private boolean existServiceInInventory(ServiceOrderItem serviceOrderItem,
- ServiceOrderItemInfo serviceOrderItemInfo, String globalSubscriberId) {
- if (!StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
- String serviceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
- boolean serviceExistInInventory = serviceOrderConsumerService.doesServiceExistInServiceInventory(
- serviceOrderItem.getService().getId(), serviceName, globalSubscriberId);
- if (serviceExistInInventory) {
- return true;
- }
- }
- return false;
+ ServiceOrderItemInfo serviceOrderItemInfo, String globalSubscriberId) {
+ String serviceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
+ return serviceOrderConsumerService.doesServiceExistInServiceInventory(
+ serviceOrderItem.getService().getId(), serviceName, globalSubscriberId);
}
private boolean existServiceInCatalog(ServiceOrderItemInfo serviceOrderItemInfo) {
}
private void handleServiceFromCatalog(ServiceOrderItem serviceOrderItem,
- ServiceOrderItemInfo serviceOrderItemInfo) {
+ ServiceOrderItemInfo serviceOrderItemInfo) {
ResponseEntity<Object> response = serviceOrderConsumerService
- .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId());
+ .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId());
if (response != null && (response.getStatusCode().equals(HttpStatus.OK)
- || response.getStatusCode().equals(HttpStatus.PARTIAL_CONTENT))) {
+ || response.getStatusCode().equals(HttpStatus.PARTIAL_CONTENT))) {
LinkedHashMap body = (LinkedHashMap) response.getBody();
serviceOrderItemInfo.setCatalogResponse(body);
+ } else {
+ LOGGER.error("unable to retrieve catalog information for service {0}",
+ serviceOrderItem.getService().getServiceSpecification().getId());
}
}
/**
- * Copyright (c) 2018 Orange
+ * Copyright (c) 2018 Orange
*
- * 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
+ * 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
+ * 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.
+ * 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.
*/
package org.onap.nbi.apis.serviceorder.workflow;
+import java.util.Date;
import org.onap.nbi.apis.serviceorder.MultiClient;
+import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
+import org.onap.nbi.apis.serviceorder.model.StateType;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
+import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Autowired
private MultiClient serviceOrderConsumerService;
+ @Autowired
+ ServiceOrderRepository serviceOrderRepository;
- public void createAAICustomer(ServiceOrderInfo serviceOrderInfo) {
+ private static final Logger LOGGER = LoggerFactory.getLogger(CreateAAICustomerManager.class);
+ public void createAAICustomer(ServiceOrder serviceOrder,
+ ServiceOrderInfo serviceOrderInfo) {
if (serviceOrderInfo.isUseServiceOrderCustomer() && serviceOrderInfo.isAllItemsInAdd()
- && !serviceOrderConsumerService
- .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
- serviceOrderConsumerService.putCustomer(serviceOrderInfo.getSubscriberInfo());
+ && !serviceOrderConsumerService
+ .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
+
+ boolean customerCreated = serviceOrderConsumerService.putCustomer(serviceOrderInfo.getSubscriberInfo());
+ if (!customerCreated) {
+ serviceOrder.setState(StateType.REJECTED);
+ serviceOrder.setCompletionDateTime(new Date());
+ serviceOrderRepository.save(serviceOrder);
+ LOGGER.error("serviceOrder {0} rejected : cannot create customer", serviceOrder.getId());
+ }
}
}
/**
- * Copyright (c) 2018 Orange
+ * Copyright (c) 2018 Orange
*
- * 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
+ * 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
+ * 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.
+ * 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.
*/
package org.onap.nbi.apis.serviceorder.workflow;
+import java.util.Date;
import org.onap.nbi.apis.serviceorder.MultiClient;
import org.onap.nbi.apis.serviceorder.model.ActionType;
import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
+import org.onap.nbi.apis.serviceorder.model.StateType;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
+import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.LinkedHashMap;
@Autowired
private MultiClient serviceOrderConsumerService;
+ @Autowired
+ ServiceOrderRepository serviceOrderRepository;
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(CreateAAIServiceTypeManager.class);
public void createAAIServiceType(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
LinkedHashMap servicesInAaiForCustomer = serviceOrderConsumerService
- .getServicesInAaiForCustomer(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
+ .getServicesInAaiForCustomer(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
if (ActionType.ADD == serviceOrderItem.getAction()) {
ServiceOrderItemInfo serviceOrderItemInfo =
- serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId());
+ serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId());
String sdcServiceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
if (!serviceNameExistsInAAI(servicesInAaiForCustomer, sdcServiceName)) {
- serviceOrderConsumerService.putServiceType(
- serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), sdcServiceName);
+ boolean serviceCreated = serviceOrderConsumerService.putServiceType(
+ serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), sdcServiceName);
+ if (!serviceCreated) {
+ serviceOrder.setState(StateType.REJECTED);
+ serviceOrder.setCompletionDateTime(new Date());
+ serviceOrderRepository.save(serviceOrder);
+ LOGGER.error("serviceOrder {0} rejected : cannot create customer", serviceOrder.getId());
+ }
}
}
}
if (servicesInAaiForCustomer != null && servicesInAaiForCustomer.get("service-subscription") != null) {
List<LinkedHashMap> servicesInAAI =
- (List<LinkedHashMap>) servicesInAaiForCustomer.get("service-subscription");
+ (List<LinkedHashMap>) servicesInAaiForCustomer.get("service-subscription");
for (LinkedHashMap service : servicesInAAI) {
String serviceType = (String) service.get("service-type");
if (sdcServiceName.equalsIgnoreCase(serviceType)) {
/**
* Copyright (c) 2018 Orange
*
- * 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
+ * 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.
+ * 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.
*/
package org.onap.nbi.apis.serviceorder.workflow;
import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
-import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfoJson;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Autowired
private ExecutionTaskRepository executionTaskRepository;
- @Autowired
- private ServiceOrderInfoRepository serviceOrderInfoRepository;
-
@Autowired
private SOTaskProcessor soTaskProcessor;
* @param serviceOrderInfoJson
*/
private void registerOrderItemExecutionPlan(List<ServiceOrderItem> orderItems,
- ServiceOrderInfoJson serviceOrderInfoJson) {
+ String serviceOrderInfoJson) {
List<ExecutionTask> executionTasksSaved = new ArrayList<>();
Map<String, Long> internalIdOrderItemsMap = new HashMap<>();
if (orderItems != null) {
for (ExecutionTask executionTask : executionTasksSaved) {
for (String key : internalIdOrderItemsMap.keySet()) {
String replace = executionTask.getReliedTasks().replace(key,
- String.valueOf(internalIdOrderItemsMap.get(key)));
+ String.valueOf(internalIdOrderItemsMap.get(key)));
executionTask.setReliedTasks(replace);
}
executionTaskRepository.save(executionTask);
* @param serviceOrderInfo
*/
public void registerServiceOrder(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
- String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
- ServiceOrderInfoJson serviceOrderInfoJson = new ServiceOrderInfoJson(serviceOrder.getId(), json);
- serviceOrderInfoRepository.save(serviceOrderInfoJson);
+ String serviceOrderInfoJson = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
registerOrderItemExecutionPlan(serviceOrder.getOrderItem(), serviceOrderInfoJson);
}
/**
* Copyright (c) 2018 Orange
*
- * 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
+ * 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.
+ * 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.
*/
package org.onap.nbi.apis.serviceorder.workflow;
import org.onap.nbi.apis.serviceorder.model.consumer.*;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
-import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfoJson;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
+import org.onap.nbi.exceptions.TechnicalException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
public void processOrderItem(ExecutionTask executionTask) throws InterruptedException {
- ServiceOrderInfoJson serviceOrderInfoJson = executionTask.getServiceOrderInfoJson();
- ServiceOrder serviceOrder = serviceOrderRepository.findOne(serviceOrderInfoJson.getServiceOrderId());
- ServiceOrderItem serviceOrderItem = null;
- for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
- if (item.getId().equals(executionTask.getOrderItemId())) {
- serviceOrderItem = item;
- }
- }
+ ServiceOrderInfo serviceOrderInfo = getServiceOrderInfo(executionTask);
+
+
+ ServiceOrder serviceOrder = serviceOrderRepository.findOne(serviceOrderInfo.getServiceOrderId());
+ ServiceOrderItem serviceOrderItem = getServiceOrderItem(executionTask, serviceOrder);
- ServiceOrderInfo serviceOrderInfo = null;
- try {
- serviceOrderInfo =
- JsonEntityConverter.convertJsonToServiceOrderInfo(serviceOrderInfoJson.getServiceOrderInfoJson());
- } catch (IOException e) {
- LOGGER.warn("Unable to read ServiceOrderInfo Json for serviceOrderId " + serviceOrder.getId(), e);
- }
if (serviceOrderItem != null && StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
- ResponseEntity<CreateServiceInstanceResponse> response = null;
- try {
- response = postSORequest(serviceOrderItem, serviceOrderInfo);
- } catch (NullPointerException e) {
- LOGGER.warn("Enable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
- response = null;
- }
+ ResponseEntity<CreateServiceInstanceResponse> response = postServiceOrderItem(serviceOrderInfo,
+ serviceOrderItem);
if (response == null) {
LOGGER.warn("response=null for serviceOrderItem.id=" + serviceOrderItem.getId());
serviceOrderItem.setState(StateType.FAILED);
} else {
- updateServiceOrderItem(response.getBody(), serviceOrderItem);
+ updateServiceOrderItem(response, serviceOrderItem);
+
- if (response.getStatusCode() != HttpStatus.CREATED || response.getBody() == null
- || response.getBody().getRequestReferences() == null) {
- serviceOrderItem.setState(StateType.FAILED);
- } else {
- serviceOrderItem.setState(StateType.INPROGRESS);
- }
}
}
- if (executionTask.getNbRetries() > 0) {
+ if (executionTask.getNbRetries() > 0 && StateType.FAILED != serviceOrderItem.getState()
+ ) {
// TODO lancer en asynchrone
pollSoRequestStatus(serviceOrderItem);
if (serviceOrderItem.getState().equals(StateType.COMPLETED)) {
updateFailedTask(executionTask, serviceOrder);
}
-
updateServiceOrder(serviceOrder);
}
+ private ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
+ ServiceOrderItem serviceOrderItem) {
+ ResponseEntity<CreateServiceInstanceResponse> response = null;
+ try {
+ response = postSORequest(serviceOrderItem, serviceOrderInfo);
+ } catch (NullPointerException e) {
+ LOGGER.warn("Enable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
+ response = null;
+ }
+ return response;
+ }
+
+ private ServiceOrderItem getServiceOrderItem(ExecutionTask executionTask, ServiceOrder serviceOrder) {
+ ServiceOrderItem serviceOrderItem = null;
+ for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
+ if (item.getId().equals(executionTask.getOrderItemId())) {
+ serviceOrderItem = item;
+ }
+ }
+ return serviceOrderItem;
+ }
+
+ private ServiceOrderInfo getServiceOrderInfo(ExecutionTask executionTask) {
+ String serviceOrderInfoJson = executionTask.getServiceOrderInfoJson();
+ ServiceOrderInfo serviceOrderInfo = null;
+ try {
+ serviceOrderInfo =
+ JsonEntityConverter.convertJsonToServiceOrderInfo(serviceOrderInfoJson);
+ } catch (IOException e) {
+ LOGGER.error("Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId(), e);
+ throw new TechnicalException("Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId());
+ }
+ return serviceOrderInfo;
+ }
+
private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
- ServiceOrderInfo serviceOrderInfo) {
+ ServiceOrderInfo serviceOrderInfo) {
RequestDetails requestDetails = buildSoRequest(serviceOrderItem,
- serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
- serviceOrderInfo.getSubscriberInfo());
+ serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
+ serviceOrderInfo.getSubscriberInfo());
MSOPayload msoPayload = new MSOPayload(requestDetails);
ResponseEntity<CreateServiceInstanceResponse> response = null;
boolean atLeastOneNotFinished = false;
boolean atLeastOneFailed = false;
-
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
switch (serviceOrderItem.getState()) {
case COMPLETED:
* @return
*/
private RequestDetails buildSoRequest(ServiceOrderItem orderItem, LinkedHashMap<String, Object> sdcInfos,
- SubscriberInfo subscriberInfo) {
+ SubscriberInfo subscriberInfo) {
RequestDetails requestDetails = new RequestDetails();
requestDetails.setSubscriberInfo(subscriberInfo);
RequestParameters requestParameters = new RequestParameters();
requestParameters.setSubscriptionServiceType((String) sdcInfos.get("name"));
requestParameters.setUserParams(
- retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
+ retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
requestParameters.setaLaCarte(true);
requestDetails.setRequestParameters(requestParameters);
if (!CollectionUtils.isEmpty(characteristics)) {
for (ServiceCharacteristic characteristic : characteristics) {
UserParams userParam = new UserParams(characteristic.getName(),
- characteristic.getValue().getServiceCharacteristicValue());
+ characteristic.getValue().getServiceCharacteristicValue());
userParams.add(userParam);
}
}
/**
* Update ServiceOrderItem with SO response by using serviceOrderRepository with the serviceOrderId
*
- * @param createServiceInstanceResponse
+ * @param response
* @param orderItem
*/
- private void updateServiceOrderItem(CreateServiceInstanceResponse createServiceInstanceResponse,
- ServiceOrderItem orderItem) {
+ private void updateServiceOrderItem(ResponseEntity<CreateServiceInstanceResponse> response,
+ ServiceOrderItem orderItem) {
+ CreateServiceInstanceResponse createServiceInstanceResponse=response.getBody();
if (createServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) {
orderItem.getService().setId(createServiceInstanceResponse.getRequestReferences().getInstanceId());
orderItem.setRequestId(createServiceInstanceResponse.getRequestReferences().getRequestId());
}
+
+ if (response.getStatusCode() != HttpStatus.CREATED || response.getBody() == null
+ || response.getBody().getRequestReferences() == null) {
+ orderItem.setState(StateType.FAILED);
+ } else {
+ orderItem.setState(StateType.INPROGRESS);
+ }
}
/**
private void updateSuccessTask(ExecutionTask executionTask) {
executionTaskRepository.delete(executionTask.getInternalId());
executionTaskRepository.updateReliedTaskAfterDelete(executionTask.getInternalId());
+
}
/**
for (ExecutionTask taskId : executionTasksToDelete) {
executionTaskRepository.delete(taskId);
}
-
for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
for (ExecutionTask taskToDelete : executionTasksToDelete) {
if (taskToDelete.getOrderItemId().equals(item.getId())) {
List<ExecutionTask> executionTasks = new ArrayList<>();
List<ExecutionTask> tasksReliedToAnOrderItemId =
- executionTaskRepository.findTasksReliedToAnOrderItemId(executionTask.getInternalId());
+ executionTaskRepository.findTasksReliedToAnOrderItemId(executionTask.getInternalId());
if (CollectionUtils.isEmpty(tasksReliedToAnOrderItemId)) {
return Arrays.asList(executionTask);
import org.onap.nbi.apis.serviceorder.model.StateType;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
import org.springframework.beans.factory.annotation.Autowired;
@Autowired
ServiceOrderRepository serviceOrderRepository;
- @Autowired
- ServiceOrderInfoRepository serviceOrderInfoRepository;
-
@Autowired
ExecutionTaskRepository executionTaskRepository;
@After
public void tearsDownUpPort() throws Exception {
executionTaskRepository.deleteAll();
- serviceOrderInfoRepository.deleteAll();
serviceOrderRepository.deleteAll();
wireMockServer.resetToDefaultMappings();
return null;
}
+ private void removeWireMockMapping(String s) {
+ ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
+ StubMapping mappingToDelete = null;
+ List<StubMapping> mappings = listStubMappingsResult.getMappings();
+ for (StubMapping mapping : mappings) {
+ if (mapping.getRequest().getUrl().equals(s)) {
+ mappingToDelete = mapping;
+ }
+ }
+ wireMockServer.removeStubMapping(mappingToDelete);
+ }
+
// serviceCatalog
@Test
}
@Test
- public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
+ public void testCheckServiceOrderWithUnKnownCustomer() throws Exception {
ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
List<RelatedParty> customers = new ArrayList<>();
}
+
+ @Test
+ public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
+
+ removeWireMockMapping("/aai/v11/business/customers/customer/new");
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ }
+
+
+ @Test
+ public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
+
+ removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ }
+
+
@Test
public void testCheckServiceOrderDelete() throws Exception {
}
+ @Test
+ public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().getServiceSpecification().setId("undefined");
+ }
+
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A"))
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
+ }
+ }
+
+
+
@Test
public void testCheckServiceOrderRejected() throws Exception {
public void testExecutionTaskSuccess() throws Exception {
ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
+ executionTaskRepository, ActionType.ADD);
ExecutionTask executionTaskB;
public void testExecutionTaskDeleteSuccess() throws Exception {
ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
+ executionTaskRepository, ActionType.DELETE);
ExecutionTask executionTaskB;
public void testExecutionTaskFailed() throws Exception {
ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
+ executionTaskRepository, ActionType.ADD);
- ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
- StubMapping mappingToDelete = null;
- List<StubMapping> mappings = listStubMappingsResult.getMappings();
- for (StubMapping mapping : mappings) {
- if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
- mappingToDelete = mapping;
- }
- }
- wireMockServer.removeStubMapping(mappingToDelete);
+ removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v4/requestId");
SoTaskProcessor.processOrderItem(executionTaskA);
}
+
+
+
+ @Test
+ public void testExecutionTaskFailedNoSoResponse() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+ removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v4");
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+ }
+
+ ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
+ assertThat(executionTaskB).isNull();
+
+
+ }
+
+
}
import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
-import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfoJson;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
- ServiceOrderInfoRepository serviceOrderInfoRepository, ExecutionTaskRepository executionTaskRepository,
- ActionType actionType) {
+ ExecutionTaskRepository executionTaskRepository,
+ ActionType actionType) {
ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
sdcResponse.put("version", "v1");
ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
-
+ serviceOrderInfo.setServiceOrderId("test");
SubscriberInfo subscriberInfo = new SubscriberInfo();
subscriberInfo.setGlobalSubscriberId("6490");
subscriberInfo.setSubscriberName("edgar");
serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
- ServiceOrderInfoJson serviceOrderInfoJson = new ServiceOrderInfoJson("test", json);
- serviceOrderInfoRepository.save(serviceOrderInfoJson);
ExecutionTask executionTaskA = new ExecutionTask();
executionTaskA.setNbRetries(3);
executionTaskA.setOrderItemId("A");
- executionTaskA.setServiceOrderInfoJson(serviceOrderInfoJson);
+ executionTaskA.setServiceOrderInfoJson(json);
executionTaskA = executionTaskRepository.save(executionTaskA);
ExecutionTask executionTaskB = new ExecutionTask();
executionTaskB.setNbRetries(3);
executionTaskB.setOrderItemId("B");
executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
- executionTaskB.setServiceOrderInfoJson(serviceOrderInfoJson);
+ executionTaskB.setServiceOrderInfoJson(json);
executionTaskRepository.save(executionTaskB);
return executionTaskA;
}
Code Review / externalapi / nbi.git / commitdiff