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.Map;
  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.onap.nbi.apis.serviceorder.service.ServiceOrderService;
  21 import org.onap.nbi.apis.serviceorder.utils.E2EServiceUtils;
  22 import org.slf4j.Logger;
  23 import org.slf4j.LoggerFactory;
  24 import org.springframework.beans.factory.annotation.Autowired;
  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     @Autowired
  36     private ServiceOrderService serviceOrderService;
  37
  38
  39     private static final Logger LOGGER = LoggerFactory.getLogger(CheckOrderConsistenceManager.class);
  40
  41     public ServiceOrderInfo checkServiceOrder(ServiceOrder serviceOrder) {
  42         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
  43         serviceOrderInfo.setServiceOrderId(serviceOrder.getId());
  44         manageCustomer(serviceOrder, serviceOrderInfo);
  45         int nbItemsCompleted = 0;
  46
  47         for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
  48             ServiceOrderItemInfo serviceOrderItemInfo = new ServiceOrderItemInfo();
  49             handleServiceFromCatalog(serviceOrderItem,serviceOrder, serviceOrderItemInfo);
  50             if (!existServiceInCatalog(serviceOrderItemInfo)) {
  51                 serviceOrderInfo.setIsServiceOrderRejected(true);
  52                 serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
  53                 LOGGER.warn(
  54                     "service order item {} of service order {} rejected cause no service catalog found for id {}",
  55                     serviceOrderItem.getId(), serviceOrder.getId(),
  56                     serviceOrderItem.getService().getServiceSpecification().getId());
  57                 serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "102");
  58             } else {
  59                 switch (serviceOrderItem.getAction()) {
  60                     case ADD:
  61                         handleServiceOrderItemInAdd(serviceOrderInfo, serviceOrder, serviceOrderItem,
  62                             serviceOrderItemInfo);
  63                         break;
  64                     case MODIFY:
  65                     case DELETE:
  66                         handleServiceOrderItemInChange(serviceOrderInfo, serviceOrder, serviceOrderItem,
  67                             serviceOrderItemInfo);
  68                         break;
  69                     case NOCHANGE:
  70                         serviceOrderInfo.setAllItemsInAdd(false);
  71                         serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.COMPLETED);
  72                         nbItemsCompleted++;
  73                         break;
  74                 }
  75             }
  76
  77         }
  78
  79         if (serviceOrder.getOrderItem().size() != nbItemsCompleted) {
  80             serviceOrderInfo.setAllItemsCompleted(false);
  81         } else {
  82             serviceOrderInfo.setAllItemsCompleted(true);
  83         }
  84
  85         return serviceOrderInfo;
  86
  87     }
  88
  89     private void handleServiceOrderItemInChange(ServiceOrderInfo serviceOrderInfo,
  90         ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
  91         ServiceOrderItemInfo serviceOrderItemInfo) {
  92         serviceOrderInfo.setAllItemsInAdd(false);
  93         if (shouldAcceptServiceOrderItemToChange(serviceOrderInfo, serviceOrder, serviceOrderItem,
  94             serviceOrderItemInfo)) {
  95             serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
  96         } else {
  97             serviceOrderInfo.setIsServiceOrderRejected(true);
  98             serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
  99         }
 100     }
 101
 102     private void handleServiceOrderItemInAdd(ServiceOrderInfo serviceOrderInfo,
 103         ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
 104         ServiceOrderItemInfo serviceOrderItemInfo) {
 105         boolean e2eService= E2EServiceUtils.isE2EService(serviceOrderItemInfo);
 106         if (shouldAcceptServiceOrderItemToAdd(serviceOrderItem, serviceOrder, serviceOrderInfo.getServiceOrderId(), e2eService)) {
 107             serviceOrderInfo.addServiceOrderItemInfos(serviceOrderItem.getId(), serviceOrderItemInfo);
 108         } else {
 109             serviceOrderInfo.setIsServiceOrderRejected(true);
 110             serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.REJECTED);
 111         }
 112     }
 113
 114     private boolean shouldAcceptServiceOrderItemToAdd(ServiceOrderItem serviceOrderItem,
 115         ServiceOrder serviceOrder, String serviceOrderId, Boolean e2eService) {
 116         if (!StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
 117             LOGGER
 118                 .warn("serviceOrderItem {} for serviceorder {} rejected cause service.id must be empty in add action",
 119                     serviceOrderItem.getId(), serviceOrderId);
 120             serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "103");
 121             return false;
 122         } else if (!e2eService && !serviceOrderConsumerService.isTenantIdPresentInAAI(serviceOrder)) {
 123             LOGGER.warn("serviceOrderItem {}  for serviceOrder {} rejected cause tenantId not found in AAI",
 124                 serviceOrderItem.getId(), serviceOrderId);
 125             serviceOrderService.addOrderMessage(serviceOrder,"503");
 126
 127             return false;
 128         }
 129         return true;
 130     }
 131
 132     private boolean shouldAcceptServiceOrderItemToChange(ServiceOrderInfo serviceOrderInfo,
 133         ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem,
 134         ServiceOrderItemInfo serviceOrderItemInfo) {
 135
 136         if (StringUtils.isEmpty(serviceOrderItem.getService().getId())) {
 137             LOGGER.warn(
 138                 "serviceOrderItem {} for serviceOrder {} rejected cause service.id is mandatory in delete/change action",
 139                 serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
 140             serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "101");
 141             return false;
 142         } else if (!isCustomerFromServiceOrderPresentInInventory(serviceOrderInfo,serviceOrder)) {
 143             LOGGER
 144                 .warn("serviceOrderItem {} for serviceOrder {} rejected cause customer not found in inventory",
 145                     serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId());
 146             serviceOrderService.addOrderMessage(serviceOrder, "104");
 147             return false;
 148         } else if (!existServiceInInventory(serviceOrderItem, serviceOrder, serviceOrderItemInfo,
 149             serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId())) {
 150             LOGGER
 151                 .warn("serviceOrderItem {} for serviceOrder {} rejected cause service id {} not found in inventory",
 152                     serviceOrderItem.getId(), serviceOrderInfo.getServiceOrderId(),
 153                     serviceOrderItem.getService().getId());
 154             serviceOrderService.addOrderItemMessage(serviceOrder,serviceOrderItem, "106");
 155             return false;
 156         }
 157         return true;
 158     }
 159
 160     private void manageCustomer(ServiceOrder serviceOrder, ServiceOrderInfo serviceOrderInfo) {
 161         RelatedParty customerFromServiceOrder = getCustomerFromServiceOrder(serviceOrder);
 162         SubscriberInfo subscriberInfo = new SubscriberInfo();
 163         if (customerFromServiceOrder != null) {
 164             subscriberInfo.setSubscriberName(customerFromServiceOrder.getName());
 165             subscriberInfo.setGlobalSubscriberId(customerFromServiceOrder.getId());
 166             serviceOrderInfo.setUseServiceOrderCustomer(true);
 167         } else {
 168             subscriberInfo.setSubscriberName("generic");
 169             subscriberInfo.setGlobalSubscriberId("generic");
 170             serviceOrderInfo.setUseServiceOrderCustomer(false);
 171         }
 172         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 173
 174     }
 175
 176
 177     private RelatedParty getCustomerFromServiceOrder(ServiceOrder serviceOrder) {
 178         if (serviceOrder.getRelatedParty() != null) {
 179             for (RelatedParty relatedParty : serviceOrder.getRelatedParty()) {
 180                 if ("ONAPcustomer".equalsIgnoreCase(relatedParty.getRole())) {
 181                     return relatedParty;
 182                 }
 183             }
 184         }
 185         return null;
 186     }
 187
 188     private boolean isCustomerFromServiceOrderPresentInInventory(ServiceOrderInfo serviceOrderInfo,
 189         ServiceOrder serviceOrder) {
 190
 191         if (serviceOrderInfo.isUseServiceOrderCustomer()) {
 192             return serviceOrderConsumerService
 193                 .isCustomerPresentInAAI(serviceOrderInfo.getSubscriberInfo().getGlobalSubscriberId(),serviceOrder);
 194         }
 195         return true;
 196     }
 197
 198     private boolean existServiceInInventory(ServiceOrderItem serviceOrderItem,
 199         ServiceOrder serviceOrder, ServiceOrderItemInfo serviceOrderItemInfo,
 200         String globalSubscriberId) {
 201         String serviceName = (String) serviceOrderItemInfo.getCatalogResponse().get("name");
 202         return serviceOrderConsumerService.doesServiceExistInServiceInventory(
 203             serviceOrderItem.getService().getId(), serviceName, globalSubscriberId,serviceOrder);
 204     }
 205
 206     private boolean existServiceInCatalog(ServiceOrderItemInfo serviceOrderItemInfo) {
 207         return serviceOrderItemInfo.getCatalogResponse() != null;
 208     }
 209
 210     private void handleServiceFromCatalog(ServiceOrderItem serviceOrderItem,
 211         ServiceOrder serviceOrder, ServiceOrderItemInfo serviceOrderItemInfo) {
 212         Map body = serviceOrderConsumerService
 213             .getServiceCatalog(serviceOrderItem.getService().getServiceSpecification().getId(),serviceOrder,serviceOrderItem);
 214         serviceOrderItemInfo.setCatalogResponse(body);
 215
 216     }
 217
 218 }