import java.util.Map;
import java.util.Map.Entry;
import org.onap.nbi.OnapComponentsUrlPaths;
+import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
+import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
+import org.onap.nbi.apis.serviceorder.service.ServiceOrderService;
import org.onap.nbi.exceptions.BackendFunctionalException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Autowired
private ServiceInventoryUrl serviceInventoryUrl;
+ @Autowired
+ private ServiceOrderService serviceOrderService;
+
private static final String HEADER_AUTHORIZATION = "Authorization";
private static final String X_FROM_APP_ID = "X-FromAppId";
private static final Logger LOGGER = LoggerFactory.getLogger(MultiClient.class);
- public ResponseEntity<Object> getServiceCatalog(String id) {
+ public Map getServiceCatalog(String id,ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem){
StringBuilder callURL = new StringBuilder().append(serviceCatalogUrl.getServiceCatalogUrl()).append(id);
- return callApiGet(callURL.toString(), new HttpHeaders(), null);
+ ResponseEntity<Object> response = callApiGet(callURL.toString(), new HttpHeaders(), null);
+
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "500");
+ LOGGER.warn("unable to retrieve catalog information for service {}",
+ serviceOrderItem.getService().getServiceSpecification().getId());
+ }
+ if (response.getStatusCode().is2xxSuccessful()) {
+ return (LinkedHashMap) response.getBody();
+ }
+ return null;
+
}
- public boolean doesServiceExistInServiceInventory(String id, String serviceName, String globalSubscriberId) {
+ public boolean doesServiceExistInServiceInventory(String id, String serviceName, String globalSubscriberId, ServiceOrder serviceOrder) {
StringBuilder callURL = new StringBuilder().append(serviceInventoryUrl.getServiceInventoryUrl()).append(id);
Map<String, String> param = new HashMap<>();
param.put("serviceSpecification.name", serviceName);
param.put("relatedParty.id", globalSubscriberId);
ResponseEntity<Object> response = callApiGet(callURL.toString(), new HttpHeaders(), param);
- return response != null && response.getStatusCode().equals(HttpStatus.OK);
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+ return false;
+ }
+ return response.getStatusCode().equals(HttpStatus.OK);
}
}
- public boolean isTenantIdPresentInAAI() {
+ public boolean isTenantIdPresentInAAI(ServiceOrder serviceOrder) {
StringBuilder callURL = new StringBuilder().append(aaiHost).append(OnapComponentsUrlPaths.AAI_GET_TENANTS_PATH);
String callUrlFormated = callURL.toString().replace("$onap.lcpCloudRegionId", lcpCloudRegionId);
callUrlFormated = callUrlFormated.replace("$onap.cloudOwner", cloudOwner);
ResponseEntity<Object> response = callApiGet(callUrlFormated, buildRequestHeaderForAAI(), null);
- if (response != null) {
+ if (response.getStatusCode().is2xxSuccessful()) {
LinkedHashMap body = (LinkedHashMap) response.getBody();
List<LinkedHashMap> tenants = (List<LinkedHashMap>) body.get("tenant");
for (LinkedHashMap tenant : tenants) {
return true;
}
}
+ } else {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
}
return false;
}
- public boolean isCustomerPresentInAAI(String customerId) {
+ public boolean isCustomerPresentInAAI(String customerId,
+ ServiceOrder serviceOrder) {
StringBuilder callURL = new StringBuilder().append(aaiHost).append(OnapComponentsUrlPaths.AAI_GET_CUSTOMER_PATH)
.append(customerId);
ResponseEntity<Object> response = callApiGet(callURL.toString(), buildRequestHeaderForAAI(), null);
- return(response != null && response.getStatusCode().equals(HttpStatus.OK));
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+ return false;
+ }
+ return response.getStatusCode().equals(HttpStatus.OK);
}
- public boolean putCustomer(SubscriberInfo subscriberInfo) {
+ public boolean putCustomer(SubscriberInfo subscriberInfo,
+ ServiceOrder serviceOrder) {
Map<String, String> param = new HashMap<>();
param.put("global-customer-id", subscriberInfo.getGlobalSubscriberId());
param.put("subscriber-name", subscriberInfo.getSubscriberName());
aaiHost + OnapComponentsUrlPaths.AAI_GET_CUSTOMER_PATH + subscriberInfo.getGlobalSubscriberId();
ResponseEntity<Object> response = putRequest(param, callURL, buildRequestHeaderForAAI());
- return response != null && response.getStatusCode().equals(HttpStatus.CREATED);
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+ return false;
+ }
+ return response.getStatusCode().equals(HttpStatus.CREATED);
}
- public Map getServicesInAaiForCustomer(String customerId) {
+ public Map getServicesInAaiForCustomer(String customerId,
+ ServiceOrder serviceOrder) {
StringBuilder callURL =
new StringBuilder().append(aaiHost).append(OnapComponentsUrlPaths.AAI_GET_SERVICES_FOR_CUSTOMER_PATH);
String callUrlFormated = callURL.toString().replace("$customerId", customerId);
ResponseEntity<Object> response = callApiGet(callUrlFormated, buildRequestHeaderForAAI(), null);
- if (response != null && response.getStatusCode().equals(HttpStatus.OK)) {
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+ return null;
+ }
+ else if (response.getStatusCode().is2xxSuccessful()) {
return (LinkedHashMap) response.getBody();
}
return null;
}
- public boolean putServiceType(String globalSubscriberId, String serviceName) {
+ public boolean putServiceType(String globalSubscriberId, String serviceName,
+ ServiceOrder serviceOrder) {
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.replace("$customerId", globalSubscriberId);
ResponseEntity<Object> response = putRequest(param, callUrlFormated, buildRequestHeaderForAAI());
- return response != null && response.getStatusCode().equals(HttpStatus.CREATED);
+ if(response.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+ }
+ return response.getStatusCode().is2xxSuccessful();
}
LOGGER.warn("HTTP call on {} returns {} , {}", callUrl , response.getStatusCodeValue(), response.getBody().toString());
}
return response;
- } catch (BackendFunctionalException|ResourceAccessException e) {
+ } catch (BackendFunctionalException e) {
LOGGER.error("error on calling " + callUrl + " ," + e);
- return null;
+ return new ResponseEntity<>("problem calling onap services", e.getHttpStatus());
+ }catch (ResourceAccessException e) {
+ LOGGER.error("error on calling " + callUrl + " ," + e);
+ return new ResponseEntity<>("unable to reach onap services", HttpStatus.INTERNAL_SERVER_ERROR);
}
}
private ResponseEntity<Object> callApiGet(String callURL, HttpHeaders httpHeaders, Map<String, String> param) {
-
-
try {
-
UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(callURL);
if (param != null) {
for (Entry<String, String> stringEntry : param.entrySet()) {
}
}
URI uri = builder.build().encode().toUri();
-
-
ResponseEntity<Object> response =
restTemplate.exchange(uri, HttpMethod.GET, new HttpEntity<>(httpHeaders), Object.class);
if(LOGGER.isDebugEnabled()){
}
return response;
- } catch (BackendFunctionalException|ResourceAccessException e) {
+ } catch (BackendFunctionalException e) {
LOGGER.error("error on calling " + callURL + " ," + e);
- return null;
+ return new ResponseEntity<>("problem calling onap services", e.getHttpStatus());
+ }catch (ResourceAccessException e) {
+ LOGGER.error("error on calling " + callURL + " ," + e);
+ return new ResponseEntity<>("unable to reach onap services", HttpStatus.INTERNAL_SERVER_ERROR);
}
+
}
/**
- * 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;
try {
ResponseEntity<CreateServiceInstanceResponse> response = restTemplate.exchange(url, HttpMethod.POST,
- new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
+ new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
logResponsePost(url, response);
return response;
- } catch (BackendFunctionalException|ResourceAccessException e) {
- LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
- return null;
+ } catch (BackendFunctionalException e) {
+ LOGGER.error("error on calling " + url + " ," + e);
+ return new ResponseEntity<>(e.getHttpStatus());
+ } catch (ResourceAccessException e) {
+ LOGGER.error("error on calling " + url + " ," + e);
+ return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
- public ResponseEntity<CreateServiceInstanceResponse> callDeleteServiceInstance(MSOPayload msoPayload,
- String serviceId) {
+ public ResponseEntity<CreateServiceInstanceResponse> callDeleteServiceInstance(MSOPayload msoPayload, String serviceId) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Calling SO DeleteServiceInstance with msoPayload : " + msoPayload.toString());
try {
ResponseEntity<CreateServiceInstanceResponse> response = restTemplate.exchange(url, HttpMethod.DELETE,
- new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
+ new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
logResponsePost(url, response);
return response;
- } catch (BackendFunctionalException|ResourceAccessException e) {
- LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
- return null;
+ } catch (BackendFunctionalException e) {
+ LOGGER.error("error on calling " + url + " ," + e);
+ return new ResponseEntity<>(e.getHttpStatus());
+ } catch (ResourceAccessException e) {
+ LOGGER.error("error on calling " + url + " ," + e);
+ return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
private void logResponsePost(String url, ResponseEntity<CreateServiceInstanceResponse> response) {
LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue());
- if(LOGGER.isDebugEnabled()){
+ if (LOGGER.isDebugEnabled()) {
LOGGER.debug("response body : {}", response.getBody().toString());
}
if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.CREATED)) {
- LOGGER.warn("HTTP call SO on {} returns {} , {}",url ,response.getStatusCodeValue(), response.getBody().toString());
+ LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
+ response.getBody().toString());
}
}
try {
ResponseEntity<GetRequestStatusResponse> response = restTemplate.exchange(url, HttpMethod.GET,
- new HttpEntity<>(buildRequestHeader()), GetRequestStatusResponse.class);
+ new HttpEntity<>(buildRequestHeader()), GetRequestStatusResponse.class);
logResponseGet(url, response);
return response.getBody();
- } catch (BackendFunctionalException|ResourceAccessException e) {
+ } catch (BackendFunctionalException | ResourceAccessException e) {
LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
return null;
}
}
private void logResponseGet(String url, ResponseEntity<GetRequestStatusResponse> response) {
- if(response!=null){
- if(LOGGER.isDebugEnabled()){
+ if (response != null) {
+ if (LOGGER.isDebugEnabled()) {
LOGGER.debug("response body : {}", response.getBody().toString());
}
LOGGER.info("response status : {}", response.getStatusCodeValue());
if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.OK)) {
- LOGGER.warn("HTTP call SO on {} returns {} , {}",url ,response.getStatusCodeValue(), response.getBody().toString());
+ LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
+ response.getBody().toString());
}
} else {
- LOGGER.info("no response calling url {}",url);
+ LOGGER.info("no response calling url {}", url);
}
}
--- /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.
+ */
+/*
+ * API ServiceOrder serviceOrder API designed for ONAP Beijing Release. This API is build from TMF
+ * open API16.5 + applied TMF guideline 3.0
+ *
+ * OpenAPI spec version: 0.1.1_inProgress
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git Do not edit the class manually.
+ *
+ * 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;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.Objects;
+import javax.validation.constraints.NotNull;
+
+/**
+ * An optional array of messages associated with the Order
+ */
+@ApiModel(description = "An optional array of messages associated with the Order")
+@javax.annotation.Generated(value = "io.swagger.codegen.languages.JavaJerseyServerCodegen",
+ date = "2018-07-12T11:46:30.345Z")
+public class OrderMessage {
+
+
+ @JsonProperty("code")
+ private String code = null;
+
+ @JsonProperty("field")
+ private String field = null;
+
+ @JsonProperty("messageInformation")
+ private String messageInformation = null;
+
+ @JsonProperty("severity")
+ private SeverityMessage severity = null;
+
+ @JsonProperty("correctionRequired")
+ private boolean correctionRequired;
+
+
+
+
+ /**
+ * A code associated to this message
+ *
+ * @return code
+ **/
+ @JsonProperty("code")
+ @ApiModelProperty(value = "A code associated to this message")
+ public String getCode() {
+ return code;
+ }
+
+ public void setCode(String code) {
+ this.code = code;
+ }
+
+ public OrderMessage code(String code) {
+ this.code = code;
+ return this;
+ }
+
+
+ /**
+ * Service Order attribute related to this error message
+ *
+ * @return field
+ **/
+ @JsonProperty("field")
+ @ApiModelProperty(value = "Service Order attribute related to this error message")
+ public String getField() {
+ return field;
+ }
+
+ public void setField(String field) {
+ this.field = field;
+ }
+
+ public OrderMessage field(String field) {
+ this.field = field;
+ return this;
+ }
+
+
+ /**
+ * Message related to this order
+ *
+ * @return messageInformation
+ **/
+ @JsonProperty("messageInformation")
+ @ApiModelProperty(value = "Message related to this order")
+ public String getMessageInformation() {
+ return messageInformation;
+ }
+
+ public void setMessageInformation(String messageInformation) {
+ this.messageInformation = messageInformation;
+ }
+
+ public OrderMessage messageInformation(String messageInformation) {
+ this.messageInformation = messageInformation;
+ return this;
+ }
+
+
+ /**
+ * Gravity of this message
+ *
+ * @return severity
+ **/
+ @JsonProperty("severity")
+ @ApiModelProperty(required = true,value = "Gravity of this message")
+ @NotNull
+ public SeverityMessage getSeverity() {
+ return severity;
+ }
+
+ public void setSeverity(SeverityMessage severity) {
+ this.severity = severity;
+ }
+
+ public OrderMessage severity(SeverityMessage severity) {
+ this.severity = severity;
+ return this;
+ }
+
+
+ /**
+ * Indicator that an action is required to allow service order fullfilment to follow up
+ *
+ * @return correctionRequired
+ **/
+ @JsonProperty("correctionRequired")
+ @ApiModelProperty(required = true,value = "Indicator that an action is required to allow service order fullfilment to follow up")
+ @NotNull
+ public boolean getCorrectionRequired() {
+ return correctionRequired;
+ }
+
+ public void setCorrectionRequired(boolean correctionRequired) {
+ this.correctionRequired = correctionRequired;
+ }
+
+ public OrderMessage severity(boolean correctionRequired) {
+ this.correctionRequired = correctionRequired;
+ return this;
+ }
+
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ OrderMessage orderMessage = (OrderMessage) o;
+ return Objects.equals(this.code, orderMessage.code)
+ && Objects.equals(this.field, orderMessage.field)
+ && Objects.equals(this.messageInformation, orderMessage.messageInformation)
+ && Objects.equals(this.severity, orderMessage.severity)
+ && Objects.equals(this.correctionRequired, orderMessage.correctionRequired);
+ }
+
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(code, field, messageInformation,severity);
+ }
+
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("class OrderMessage {\n");
+ sb.append(" code: ").append(toIndentedString(code)).append("\n");
+ sb.append(" field: ").append(toIndentedString(field)).append("\n");
+ sb.append(" messageInformation: ").append(toIndentedString(messageInformation)).append("\n");
+ sb.append(" severity: ").append(toIndentedString(severity)).append("\n");
+ sb.append(" correctionRequired: ").append(toIndentedString(correctionRequired)).append("\n");
+ sb.append("}");
+ return sb.toString();
+ }
+
+ /**
+ * Convert the given object to string with each line indented by 4 spaces (except the first
+ * line).
+ */
+ private String toIndentedString(Object o) {
+ if (o == null) {
+ return "null";
+ }
+ return o.toString().replace("\n", "\n ");
+ }
+}
+
@JsonProperty("orderItem")
private List<ServiceOrderItem> orderItem = null;
+ @JsonProperty("orderMessage")
+ private List<OrderMessage> orderMessage = null;
+
public ServiceOrder id(String id) {
this.id = id;
return this;
}
+ public ServiceOrder orderMessage(List<OrderMessage> orderMessage) {
+ this.orderMessage = orderMessage;
+ return this;
+ }
+
+ public ServiceOrder addOrderMessageItem(OrderMessage orderMessageItem) {
+ if (this.orderMessage == null) {
+ this.orderMessage = new ArrayList<OrderMessage>();
+ }
+ boolean mesageAlreadyExist=false;
+ for (OrderMessage message : this.orderMessage) {
+ if(message.getCode().equals(orderMessageItem.getCode())){
+ mesageAlreadyExist=true;
+
+ }
+ }
+ if(!mesageAlreadyExist) {
+ this.orderMessage.add(orderMessageItem);
+ }
+ return this;
+ }
+
+ /**
+ *
+ * @return orderMessage
+ **/
+ @JsonProperty("orderMessage")
+ @ApiModelProperty(value = "")
+ public List<OrderMessage> getOrderMessage() {
+ return orderMessage;
+ }
+
+ public void setOrderMessage(List<OrderMessage> orderMessage) {
+ this.orderMessage = orderMessage;
+ }
+
+
+
+
+
@Override
public boolean equals(java.lang.Object o) {
if (this == o) {
&& Objects.equals(this.schemaLocation, serviceOrder.schemaLocation)
&& Objects.equals(this.relatedParty, serviceOrder.relatedParty)
&& Objects.equals(this.orderRelationship, serviceOrder.orderRelationship)
- && Objects.equals(this.orderItem, serviceOrder.orderItem);
+ && Objects.equals(this.orderItem, serviceOrder.orderItem)
+ && Objects.equals(this.orderMessage, serviceOrder.orderMessage);
}
+
@Override
public int hashCode() {
return Objects.hash(id, href, externalId, priority, description, category, state, orderDate, completionDateTime,
expectedCompletionDate, requestedStartDate, requestedCompletionDate, startDate, baseType, type,
- schemaLocation, relatedParty, orderRelationship, orderItem);
+ schemaLocation, relatedParty, orderRelationship, orderItem, orderMessage);
}
sb.append(" relatedParty: ").append(toIndentedString(relatedParty)).append("\n");
sb.append(" orderRelationship: ").append(toIndentedString(orderRelationship)).append("\n");
sb.append(" orderItem: ").append(toIndentedString(orderItem)).append("\n");
+ sb.append(" orderMessage: ").append(toIndentedString(orderMessage)).append("\n");
sb.append("}");
return sb.toString();
}
@JsonProperty("service")
private Service service = null;
+
+ @JsonProperty("orderMessage")
+ private List<OrderMessage> orderItemMessage = new ArrayList<>();
+
+
public ServiceOrderItem id(String id) {
this.id = id;
return this;
this.requestId = requestId;
}
+
+ public ServiceOrderItem orderItemMessage(List<OrderMessage> orderItemMessage) {
+ this.orderItemMessage = orderItemMessage;
+ return this;
+ }
+
+ public ServiceOrderItem addOrderItemMessageItem(OrderMessage orderItemMessageItem) {
+ if (this.orderItemMessage == null) {
+ this.orderItemMessage = new ArrayList<OrderMessage>();
+ }
+ boolean mesageAlreadyExist=false;
+ for (OrderMessage message : this.orderItemMessage) {
+ if(message.getCode().equals(orderItemMessageItem.getCode())){
+ mesageAlreadyExist=true;
+
+ }
+ }
+ if(!mesageAlreadyExist) {
+ this.orderItemMessage.add(orderItemMessageItem);
+ }
+ return this;
+ }
+
+ /**
+ *
+ * @return orderItemMessage
+ **/
+ @JsonProperty("orderItemMessage")
+ @ApiModelProperty(value = "")
+ public List<OrderMessage> getOrderItemMessage() {
+ return orderItemMessage;
+ }
+
+ public void setOrderMessage(List<OrderMessage> orderItemMessage) {
+ this.orderItemMessage = orderItemMessage;
+ }
+
+
+
+
@Override
public boolean equals(java.lang.Object o) {
if (this == o) {
&& Objects.equals(this.baseType, serviceOrderItem.baseType)
&& Objects.equals(this.orderItemRelationship, serviceOrderItem.orderItemRelationship)
&& Objects.equals(this.service, serviceOrderItem.service)
- && Objects.equals(this.requestId, serviceOrderItem.requestId);
+ && Objects.equals(this.requestId, serviceOrderItem.requestId)
+ && Objects.equals(this.orderItemMessage, serviceOrderItem.orderItemMessage);
+
}
@Override
public int hashCode() {
return Objects.hash(id, action, state, type, schemaLocation, baseType, orderItemRelationship, service,
- requestId);
+ requestId,orderItemMessage);
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ServiceOrderItem {\n");
-
sb.append(" id: ").append(toIndentedString(id)).append("\n");
sb.append(" action: ").append(toIndentedString(action)).append("\n");
sb.append(" state: ").append(toIndentedString(state)).append("\n");
sb.append(" orderItemRelationship: ").append(toIndentedString(orderItemRelationship)).append("\n");
sb.append(" requestId: ").append(toIndentedString(requestId)).append("\n");
sb.append(" service: ").append(toIndentedString(service)).append("\n");
+ sb.append(" service: ").append(toIndentedString(orderItemMessage)).append("\n");
sb.append("}");
return sb.toString();
}
--- /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.
+ */
+/*
+ * API ServiceOrder serviceOrder API designed for ONAP Beijing Release. This API is build from TMF
+ * open API16.5 + applied TMF guideline 3.0
+ *
+ * OpenAPI spec version: 0.1.1_inProgress
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git Do not edit the class manually.
+ *
+ * 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;
+
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ *
+ */
+public enum SeverityMessage {
+
+ INFORMATION("information"),
+
+ ERROR("error");
+
+ private String value;
+
+ SeverityMessage(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return String.valueOf(value);
+ }
+
+ @JsonCreator
+ public static SeverityMessage fromValue(String text) {
+ for (SeverityMessage b : SeverityMessage.values()) {
+ if (String.valueOf(b.value).equals(text)) {
+ return b;
+ }
+ }
+ return null;
+ }
+
+ @JsonValue
+ public String value() {
+ return this.value;
+ }
+
+}
+
*/
package org.onap.nbi.apis.serviceorder.service;
+import org.onap.nbi.apis.serviceorder.model.OrderMessage;
import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
+import org.onap.nbi.apis.serviceorder.model.SeverityMessage;
import org.onap.nbi.apis.serviceorder.model.StateType;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
}
+
+ public void addOrderMessage(ServiceOrder serviceOrder, String code) {
+ OrderMessage orderMessage = new OrderMessage();
+ orderMessage.setCode(code);
+ orderMessage.setSeverity(SeverityMessage.ERROR);
+ orderMessage.setCorrectionRequired(true);
+
+ if ("104".equalsIgnoreCase(code)) {
+ orderMessage.setField("relatedParty.id");
+ orderMessage.setMessageInformation("Referred customer did not exist in ONAP");
+ serviceOrder.addOrderMessageItem(orderMessage);
+ }
+ if ("500".equalsIgnoreCase(code)) {
+ orderMessage.setMessageInformation("Problem with SDC API");
+ serviceOrder.addOrderMessageItem(orderMessage);
+ }
+ if ("501".equalsIgnoreCase(code)) {
+ orderMessage.setMessageInformation("Problem with AAI API");
+ serviceOrder.addOrderMessageItem(orderMessage);
+ }
+ if ("502".equalsIgnoreCase(code)) {
+ orderMessage.setMessageInformation("Problem with SO API");
+ serviceOrder.addOrderMessageItem(orderMessage);
+ }
+ if ("503".equalsIgnoreCase(code)) {
+ orderMessage.setMessageInformation("tenantId not found in AAI");
+ serviceOrder.addOrderMessageItem(orderMessage);
+ }
+ serviceOrderRepository.save(serviceOrder);
+ }
+
+ public void addOrderItemMessage(ServiceOrder serviceOrder,ServiceOrderItem serviceOrderItem, String code) {
+ OrderMessage orderMessage = new OrderMessage();
+ orderMessage.setCode(code);
+ orderMessage.setSeverity(SeverityMessage.ERROR);
+ orderMessage.setCorrectionRequired(true);
+
+ if ("101".equalsIgnoreCase(code)) {
+ orderMessage.setField("service.id");
+ orderMessage.setMessageInformation("Missing Information - orderItem.service.id must be provided");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ if ("102".equalsIgnoreCase(code)) {
+ orderMessage.setField("serviceSpecification.id");
+ orderMessage
+ .setMessageInformation("Incorrect serviceSpecification.id provided – not found in Catalog (SDC");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ if ("103".equalsIgnoreCase(code)) {
+ orderMessage.setField("service.id");
+ orderMessage.setMessageInformation(
+ "Inconsistence information provided. service.id must not be provided for add action");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ if ("105".equalsIgnoreCase(code)) {
+ orderMessage.setField("service.name");
+ orderMessage.setMessageInformation("ServiceName already exist in AAI");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ if ("106".equalsIgnoreCase(code)) {
+ orderMessage.setField("service.id");
+ orderMessage.setMessageInformation("Incorrect service.id provided – not found in Inventory (AAI)");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ if ("107".equalsIgnoreCase(code)) {
+ orderMessage.setMessageInformation("tenantId not found in AAI");
+ serviceOrderItem.addOrderItemMessageItem(orderMessage);
+ }
+ serviceOrderRepository.save(serviceOrder);
+ }
+
}
*/
package org.onap.nbi.apis.serviceorder.workflow;
-import java.util.LinkedHashMap;
+import java.util.Map;
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.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;
@Autowired
private ServiceOrderService serviceOrderService;
+
private static final Logger LOGGER = LoggerFactory.getLogger(CheckOrderConsistenceManager.class);
public ServiceOrderInfo checkServiceOrder(ServiceOrder serviceOrder) {
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
ServiceOrderItemInfo serviceOrderItemInfo = new ServiceOrderItemInfo();
- handleServiceFromCatalog(serviceOrderItem, serviceOrderItemInfo);
+ handleServiceFromCatalog(serviceOrderItem,serviceOrder, serviceOrderItemInfo);
if (!existServiceInCatalog(serviceOrderItemInfo)) {
serviceOrderInfo.setIsServiceOrderRejected(true);
- serviceOrderService.updateOrderItemState(serviceOrder,serviceOrderItem,StateType.REJECTED);
+ serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
LOGGER.warn(
"service order item {} of service order {} rejected cause no service catalog found for id {}",
serviceOrderItem.getId(), serviceOrder.getId(),
serviceOrderItem.getService().getServiceSpecification().getId());
+ serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "102");
} else {
switch (serviceOrderItem.getAction()) {
case ADD:
- handleServiceOrderItemInAdd(serviceOrderInfo,serviceOrder, serviceOrderItem, serviceOrderItemInfo);
+ handleServiceOrderItemInAdd(serviceOrderInfo, serviceOrder, serviceOrderItem,
+ serviceOrderItemInfo);
break;
case MODIFY:
case DELETE:
- handleServiceOrderItemInChange(serviceOrderInfo,serviceOrder, serviceOrderItem, serviceOrderItemInfo);
+ handleServiceOrderItemInChange(serviceOrderInfo, serviceOrder, serviceOrderItem,
+ serviceOrderItemInfo);
break;
case NOCHANGE:
serviceOrderInfo.setAllItemsInAdd(false);
- serviceOrderService.updateOrderItemState(serviceOrder,serviceOrderItem,StateType.COMPLETED);
+ serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.COMPLETED);
nbItemsCompleted++;
break;
}
ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
ServiceOrderItemInfo serviceOrderItemInfo) {
serviceOrderInfo.setAllItemsInAdd(false);
- if (shouldAcceptServiceOrderItemToChange(serviceOrderInfo, serviceOrderItem,
+ if (shouldAcceptServiceOrderItemToChange(serviceOrderInfo, serviceOrder, serviceOrderItem,
serviceOrderItemInfo)) {
serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
} else {
serviceOrderInfo.setIsServiceOrderRejected(true);
- serviceOrderService.updateOrderItemState(serviceOrder,serviceOrderItem,StateType.REJECTED);
+ serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
}
}
private void handleServiceOrderItemInAdd(ServiceOrderInfo serviceOrderInfo,
ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
ServiceOrderItemInfo serviceOrderItemInfo) {
- if (shouldAcceptServiceOrderItemToAdd(serviceOrderItem, serviceOrderInfo.getServiceOrderId())) {
+ if (shouldAcceptServiceOrderItemToAdd(serviceOrderItem, serviceOrder, serviceOrderInfo.getServiceOrderId())) {
serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
} else {
serviceOrderInfo.setIsServiceOrderRejected(true);
- serviceOrderService.updateOrderItemState(serviceOrder,serviceOrderItem,StateType.REJECTED);
+ serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
}
}
private boolean shouldAcceptServiceOrderItemToAdd(ServiceOrderItem serviceOrderItem,
- String serviceOrderId) {
+ ServiceOrder serviceOrder, String serviceOrderId) {
if (!StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
LOGGER
.warn("serviceOrderItem {} for serviceorder {} rejected cause service.id must be empty in add action",
serviceOrderItem.getId(), serviceOrderId);
+ serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "103");
return false;
- } else if (!serviceOrderConsumerService.isTenantIdPresentInAAI()) {
+ } else if (!serviceOrderConsumerService.isTenantIdPresentInAAI(serviceOrder)) {
LOGGER.warn("serviceOrderItem {} for serviceOrder {} rejected cause tenantId not found in AAI",
serviceOrderItem.getId(), serviceOrderId);
+ serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "107");
+
return false;
}
return true;
}
private boolean shouldAcceptServiceOrderItemToChange(ServiceOrderInfo serviceOrderInfo,
- ServiceOrderItem serviceOrderItem,
+ ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
ServiceOrderItemInfo serviceOrderItemInfo) {
if (StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
LOGGER.warn(
"serviceOrderItem {} for serviceOrder {} rejected cause service.id is mandatory in delete/change action",
serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
+ serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "101");
return false;
- } else if (!isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo)) {
+ } else if (!isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo,serviceOrder)) {
LOGGER
.warn("serviceOrderItem {} for serviceOrder {} rejected cause customer not found in inventory",
serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
+ serviceOrderService.addOrderMessage(serviceOrder, "104");
return false;
- } else if (!existServiceInInventory(serviceOrderItem, serviceOrderItemInfo,
+ } else if (!existServiceInInventory(serviceOrderItem, serviceOrder, serviceOrderItemInfo,
serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
LOGGER
.warn("serviceOrderItem {} for serviceOrder {} rejected cause service id {} not found in inventory",
serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId(),
serviceOrderItem.getService().getId());
+ serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "106");
return false;
}
return true;
return null;
}
- private boolean isCustomerFromServiceOrderPresentInInventory(ServiceOrderInfo serviceOrderInfo) {
+ private boolean isCustomerFromServiceOrderPresentInInventory(ServiceOrderInfo serviceOrderInfo,
+ ServiceOrder serviceOrder) {
if (serviceOrderInfo.isUseServiceOrderCustomer()) {
return serviceOrderConsumerService
- .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
+ .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(),serviceOrder);
}
return true;
}
private boolean existServiceInInventory(ServiceOrderItem serviceOrderItem,
- ServiceOrderItemInfo serviceOrderItemInfo, String globalSubscriberId) {
+ ServiceOrder serviceOrder, ServiceOrderItemInfo serviceOrderItemInfo,
+ String globalSubscriberId) {
String serviceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
return serviceOrderConsumerService.doesServiceExistInServiceInventory(
- serviceOrderItem.getService().getId(), serviceName, globalSubscriberId);
+ serviceOrderItem.getService().getId(), serviceName, globalSubscriberId,serviceOrder);
}
private boolean existServiceInCatalog(ServiceOrderItemInfo serviceOrderItemInfo) {
}
private void handleServiceFromCatalog(ServiceOrderItem serviceOrderItem,
- ServiceOrderItemInfo serviceOrderItemInfo) {
- ResponseEntity<Object> response = serviceOrderConsumerService
- .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId());
- if (response != null && (response.getStatusCode().equals(HttpStatus.OK)
- || response.getStatusCode().equals(HttpStatus.PARTIAL_CONTENT))) {
- LinkedHashMap body = (LinkedHashMap) response.getBody();
- serviceOrderItemInfo.setCatalogResponse(body);
- } else {
- LOGGER.warn("unable to retrieve catalog information for service {}",
- serviceOrderItem.getService().getServiceSpecification().getId());
- }
- }
+ ServiceOrder serviceOrder, ServiceOrderItemInfo serviceOrderItemInfo) {
+ Map body = serviceOrderConsumerService
+ .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId(),serviceOrder,serviceOrderItem);
+ serviceOrderItemInfo.setCatalogResponse(body);
+ }
}
if (serviceOrderInfo.isUseServiceOrderCustomer() && serviceOrderInfo.isAllItemsInAdd()
&& !serviceOrderConsumerService
- .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
+ .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), serviceOrder)) {
- boolean customerCreated = serviceOrderConsumerService.putCustomer(serviceOrderInfo.getSubscriberInfo());
+ boolean customerCreated = serviceOrderConsumerService.putCustomer(serviceOrderInfo.getSubscriberInfo(), serviceOrder);
if (!customerCreated) {
serviceOrderService.updateOrderState(serviceOrder,StateType.REJECTED);
LOGGER.warn("serviceOrder {} rejected : cannot create customer", serviceOrder.getId());
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
}
}
}
@Autowired
ServiceOrderService serviceOrderService;
+
private static final Logger LOGGER = LoggerFactory.getLogger(CreateAAIServiceTypeManager.class);
public void createAAIServiceType(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
Map servicesInAaiForCustomer = serviceOrderConsumerService
- .getServicesInAaiForCustomer(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
+ .getServicesInAaiForCustomer(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), serviceOrder);
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
if (ActionType.ADD == serviceOrderItem.getAction()) {
String sdcServiceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
if (!serviceNameExistsInAAI(servicesInAaiForCustomer, sdcServiceName)) {
boolean serviceCreated = serviceOrderConsumerService.putServiceType(
- serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), sdcServiceName);
+ serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(), sdcServiceName, serviceOrder);
if (!serviceCreated) {
serviceOrderService.updateOrderState(serviceOrder,StateType.REJECTED);
LOGGER.warn("serviceOrder {} rejected : cannot create service type {} for customer {}",
serviceOrder.getId(), sdcServiceName,
serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
+ serviceOrderService.addOrderMessage(serviceOrder, "501");
+
}
}
}
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
- ResponseEntity<CreateServiceInstanceResponse> response = postServiceOrderItem(serviceOrderInfo,
+ ResponseEntity<CreateServiceInstanceResponse> response = postServiceOrderItem(serviceOrderInfo,serviceOrder,
serviceOrderItem);
updateServiceOrderItem(response, serviceOrderItem,serviceOrder);
}
}
private ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
- ServiceOrderItem serviceOrderItem) {
+ ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem) {
ResponseEntity<CreateServiceInstanceResponse> response = null;
try {
- response = postSORequest(serviceOrderItem, serviceOrderInfo);
+ response = postSORequest(serviceOrderItem,serviceOrder, serviceOrderInfo);
} catch (NullPointerException e) {
LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
response = null;
}
private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
- ServiceOrderInfo serviceOrderInfo) {
+ ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
RequestDetails requestDetails = buildSoRequest(serviceOrderItem,
serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
serviceOrderInfo.getSubscriberInfo());
response = soClient.callCreateServiceInstance(msoPayload);
break;
case DELETE:
- response = soClient.callDeleteServiceInstance(msoPayload, serviceOrderItem.getService().getId());
+ response = soClient.callDeleteServiceInstance(msoPayload,serviceOrderItem.getService().getId());
break;
default:
break;
}
+ if(response!=null && response.getStatusCode()== HttpStatus.INTERNAL_SERVER_ERROR) {
+ serviceOrderService.addOrderMessage(serviceOrder, "502");
+ }
return response;
}
private void updateServiceOrderItem(ResponseEntity<CreateServiceInstanceResponse> response,
ServiceOrderItem orderItem, ServiceOrder serviceOrder) {
- if (response == null) {
- LOGGER.warn("response=null for serviceOrderItem.id=" + orderItem.getId());
+ if (response==null || !response.getStatusCode().is2xxSuccessful()) {
+ LOGGER.warn("response ko for serviceOrderItem.id=" + orderItem.getId());
serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
}
else {
}
+
+ @Test
+ public void testCheckServiceOrderWithUnknownSverviceSpecId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().getServiceSpecification().setId("toto");
+ }
+
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
+ }
+
@Test
public void testCheckServiceOrderWithGenericCustomer() throws Exception {
}
+ @Test
+ public void testCheckServiceOrderInDeleteWithNoServiceId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().setId(null);
+ }
+
+ 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()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("101");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
+ }
+
+ @Test
+ public void testCheckServiceOrderInAddWithServiceId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().setId("toto");
+ }
+
+ 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()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("103");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
+ }
+
+ @Test
+ public void testCheckServiceOrderWithUnKnownCustomerInChange() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ 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);
+
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("104");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getField()).isEqualTo("relatedParty.id");
+ }
+
+
@Test
public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("501");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with AAI API");
+ }
+
+
+ @Test
+ public void testCheckServiceOrderWithSDCNotResponding() throws Exception {
+
+ removeWireMockMapping("/sdc/v1/catalog/services/1e3feeb0-8e36-46c6-862c-236d9c626439/metadata");
+
+ 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);
+
+
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
}
+
+
@Test
public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("106");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
}
@Test
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if(serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
+ }
}
@Test
import static org.assertj.core.api.Assertions.assertThat;
+import java.util.ArrayList;
+import java.util.List;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
+import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
+import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
+import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
import org.onap.nbi.apis.serviceorder.model.ActionType;
+import org.onap.nbi.apis.serviceorder.model.RelatedParty;
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.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.context.embedded.LocalServerPort;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@Autowired
SOTaskProcessor SoTaskProcessor;
+ @Autowired
+ ServiceSpecificationResource serviceSpecificationResource;
+
+ @Autowired
+ ServiceInventoryResource serviceInventoryResource;
+
+ @Autowired
+ ServiceOrderResource serviceOrderResource;
+
@After
public void tearsDownUpPort() throws Exception {
executionTaskRepository.deleteAll();
for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
}
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with SO API");
assertThat(executionTaskRepository.count()).isEqualTo(0);
}
+ @Test
+ public void testCheckServiceOrderWithSDCNotResponding() throws Exception {
+
+ 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);
+
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("500");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with SDC API");
+ }
+
+
+
+ @Test
+ public void testServiceCatalogGetResource() throws Exception {
+
+ ResponseEntity<Object> resource = serviceSpecificationResource
+ .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
+ assertThat(resource.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
+
+
+ }
+
+
+
+ @Test
+ public void testServiceResourceGetInventory() throws Exception {
+
+ String serviceName = "vFW";
+ String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("serviceSpecification.name", serviceName);
+ params.add("relatedParty.id", "6490");
+ ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
+ assertThat(resource.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
+
+ }
Code Review / externalapi / nbi.git / commitdiff