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