src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java

   1 /**
   2  * Copyright (c) 2018 Orange
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   5  * in compliance with the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License
  10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11  * or implied. See the License for the specific language governing permissions and limitations under
  12  * the License.
  13  */
  14
  15 package org.onap.nbi.apis.assertions;
  16
  17 import java.util.ArrayList;
  18 import java.util.Date;
  19 import java.util.LinkedHashMap;
  20 import java.util.List;
  21 import org.onap.nbi.apis.serviceorder.model.ActionType;
  22 import org.onap.nbi.apis.serviceorder.model.OrderItemRelationship;
  23 import org.onap.nbi.apis.serviceorder.model.OrderRelationship;
  24 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  25 import org.onap.nbi.apis.serviceorder.model.RelationshipType;
  26 import org.onap.nbi.apis.serviceorder.model.ResourceSpecification;
  27 import org.onap.nbi.apis.serviceorder.model.Service;
  28 import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
  29 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  30 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  31 import org.onap.nbi.apis.serviceorder.model.ServiceSpecificationRef;
  32 import org.onap.nbi.apis.serviceorder.model.StateType;
  33 import org.onap.nbi.apis.serviceorder.model.Value;
  34 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
  35 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  36 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
  37 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
  38 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  39 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  40 import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
  41
  42 public class ServiceOrderExecutionTaskAssertions {
  43
  44     public static ServiceOrder createTestServiceOrderRejected() {
  45         ServiceOrder serviceOrder = new ServiceOrder();
  46         serviceOrder.setExternalId("LudONAP001");
  47         serviceOrder.setPriority("1");
  48         serviceOrder.setDescription("Ludo first ONAP Order");
  49         serviceOrder.setCategory("Consumer");
  50         serviceOrder.setRequestedStartDate(new Date());
  51         serviceOrder.setRequestedCompletionDate(new Date());
  52
  53         RelatedParty party = new RelatedParty();
  54         party.setId("6490");
  55         party.setRole("ONAPcustomer");
  56         party.setReferredType("individual");
  57         party.setName("Jean Pontus");
  58         List<RelatedParty> relatedPartyList = new ArrayList<>();
  59         relatedPartyList.add(party);
  60         serviceOrder.setRelatedParty(relatedPartyList);
  61
  62         List<ServiceOrderItem> items = new ArrayList<>();
  63
  64         ServiceOrderItem itemA = new ServiceOrderItem();
  65         itemA.id("A");
  66         itemA.action(ActionType.ADD);
  67         Service serviceA = new Service();
  68         serviceA.setServiceState("active");
  69         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
  70         serviceSpecificationRefA.setId("333");
  71         serviceA.setServiceSpecification(serviceSpecificationRefA);
  72         itemA.setService(serviceA);
  73         items.add(itemA);
  74
  75         ServiceOrderItem itemB = new ServiceOrderItem();
  76         itemB.id("B");
  77         itemB.action(ActionType.ADD);
  78         Service serviceB = new Service();
  79         serviceB.setServiceState("active");
  80         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
  81         serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
  82         serviceB.setServiceSpecification(serviceSpecificationRefB);
  83         itemB.setService(serviceB);
  84         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
  85         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
  86         orderItemRelationship.setId("A");
  87         orderItemRelationships.add(orderItemRelationship);
  88         itemB.setOrderItemRelationship(orderItemRelationships);
  89         items.add(itemB);
  90         serviceOrder.setOrderItem(items);
  91         return serviceOrder;
  92
  93     }
  94
  95     public static ServiceOrder createTestServiceOrder(ActionType actionType) {
  96         ServiceOrder serviceOrder = new ServiceOrder();
  97         serviceOrder.setExternalId("LudONAP001");
  98         serviceOrder.setPriority("1");
  99         serviceOrder.setDescription("Ludo first ONAP Order");
 100         serviceOrder.setCategory("Consumer");
 101         serviceOrder.setRequestedStartDate(new Date());
 102         serviceOrder.setRequestedCompletionDate(new Date());
 103         serviceOrder.setBaseType("toto");
 104         serviceOrder.setCompletionDateTime(new Date());
 105         serviceOrder.setExpectedCompletionDate(new Date());
 106         serviceOrder.setSchemaLocation("/tutu");
 107
 108         OrderRelationship orderRelationship = new OrderRelationship();
 109         orderRelationship.setId("test");
 110         orderRelationship.setHref("test");
 111         orderRelationship.setReferredType("test");
 112         orderRelationship.setType("type");
 113         List<OrderRelationship> relationships = new ArrayList<>();
 114         serviceOrder.setOrderRelationship(relationships);
 115
 116         RelatedParty party = new RelatedParty();
 117         party.setId("6490");
 118         party.setRole("ONAPcustomer");
 119         party.setReferredType("individual");
 120         party.setName("Jean Pontus");
 121         List<RelatedParty> relatedPartyList = new ArrayList<>();
 122         relatedPartyList.add(party);
 123         serviceOrder.setRelatedParty(relatedPartyList);
 124
 125         List<ServiceOrderItem> items = new ArrayList<>();
 126
 127         ServiceOrderItem itemA = new ServiceOrderItem();
 128         itemA.id("A");
 129         itemA.action(actionType);
 130         Service serviceA = new Service();
 131         if (actionType != ActionType.ADD) {
 132             serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 133         }
 134         serviceA.setServiceState("active");
 135         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 136         serviceSpecificationRefA.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
 137         serviceA.setServiceSpecification(serviceSpecificationRefA);
 138         itemA.setService(serviceA);
 139         items.add(itemA);
 140
 141         ServiceOrderItem itemB = new ServiceOrderItem();
 142         itemB.id("B");
 143         itemB.action(actionType);
 144         Service serviceB = new Service();
 145         if (actionType != ActionType.ADD) {
 146             serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 147         }
 148         serviceB.setServiceState("active");
 149         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 150         serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
 151         serviceB.setServiceSpecification(serviceSpecificationRefB);
 152         itemB.setService(serviceB);
 153         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 154         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 155         orderItemRelationship.setId("A");
 156         orderItemRelationship.setType(RelationshipType.RELIESON);
 157         orderItemRelationships.add(orderItemRelationship);
 158         itemB.setOrderItemRelationship(orderItemRelationships);
 159         items.add(itemB);
 160         serviceOrder.setOrderItem(items);
 161         return serviceOrder;
 162
 163     }
 164
 165     public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 166             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 167         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 168
 169         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 170             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 171         }
 172
 173         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 174         testServiceOrder.setId("test");
 175         serviceOrderRepository.save(testServiceOrder);
 176
 177         LinkedHashMap<String, String> sdcResponse = new LinkedHashMap<>();
 178         sdcResponse.put("invariantUUID", "uuid");
 179         sdcResponse.put("name", "vFW");
 180         sdcResponse.put("version", "v1");
 181         sdcResponse.put("category", "NonE2E");
 182
 183         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 184         serviceOrderInfo.setServiceOrderId("test");
 185         SubscriberInfo subscriberInfo = new SubscriberInfo();
 186         subscriberInfo.setGlobalSubscriberId("6490");
 187         subscriberInfo.setSubscriberName("edgar");
 188         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 189
 190         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 191         serviceOrderItemInfoA.setId("A");
 192         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 193
 194         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 195         serviceOrderItemInfoB.setId("B");
 196         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 197         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 198         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 199
 200         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 201
 202         ExecutionTask executionTaskA = new ExecutionTask();
 203         executionTaskA.setCreateDate(new Date());
 204         executionTaskA.setOrderItemId("A");
 205         executionTaskA.setServiceOrderInfoJson(json);
 206         executionTaskA = executionTaskRepository.save(executionTaskA);
 207         ExecutionTask executionTaskB = new ExecutionTask();
 208         executionTaskB.setCreateDate(new Date());
 209         executionTaskB.setOrderItemId("B");
 210         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 211         executionTaskB.setServiceOrderInfoJson(json);
 212         executionTaskRepository.save(executionTaskB);
 213         return executionTaskA;
 214     }
 215
 216     public static ExecutionTask setUpBddForE2EExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 217             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 218         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 219
 220         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 221             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 222             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 223             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 224             serviceCharacteristic1.setName("access-site-id");
 225             Value value1 = new Value();
 226             value1.setServiceCharacteristicValue("1234765");
 227             serviceCharacteristic1.setValue(value1);
 228             serviceCharacteristics.add(serviceCharacteristic1);
 229             ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 230             serviceCharacteristic2.setName("provider-site-id");
 231             Value value2 = new Value();
 232             value2.setServiceCharacteristicValue("654321");
 233             serviceCharacteristic2.setValue(value2);
 234             serviceCharacteristics.add(serviceCharacteristic2);
 235             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 236         }
 237
 238         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 239         testServiceOrder.setId("test");
 240         serviceOrderRepository.save(testServiceOrder);
 241
 242         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 243         sdcResponse.put("invariantUUID", "uuid");
 244         sdcResponse.put("name", "vFW");
 245         sdcResponse.put("version", "v1");
 246         sdcResponse.put("category", "E2E Service");
 247
 248         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 249         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 250         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 251         resourceSpecificationA.setInstanceName("vFW-vSINK");
 252         resourceSpecificationA.setName("vFW-SINK");
 253         resourceSpecificationA.setType("ONAPresource");
 254         resourceSpecificationA.setVersion("2.0");
 255         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 256         resourceSpecs.add(resourceSpecificationA);
 257
 258         sdcResponse.put("resourceSpecification", resourceSpecs);
 259
 260         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 261         serviceOrderInfo.setServiceOrderId("test");
 262         SubscriberInfo subscriberInfo = new SubscriberInfo();
 263         subscriberInfo.setGlobalSubscriberId("6490");
 264         subscriberInfo.setSubscriberName("edgar");
 265         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 266
 267         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 268         serviceOrderItemInfoA.setId("A");
 269         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 270
 271         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 272         serviceOrderItemInfoB.setId("B");
 273         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 274         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 275         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 276
 277         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 278
 279         ExecutionTask executionTaskA = new ExecutionTask();
 280         executionTaskA.setCreateDate(new Date());
 281         executionTaskA.setOrderItemId("A");
 282         executionTaskA.setServiceOrderInfoJson(json);
 283         executionTaskA = executionTaskRepository.save(executionTaskA);
 284         ExecutionTask executionTaskB = new ExecutionTask();
 285         executionTaskB.setCreateDate(new Date());
 286         executionTaskB.setOrderItemId("B");
 287         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 288         executionTaskB.setServiceOrderInfoJson(json);
 289         executionTaskRepository.save(executionTaskB);
 290         return executionTaskA;
 291     }
 292
 293     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithObject(
 294             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 295             ActionType actionType) {
 296         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 297
 298         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 299             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 300             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 301             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 302             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 303             serviceCharacteristic1.setValueType("object");
 304             Value value1 = new Value();
 305             value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
 306             serviceCharacteristic1.setValue(value1);
 307             serviceCharacteristics.add(serviceCharacteristic1);
 308             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 309         }
 310
 311         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 312         testServiceOrder.setId("test");
 313         serviceOrderRepository.save(testServiceOrder);
 314
 315         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 316         sdcResponse.put("invariantUUID", "uuid");
 317         sdcResponse.put("name", "vFW");
 318         sdcResponse.put("version", "v1");
 319         sdcResponse.put("category", "E2E Service");
 320
 321         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 322         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 323         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 324         resourceSpecificationA.setInstanceName("vFW-vSINK");
 325         resourceSpecificationA.setName("vFW-SINK");
 326         resourceSpecificationA.setType("ONAPresource");
 327         resourceSpecificationA.setVersion("2.0");
 328         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 329         resourceSpecs.add(resourceSpecificationA);
 330
 331         sdcResponse.put("resourceSpecification", resourceSpecs);
 332
 333         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 334         serviceOrderInfo.setServiceOrderId("test");
 335         SubscriberInfo subscriberInfo = new SubscriberInfo();
 336         subscriberInfo.setGlobalSubscriberId("6490");
 337         subscriberInfo.setSubscriberName("edgar");
 338         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 339
 340         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 341         serviceOrderItemInfoA.setId("A");
 342         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 343
 344         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 345         serviceOrderItemInfoB.setId("B");
 346         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 347         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 348         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 349
 350         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 351
 352         ExecutionTask executionTaskA = new ExecutionTask();
 353         executionTaskA.setCreateDate(new Date());
 354         executionTaskA.setOrderItemId("A");
 355         executionTaskA.setServiceOrderInfoJson(json);
 356         executionTaskA = executionTaskRepository.save(executionTaskA);
 357         ExecutionTask executionTaskB = new ExecutionTask();
 358         executionTaskB.setCreateDate(new Date());
 359         executionTaskB.setOrderItemId("B");
 360         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 361         executionTaskB.setServiceOrderInfoJson(json);
 362         executionTaskRepository.save(executionTaskB);
 363         return executionTaskA;
 364     }
 365
 366     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithComplexObject(
 367             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 368             ActionType actionType) {
 369         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 370
 371         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 372             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 373             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 374             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 375             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 376             serviceCharacteristic1.setValueType("object");
 377             Value value1 = new Value();
 378             // Three parameters , one is an array of child objects
 379             value1.setServiceCharacteristicValue(
 380                     "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
 381             serviceCharacteristic1.setValue(value1);
 382             serviceCharacteristics.add(serviceCharacteristic1);
 383             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 384         }
 385
 386         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 387         testServiceOrder.setId("test");
 388         serviceOrderRepository.save(testServiceOrder);
 389
 390         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 391         sdcResponse.put("invariantUUID", "uuid");
 392         sdcResponse.put("name", "vFW");
 393         sdcResponse.put("version", "v1");
 394         sdcResponse.put("category", "E2E Service");
 395
 396         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 397         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 398         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 399         resourceSpecificationA.setInstanceName("vFW-vSINK");
 400         resourceSpecificationA.setName("vFW-SINK");
 401         resourceSpecificationA.setType("ONAPresource");
 402         resourceSpecificationA.setVersion("2.0");
 403         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 404         resourceSpecs.add(resourceSpecificationA);
 405
 406         sdcResponse.put("resourceSpecification", resourceSpecs);
 407
 408         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 409         serviceOrderInfo.setServiceOrderId("test");
 410         SubscriberInfo subscriberInfo = new SubscriberInfo();
 411         subscriberInfo.setGlobalSubscriberId("6490");
 412         subscriberInfo.setSubscriberName("edgar");
 413         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 414
 415         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 416         serviceOrderItemInfoA.setId("A");
 417         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 418
 419         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 420         serviceOrderItemInfoB.setId("B");
 421         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 422         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 423         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 424
 425         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 426
 427         ExecutionTask executionTaskA = new ExecutionTask();
 428         executionTaskA.setCreateDate(new Date());
 429         executionTaskA.setOrderItemId("A");
 430         executionTaskA.setServiceOrderInfoJson(json);
 431         executionTaskA = executionTaskRepository.save(executionTaskA);
 432         ExecutionTask executionTaskB = new ExecutionTask();
 433         executionTaskB.setCreateDate(new Date());
 434         executionTaskB.setOrderItemId("B");
 435         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 436         executionTaskB.setServiceOrderInfoJson(json);
 437         executionTaskRepository.save(executionTaskB);
 438         return executionTaskA;
 439     }
 440 }