src/main/java/org/onap/nbi/apis/serviceorder/workflow/CheckOrderConsistenceManager.java

   1 /**
   2  * Copyright (c) 2018 Orange <p> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
   3  * file except in compliance with the License. You may obtain a copy of the License at <p>
   4  * http://www.apache.org/licenses/LICENSE-2.0 <p> Unless required by applicable law or agreed to in writing, software
   5  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
   6  * either express or implied. See the License for the specific language governing permissions and limitations under the
   7  * License.
   8  */
   9 package org.onap.nbi.apis.serviceorder.workflow;
  10
  11 import java.util.LinkedHashMap;
  12 import org.onap.nbi.apis.serviceorder.MultiClient;
  13 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  14 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  15 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  16 import org.onap.nbi.apis.serviceorder.model.StateType;
  17 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
  18 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
  19 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22 import org.springframework.beans.factory.annotation.Autowired;
  23 import org.springframework.http.HttpStatus;
  24 import org.springframework.http.ResponseEntity;
  25 import org.springframework.stereotype.Service;
  26 import org.springframework.util.StringUtils;
  27
  28 @Service
  29 public class CheckOrderConsistenceManager {
  30
  31
  32     @Autowired
  33     private MultiClient serviceOrderConsumerService;
  34
  35     private static final Logger LOGGER = LoggerFactory.getLogger(CheckOrderConsistenceManager.class);
  36
  37     public ServiceOrderInfo checkServiceOrder(ServiceOrder serviceOrder) {
  38         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
  39         serviceOrderInfo.setServiceOrderId(serviceOrder.getId());
  40         manageCustomer(serviceOrder, serviceOrderInfo);
  41         int nbItemsCompleted = 0;
  42
  43         for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
  44             ServiceOrderItemInfo serviceOrderItemInfo = new ServiceOrderItemInfo();
  45             handleServiceFromCatalog(serviceOrderItem, serviceOrderItemInfo);
  46             if (!existServiceInCatalog(serviceOrderItemInfo)) {
  47                 serviceOrderInfo.setIsServiceOrderRejected(true);
  48                 serviceOrderItem.setState(StateType.REJECTED);
  49                 LOGGER.error(
  50                     "service order item {0} of service order {1} rejected cause no service catalog found for id {2}",
  51                     serviceOrderItem.getId(), serviceOrder.getId(),
  52                     serviceOrderItem.getService().getServiceSpecification().getId());
  53             } else {
  54                 switch (serviceOrderItem.getAction()) {
  55                     case ADD:
  56                         handleServiceOrderItemInAdd(serviceOrderInfo, serviceOrderItem, serviceOrderItemInfo);
  57                         break;
  58                     case MODIFY:
  59                     case DELETE:
  60                         handleServiceOrderItemInChange(serviceOrderInfo, serviceOrderItem, serviceOrderItemInfo);
  61                         break;
  62                     case NOCHANGE:
  63                         serviceOrderInfo.setAllItemsInAdd(false);
  64                         serviceOrderItem.setState(StateType.COMPLETED);
  65                         nbItemsCompleted++;
  66                         break;
  67                 }
  68             }
  69
  70         }
  71
  72         if (serviceOrder.getOrderItem().size() != nbItemsCompleted) {
  73             serviceOrderInfo.setAllItemsCompleted(false);
  74         } else {
  75             serviceOrderInfo.setAllItemsCompleted(true);
  76         }
  77
  78         return serviceOrderInfo;
  79
  80     }
  81
  82     private void handleServiceOrderItemInChange(ServiceOrderInfo serviceOrderInfo, ServiceOrderItem serviceOrderItem,
  83         ServiceOrderItemInfo serviceOrderItemInfo) {
  84         serviceOrderInfo.setAllItemsInAdd(false);
  85         if (shouldAcceptServiceOrderItemToChange(serviceOrderInfo, serviceOrderItem,
  86             serviceOrderItemInfo)) {
  87             serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
  88         } else {
  89             serviceOrderInfo.setIsServiceOrderRejected(true);
  90             serviceOrderItem.setState(StateType.REJECTED);
  91         }
  92     }
  93
  94     private void handleServiceOrderItemInAdd(ServiceOrderInfo serviceOrderInfo, ServiceOrderItem serviceOrderItem,
  95         ServiceOrderItemInfo serviceOrderItemInfo) {
  96         if (shouldAcceptServiceOrderItemToAdd(serviceOrderItem, serviceOrderInfo.getServiceOrderId())) {
  97             serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
  98         } else {
  99             serviceOrderInfo.setIsServiceOrderRejected(true);
 100             serviceOrderItem.setState(StateType.REJECTED);
 101         }
 102     }
 103
 104     private boolean shouldAcceptServiceOrderItemToAdd(ServiceOrderItem serviceOrderItem,
 105         String serviceOrderId) {
 106         if (!StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
 107             LOGGER
 108                 .error("serviceOrderItem {0} for serviceorder {1} rejected cause service.id must be empty in add action",
 109                     serviceOrderItem.getId(), serviceOrderId);
 110             return false;
 111         } else if (!serviceOrderConsumerService.isTenantIdPresentInAAI()) {
 112             LOGGER.error("serviceOrderItem {0}  for serviceOrder {1} rejected cause tenantId not found in AAI",
 113                 serviceOrderItem.getId(), serviceOrderId);
 114             return false;
 115         }
 116         return true;
 117     }
 118
 119     private boolean shouldAcceptServiceOrderItemToChange(ServiceOrderInfo serviceOrderInfo,
 120         ServiceOrderItem serviceOrderItem,
 121         ServiceOrderItemInfo serviceOrderItemInfo) {
 122
 123         if (StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
 124             LOGGER.error(
 125                 "serviceOrderItem {0} for serviceOrder {1} rejected cause service.id is mandatory in delete/change action",
 126                 serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
 127             return false;
 128         } else if (!isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo)) {
 129             LOGGER
 130                 .error("serviceOrderItem {0} for serviceOrder {1} rejected cause customer not found in inventory",
 131                     serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
 132             return false;
 133         } else if (!existServiceInInventory(serviceOrderItem, serviceOrderItemInfo,
 134             serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
 135             LOGGER
 136                 .error("serviceOrderItem {0} for serviceOrder {1} rejected cause service id {2} not found in inventory",
 137                     serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId(),
 138                     serviceOrderItem.getService().getId());
 139             return false;
 140         }
 141         return true;
 142     }
 143
 144     private void manageCustomer(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
 145         RelatedParty customerFromServiceOrder = getCustomerFromServiceOrder(serviceOrder);
 146         SubscriberInfo subscriberInfo = new SubscriberInfo();
 147         if (customerFromServiceOrder != null) {
 148             subscriberInfo.setSubscriberName(customerFromServiceOrder.getName());
 149             subscriberInfo.setGlobalSubscriberId(customerFromServiceOrder.getId());
 150             serviceOrderInfo.setUseServiceOrderCustomer(true);
 151         } else {
 152             subscriberInfo.setSubscriberName("generic");
 153             subscriberInfo.setGlobalSubscriberId("generic");
 154             serviceOrderInfo.setUseServiceOrderCustomer(false);
 155         }
 156         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 157
 158     }
 159
 160
 161     private RelatedParty getCustomerFromServiceOrder(ServiceOrder serviceOrder) {
 162         if (serviceOrder.getRelatedParty() != null) {
 163             for (RelatedParty relatedParty : serviceOrder.getRelatedParty()) {
 164                 if ("ONAPcustomer".equalsIgnoreCase(relatedParty.getRole())) {
 165                     return relatedParty;
 166                 }
 167             }
 168         }
 169         return null;
 170     }
 171
 172     private boolean isCustomerFromServiceOrderPresentInInventory(ServiceOrderInfo serviceOrderInfo) {
 173
 174         if (serviceOrderInfo.isUseServiceOrderCustomer()) {
 175             return serviceOrderConsumerService
 176                 .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId());
 177         }
 178         return true;
 179     }
 180
 181     private boolean existServiceInInventory(ServiceOrderItem serviceOrderItem,
 182         ServiceOrderItemInfo serviceOrderItemInfo, String globalSubscriberId) {
 183         String serviceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
 184         return serviceOrderConsumerService.doesServiceExistInServiceInventory(
 185             serviceOrderItem.getService().getId(), serviceName, globalSubscriberId);
 186     }
 187
 188     private boolean existServiceInCatalog(ServiceOrderItemInfo serviceOrderItemInfo) {
 189         return serviceOrderItemInfo.getCatalogResponse() != null;
 190     }
 191
 192     private void handleServiceFromCatalog(ServiceOrderItem serviceOrderItem,
 193         ServiceOrderItemInfo serviceOrderItemInfo) {
 194         ResponseEntity<Object> response = serviceOrderConsumerService
 195             .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId());
 196         if (response != null && (response.getStatusCode().equals(HttpStatus.OK)
 197             || response.getStatusCode().equals(HttpStatus.PARTIAL_CONTENT))) {
 198             LinkedHashMap body = (LinkedHashMap) response.getBody();
 199             serviceOrderItemInfo.setCatalogResponse(body);
 200         } else {
 201             LOGGER.error("unable to retrieve catalog information for service {0}",
 202                 serviceOrderItem.getService().getServiceSpecification().getId());
 203         }
 204     }
 205
 206
 207 }