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