catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogic.java

   1 /*
   2  * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.be.components.impl;
  17
  18 import static java.util.stream.Collectors.joining;
  19 import static java.util.stream.Collectors.toList;
  20 import static java.util.stream.Collectors.toMap;
  21 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
  22 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
  23 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
  24 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
  25 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
  26
  27 import com.google.gson.Gson;
  28 import com.google.gson.JsonElement;
  29 import com.google.gson.JsonObject;
  30 import com.google.gson.JsonParser;
  31 import fj.data.Either;
  32 import java.util.ArrayList;
  33 import java.util.Collection;
  34 import java.util.Collections;
  35 import java.util.EnumMap;
  36 import java.util.HashMap;
  37 import java.util.HashSet;
  38 import java.util.Iterator;
  39 import java.util.LinkedHashMap;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Map.Entry;
  43 import java.util.Optional;
  44 import java.util.Set;
  45 import java.util.TreeSet;
  46 import java.util.concurrent.atomic.AtomicReference;
  47 import java.util.regex.Pattern;
  48 import java.util.stream.Collectors;
  49 import lombok.Getter;
  50 import lombok.Setter;
  51 import org.apache.commons.collections.CollectionUtils;
  52 import org.apache.commons.collections.MapUtils;
  53 import org.apache.commons.lang3.StringUtils;
  54 import org.apache.commons.lang3.tuple.ImmutablePair;
  55 import org.json.simple.JSONObject;
  56 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
  57 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
  58 import org.openecomp.sdc.be.components.csar.CsarInfo;
  59 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
  60 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  61 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  62 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  63 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  64 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  65 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
  66 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
  67 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
  68 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  69 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  70 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
  71 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  72 import org.openecomp.sdc.be.config.ConfigurationManager;
  73 import org.openecomp.sdc.be.dao.api.ActionStatus;
  74 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  75 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  76 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
  77 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  78 import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction;
  79 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  80 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  81 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  82 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
  83 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  84 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  85 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
  86 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  87 import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction;
  88 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
  89 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  90 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  91 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  92 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
  93 import org.openecomp.sdc.be.impl.ComponentsUtils;
  94 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
  95 import org.openecomp.sdc.be.model.ArtifactDefinition;
  96 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
  97 import org.openecomp.sdc.be.model.AttributeDefinition;
  98 import org.openecomp.sdc.be.model.CapabilityDefinition;
  99 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
 100 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
 101 import org.openecomp.sdc.be.model.Component;
 102 import org.openecomp.sdc.be.model.ComponentInstance;
 103 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
 104 import org.openecomp.sdc.be.model.ComponentInstanceInput;
 105 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 106 import org.openecomp.sdc.be.model.ComponentParametersView;
 107 import org.openecomp.sdc.be.model.DataTypeDefinition;
 108 import org.openecomp.sdc.be.model.DistributionStatusEnum;
 109 import org.openecomp.sdc.be.model.GroupDefinition;
 110 import org.openecomp.sdc.be.model.GroupTypeDefinition;
 111 import org.openecomp.sdc.be.model.InputDefinition;
 112 import org.openecomp.sdc.be.model.InterfaceDefinition;
 113 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
 114 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 115 import org.openecomp.sdc.be.model.NodeTypeDefinition;
 116 import org.openecomp.sdc.be.model.NodeTypeInfo;
 117 import org.openecomp.sdc.be.model.NodeTypeMetadata;
 118 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
 119 import org.openecomp.sdc.be.model.Operation;
 120 import org.openecomp.sdc.be.model.OutputDefinition;
 121 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
 122 import org.openecomp.sdc.be.model.PolicyDefinition;
 123 import org.openecomp.sdc.be.model.PropertyDefinition;
 124 import org.openecomp.sdc.be.model.RelationshipImpl;
 125 import org.openecomp.sdc.be.model.RelationshipInfo;
 126 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
 127 import org.openecomp.sdc.be.model.RequirementDefinition;
 128 import org.openecomp.sdc.be.model.Resource;
 129 import org.openecomp.sdc.be.model.Service;
 130 import org.openecomp.sdc.be.model.UploadAttributeInfo;
 131 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
 132 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
 133 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
 134 import org.openecomp.sdc.be.model.UploadPropInfo;
 135 import org.openecomp.sdc.be.model.UploadReqInfo;
 136 import org.openecomp.sdc.be.model.UploadResourceInfo;
 137 import org.openecomp.sdc.be.model.User;
 138 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 139 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
 140 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
 141 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
 142 import org.openecomp.sdc.be.model.normatives.ToscaTypeMetadata;
 143 import org.openecomp.sdc.be.model.operations.StorageException;
 144 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
 145 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 146 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
 147 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
 148 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
 149 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 150 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
 151 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
 152 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 153 import org.openecomp.sdc.be.tosca.CsarUtils;
 154 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
 155 import org.openecomp.sdc.be.ui.model.OperationUi;
 156 import org.openecomp.sdc.be.utils.TypeUtils;
 157 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
 158 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 159 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
 160 import org.openecomp.sdc.common.api.Constants;
 161 import org.openecomp.sdc.common.datastructure.Wrapper;
 162 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
 163 import org.openecomp.sdc.common.log.wrappers.Logger;
 164 import org.openecomp.sdc.common.util.ValidationUtils;
 165 import org.openecomp.sdc.exception.ResponseFormat;
 166 import org.springframework.beans.factory.annotation.Autowired;
 167 import org.yaml.snakeyaml.Yaml;
 168
 169 @Getter
 170 @Setter
 171 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
 172 public class ServiceImportBusinessLogic {
 173
 174     protected static final String CREATE_RESOURCE = "Create Resource";
 175     private static final String INITIAL_VERSION = "0.1";
 176     private static final String IN_RESOURCE = " in resource {} ";
 177     private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
 178     private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {}  in resource {} ";
 179     private static final String CERTIFICATION_ON_IMPORT = "certification on import";
 180     private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
 181     private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
 182     private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
 183     private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
 184     private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
 185
 186     private final ComponentsUtils componentsUtils;
 187     private final ToscaOperationFacade toscaOperationFacade;
 188     private final ServiceBusinessLogic serviceBusinessLogic;
 189     private final CsarBusinessLogic csarBusinessLogic;
 190     private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
 191     private final LifecycleBusinessLogic lifecycleBusinessLogic;
 192     private final CompositionBusinessLogic compositionBusinessLogic;
 193     private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
 194     private final ServiceImportParseLogic serviceImportParseLogic;
 195     private final GroupBusinessLogic groupBusinessLogic;
 196     private final PolicyBusinessLogic policyBusinessLogic;
 197     private final ResourceImportManager resourceImportManager;
 198     private final JanusGraphDao janusGraphDao;
 199     private final ArtifactsBusinessLogic artifactsBusinessLogic;
 200     private final ArtifactTypeImportManager artifactTypeImportManager;
 201     private final IGraphLockOperation graphLockOperation;
 202     private final ToscaFunctionService toscaFunctionService;
 203     private final DataTypeBusinessLogic dataTypeBusinessLogic;
 204     private ApplicationDataTypeCache applicationDataTypeCache;
 205     private final ArtifactTypeOperation artifactTypeOperation;
 206
 207     private final GroupTypeImportManager groupTypeImportManager;
 208     private final GroupTypeOperation groupTypeOperation;
 209     private InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
 210     private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
 211
 212     private final CapabilityTypeImportManager capabilityTypeImportManager;
 213     private final CapabilityTypeOperation capabilityTypeOperation;
 214
 215     public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
 216                                       final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
 217                                       final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic,
 218                                       final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
 219                                       final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
 220                                       final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
 221                                       final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic,
 222                                       final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao,
 223                                       final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService,
 224                                       final DataTypeBusinessLogic dataTypeBusinessLogic, final ArtifactTypeOperation artifactTypeOperation,
 225                                       final ArtifactTypeImportManager artifactTypeImportManager, final GroupTypeImportManager groupTypeImportManager,
 226                                       final GroupTypeOperation groupTypeOperation,
 227                                       final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
 228                                       final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
 229                                       final CapabilityTypeImportManager capabilityTypeImportManager,
 230                                       final CapabilityTypeOperation capabilityTypeOperation) {
 231         this.componentsUtils = componentsUtils;
 232         this.toscaOperationFacade = toscaOperationFacade;
 233         this.serviceBusinessLogic = serviceBusinessLogic;
 234         this.csarBusinessLogic = csarBusinessLogic;
 235         this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
 236         this.lifecycleBusinessLogic = lifecycleBusinessLogic;
 237         this.compositionBusinessLogic = compositionBusinessLogic;
 238         this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
 239         this.serviceImportParseLogic = serviceImportParseLogic;
 240         this.groupBusinessLogic = groupBusinessLogic;
 241         this.policyBusinessLogic = policyBusinessLogic;
 242         this.resourceImportManager = resourceImportManager;
 243         this.janusGraphDao = janusGraphDao;
 244         this.artifactsBusinessLogic = artifactsBusinessLogic;
 245         this.graphLockOperation = graphLockOperation;
 246         this.toscaFunctionService = toscaFunctionService;
 247         this.dataTypeBusinessLogic = dataTypeBusinessLogic;
 248         this.artifactTypeOperation = artifactTypeOperation;
 249         this.artifactTypeImportManager = artifactTypeImportManager;
 250         this.groupTypeImportManager = groupTypeImportManager;
 251         this.groupTypeOperation = groupTypeOperation;
 252         this.interfaceLifecycleTypeOperation = interfaceLifecycleTypeOperation;
 253         this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
 254         this.capabilityTypeImportManager = capabilityTypeImportManager;
 255         this.capabilityTypeOperation = capabilityTypeOperation;
 256     }
 257
 258     @Autowired
 259     public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
 260         this.applicationDataTypeCache = applicationDataTypeCache;
 261     }
 262
 263     public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
 264                                  String payloadName) {
 265         log.debug("enter createService");
 266         service.setCreatorUserId(user.getUserId());
 267         service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 268         service.setVersion(INITIAL_VERSION);
 269         service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
 270         service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 271         try {
 272             final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
 273             if (serviceBeforeCreate.isRight()) {
 274                 throw new ComponentException(ActionStatus.GENERAL_ERROR);
 275             }
 276             log.debug("enter createService,validateServiceBeforeCreate success");
 277             String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
 278             log.debug("enter createService,get csarUUID:{}", csarUUID);
 279             csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
 280             log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
 281             return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
 282         } catch (final ComponentException e) {
 283             log.debug("Exception occurred when createService: {}", e.getMessage(), e);
 284             throw e;
 285         } catch (final Exception e) {
 286             log.debug("Exception occurred when createService: {}", e.getMessage(), e);
 287             throw new ComponentException(ActionStatus.GENERAL_ERROR);
 288         }
 289     }
 290
 291     protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
 292         log.trace("************* created successfully from YAML, resource TOSCA ");
 293         try {
 294             ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
 295
 296             final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(service.getModel(), csarInfo);
 297             if (MapUtils.isNotEmpty(dataTypesToCreate)) {
 298                 dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), service.getModel(), true);
 299                 dataTypesToCreate.entrySet().stream().forEach(createdOrUpdatedDataType -> {
 300                     applicationDataTypeCache.reload(service.getModel(),
 301                         UniqueIdBuilder.buildDataTypeUid(service.getModel(), createdOrUpdatedDataType.getKey()));
 302                 });
 303             }
 304
 305             final Map<String, Object> artifactTypesToCreate = getArtifactTypesToCreate(service.getModel(), csarInfo);
 306             if (MapUtils.isNotEmpty(artifactTypesToCreate)) {
 307                 artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), service.getModel(), true);
 308             }
 309
 310             final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(service.getModel(), csarInfo);
 311             if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
 312                 createNodeTypes(nodeTypesToCreate, service.getModel(), csarInfo.getModifier());
 313             }
 314
 315             final Map<String, Object> groupTypesToCreate = getGroupTypesToCreate(service.getModel(), csarInfo);
 316             if (MapUtils.isNotEmpty(groupTypesToCreate)) {
 317                 final Map<String, ToscaTypeMetadata> toscaTypeMetadata = fillToscaTypeMetadata(groupTypesToCreate);
 318                 final ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(new Yaml().dump(groupTypesToCreate), toscaTypeMetadata);
 319                 groupTypeImportManager.createGroupTypes(toscaTypeImportData, service.getModel(), true);
 320             }
 321
 322             final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(service.getModel(), csarInfo);
 323             if (MapUtils.isNotEmpty(interfaceTypesToCreate)) {
 324                 interfaceLifecycleTypeImportManager
 325                     .createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), service.getModel(), true);
 326             }
 327
 328             final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(service.getModel(), csarInfo);
 329
 330             if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
 331                 capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), service.getModel(), true);
 332             }
 333
 334             Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
 335             Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
 336                 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
 337             if (findNodeTypesArtifactsToHandleRes.isRight()) {
 338                 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
 339                 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
 340             }
 341             return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
 342                 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
 343         } catch (final ComponentException e) {
 344             log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
 345             throw e;
 346         } catch (final Exception e) {
 347             log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
 348             throw new ComponentException(ActionStatus.GENERAL_ERROR);
 349         }
 350     }
 351
 352     private Map<String, ToscaTypeMetadata> fillToscaTypeMetadata(final Map<String, Object> groupTypesToCreate) {
 353         final Map<String, ToscaTypeMetadata> toscaTypeMetadata = new HashMap<>();
 354         groupTypesToCreate.entrySet().forEach(entry -> {
 355             final ToscaTypeMetadata metadata = new ToscaTypeMetadata();
 356             metadata.setIcon(getIconFromGroupType(entry.getValue()));
 357             metadata.setDisplayName(extractDisplayName(entry.getKey()));
 358             toscaTypeMetadata.put(entry.getKey(), metadata);
 359         });
 360         return toscaTypeMetadata;
 361     }
 362
 363     private String extractDisplayName(final String key) {
 364         final String[] split = key.split("\\.");
 365         return split[split.length - 1];
 366     }
 367
 368     private String getIconFromGroupType(final Object value) {
 369         final Either<GroupTypeDefinition, StorageOperationStatus> groupType = groupTypeOperation.getLatestGroupTypeByType(
 370             (String) ((LinkedHashMap) value).get(ToscaTagNamesEnum.DERIVED_FROM.getElementName()), null);
 371         if (groupType.isLeft()) {
 372             return groupType.left().value().getIcon();
 373         }
 374         return null;
 375     }
 376
 377     private Map<String, Object> getGroupTypesToCreate(final String model, final CsarInfo csarInfo) {
 378         final Map<String, Object> groupTypesToCreate = new HashMap<>();
 379         final Map<String, Object> groupTypes = csarInfo.getGroupTypes();
 380         if (MapUtils.isNotEmpty(groupTypes)) {
 381             for (final Entry<String, Object> entry : groupTypes.entrySet()) {
 382                 final Either<GroupTypeDefinition, StorageOperationStatus> result
 383                     = groupTypeOperation.getGroupTypeByUid(UniqueIdBuilder.buildGroupTypeUid(model, entry.getKey(), "1.0"));
 384                 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
 385                     groupTypesToCreate.put(entry.getKey(), entry.getValue());
 386                     log.info("Deploying new group type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
 387                 }
 388             }
 389         }
 390         return groupTypesToCreate;
 391     }
 392
 393     private Map<String, Object> getCapabilityTypesToCreate(final String model, final CsarInfo csarInfo) {
 394         final Map<String, Object> capabilityTypesToCreate = new HashMap<>();
 395         final Map<String, Object> capabilityTypes = csarInfo.getCapabilityTypes();
 396         if (MapUtils.isNotEmpty(capabilityTypes)) {
 397             for (final Entry<String, Object> entry : capabilityTypes.entrySet()) {
 398                 final Either<CapabilityTypeDefinition, StorageOperationStatus> result
 399                     = capabilityTypeOperation.getCapabilityType(UniqueIdBuilder.buildCapabilityTypeUid(model, entry.getKey()));
 400                 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
 401                     capabilityTypesToCreate.put(entry.getKey(), entry.getValue());
 402                     log.info("Deploying new capability type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
 403                 }
 404             }
 405         }
 406         return capabilityTypesToCreate;
 407     }
 408
 409     private Map<String, Object> getDatatypesToCreate(final String model, final CsarInfo csarInfo) {
 410         final Map<String, Object> dataTypesToCreate = new HashMap<>();
 411
 412         for (final Entry<String, Object> dataTypeEntry : csarInfo.getDataTypes().entrySet()) {
 413             final Either<DataTypeDefinition, JanusGraphOperationStatus> result = applicationDataTypeCache.get(model,
 414                 UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey()));
 415             if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) {
 416                 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
 417                 log.info("Deploying unknown type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
 418             }
 419             if (hasNewProperties(result, (Map<String, Map<String, Object>>) dataTypeEntry.getValue())) {
 420                 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
 421                 log.info("Deploying new version of type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
 422             }
 423         }
 424         return dataTypesToCreate;
 425     }
 426
 427     private Map<String, Object> getArtifactTypesToCreate(final String model, final CsarInfo csarInfo) {
 428         final Map<String, Object> artifactTypesToCreate = new HashMap<>();
 429         final Map<String, Object> artifactTypesMap = csarInfo.getArtifactTypes();
 430         if (MapUtils.isNotEmpty(artifactTypesMap)) {
 431             for (final Entry<String, Object> artifactTypeEntry : artifactTypesMap.entrySet()) {
 432                 final Either<ArtifactTypeDefinition, StorageOperationStatus> result =
 433                     artifactTypeOperation.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(model, artifactTypeEntry.getKey()));
 434                 if (result.isRight() && StorageOperationStatus.NOT_FOUND.equals(result.right().value())) {
 435                     artifactTypesToCreate.put(artifactTypeEntry.getKey(), artifactTypeEntry.getValue());
 436                     log.info("Deploying new artifact type={}, to model={}, from package={}",
 437                         artifactTypeEntry.getKey(), model, csarInfo.getCsarUUID());
 438                 }
 439             }
 440         }
 441         return artifactTypesToCreate;
 442     }
 443
 444     private Map<String, Object> getInterfaceTypesToCreate(final String model, final CsarInfo csarInfo) {
 445         final Map<String, Object> interfaceTypesToCreate = new HashMap<>();
 446         Map<String, Object> interfacetypeMap = csarInfo.getInterfaceTypes();
 447
 448         interfacetypeMap.entrySet().forEach(interfacetypeDef -> {
 449             Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinition =
 450                 interfaceLifecycleTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(model, interfacetypeDef.getKey()));
 451             if (interfaceDefinition.isRight() && interfaceDefinition.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
 452                 interfaceTypesToCreate.put(interfacetypeDef.getKey(), interfacetypeDef.getValue());
 453             }
 454         });
 455         return interfaceTypesToCreate;
 456     }
 457
 458     private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result,
 459                                      final Map<String, Map<String, Object>> dataType) {
 460         return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
 461             && result.left().value().getProperties().size() != dataType.get("properties").size();
 462     }
 463
 464     private void createNodeTypes(List<NodeTypeDefinition> nodeTypesToCreate, String model, User user) {
 465         NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
 466         List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
 467         final Map<String, Object> allTypesToCreate = new HashMap<>();
 468         nodeTypesToCreate.stream().forEach(nodeType -> {
 469             allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
 470             nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
 471         });
 472         nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
 473         resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, user, model, true, false);
 474     }
 475
 476     private List<NodeTypeDefinition> getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) {
 477         List<NodeTypeDefinition> namesOfNodeTypesToCreate = new ArrayList<>();
 478
 479         for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) {
 480             Either<Component, StorageOperationStatus> result = toscaOperationFacade
 481                 .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model);
 482             if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
 483                 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
 484             } else if (result.isLeft()) {
 485                 Resource latestResource = (Resource) result.left().value();
 486                 Entry<String, Object> existingMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(),
 487                     latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId());
 488                 Map<String, Object> newMappedToscaTemplate = (Map<String, Object>) nodeTypeDefinition.getMappedNodeType().getValue();
 489                 Map<String, Object> combinedMappedToscaTemplate =
 490                     getNewChangesToToscaTemplate(newMappedToscaTemplate, (Map<String, Object>) existingMappedToscaTemplate.getValue());
 491                 if (!combinedMappedToscaTemplate.equals(existingMappedToscaTemplate.getValue())) {
 492                     existingMappedToscaTemplate.setValue(combinedMappedToscaTemplate);
 493                     nodeTypeDefinition.setMappedNodeType(existingMappedToscaTemplate);
 494                     namesOfNodeTypesToCreate.add(nodeTypeDefinition);
 495                 }
 496             }
 497         }
 498         return namesOfNodeTypesToCreate;
 499     }
 500
 501     private Entry<String, Object> getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) {
 502         String assetToToscaTemplate = assetToscaTemplate.getUniqueId();
 503         ImmutablePair<String, byte[]> toscaTemplate = artifactsBusinessLogic.
 504             handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null);
 505         Map<String, Object> mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right));
 506         Either<Map<String, Object>, ImportUtils.ResultStatusEnum> eitherNodeTypes =
 507             findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
 508         if (eitherNodeTypes.isRight()) {
 509             throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
 510         }
 511         return eitherNodeTypes.left().value().entrySet().iterator().next();
 512     }
 513
 514     private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> newMappedToscaTemplate,
 515                                                              Map<String, Object> existingMappedToscaTemplate) {
 516         Map<String, Object> combinedMappedToscaTemplate = new HashMap<>(existingMappedToscaTemplate);
 517         combinePropertiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("properties"),
 518             (Map<String, Object>) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate);
 519         combineAttributesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("attributes"),
 520             (Map<String, Object>) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate);
 521         combineRequirementsIntoToscaTemplate((List<Map<String, Object>>) newMappedToscaTemplate.get("requirements"),
 522             (List<Map<String, Object>>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate);
 523         combineCapabilitiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("capabilities"),
 524             (Map<String, Object>) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate);
 525         combineInterfacesIntoToscaTemplate((Map<String, Map<String, Object>>) newMappedToscaTemplate.get("interfaces"),
 526             (Map<String, Map<String, Object>>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate);
 527         return combinedMappedToscaTemplate;
 528     }
 529
 530     private void combineInterfacesIntoToscaTemplate(Map<String, Map<String, Object>> newInterfaces,
 531                                                     Map<String, Map<String, Object>> existingInterfaces,
 532                                                     Map<String, Object> combinedMappedToscaTemplate) {
 533         Map<String, Map<String, Object>> combinedInterfaces = combineAdditionalInterfaces(existingInterfaces, newInterfaces);
 534         if ((MapUtils.isEmpty(existingInterfaces) && MapUtils.isNotEmpty(combinedInterfaces))
 535             || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) {
 536             combinedMappedToscaTemplate.put("interfaces", combinedInterfaces);
 537         }
 538     }
 539
 540     private void combineCapabilitiesIntoToscaTemplate(Map<String, Object> newCapabilities, Map<String, Object> existingCapabilities,
 541                                                       Map<String, Object> combinedMappedToscaTemplate) {
 542         Map<String, Object> combinedCapabilities = combineEntries(newCapabilities, existingCapabilities);
 543         if ((MapUtils.isEmpty(existingCapabilities) && MapUtils.isNotEmpty(combinedCapabilities)) ||
 544             (MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) {
 545             combinedMappedToscaTemplate.put("capabilities", combinedCapabilities);
 546         }
 547     }
 548
 549     private void combineRequirementsIntoToscaTemplate(List<Map<String, Object>> newRequirements, List<Map<String, Object>> existingRequirements,
 550                                                       Map<String, Object> combinedMappedToscaTemplate) {
 551         List<Map<String, Object>> combinedRequirements = combineAdditionalRequirements(newRequirements, existingRequirements);
 552         if ((CollectionUtils.isEmpty(existingRequirements) && CollectionUtils.isNotEmpty(combinedRequirements))
 553             || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) {
 554             combinedMappedToscaTemplate.put("requirements", combinedRequirements);
 555         }
 556     }
 557
 558     private void combineAttributesIntoToscaTemplate(Map<String, Object> newAttributes, Map<String, Object> existingAttributes,
 559                                                     Map<String, Object> combinedMappedToscaTemplate) {
 560         Map<String, Object> combinedAttributes = combineEntries(newAttributes, existingAttributes);
 561         if ((MapUtils.isEmpty(existingAttributes) && MapUtils.isNotEmpty(combinedAttributes)) ||
 562             (MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) {
 563             combinedMappedToscaTemplate.put("attributes", combinedAttributes);
 564         }
 565     }
 566
 567     private void combinePropertiesIntoToscaTemplate(Map<String, Object> newProperties, Map<String, Object> existingProperties,
 568                                                     Map<String, Object> combinedMappedToscaTemplate) {
 569         Map<String, Object> combinedProperties = combineEntries(newProperties, existingProperties);
 570         if ((MapUtils.isEmpty(existingProperties) && MapUtils.isNotEmpty(combinedProperties)) ||
 571             (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) {
 572             combinedMappedToscaTemplate.put("properties", combinedProperties);
 573         }
 574     }
 575
 576     private Map<String, Map<String, Object>> combineAdditionalInterfaces(Map<String, Map<String, Object>> existingInterfaces,
 577                                                                          Map<String, Map<String, Object>> newInterfaces) {
 578         if (MapUtils.isEmpty(newInterfaces)) {
 579             newInterfaces = new HashMap<>();
 580         }
 581         Map<String, Map<String, Object>> combinedEntries = new HashMap<>(newInterfaces);
 582         if (MapUtils.isEmpty(existingInterfaces)) {
 583             return combinedEntries;
 584         }
 585         existingInterfaces.entrySet().forEach(interfaceDef -> {
 586             combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals((interfaceDef.getValue()).get("type")))
 587                 .findFirst().ifPresentOrElse((interFace) -> {
 588                     interFace.getValue().putAll(interfaceDef.getValue());
 589                 }, () -> {
 590                     combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue());
 591                 });
 592         });
 593         return combinedEntries;
 594     }
 595
 596     private List<Map<String, Object>> combineAdditionalRequirements(List<Map<String, Object>> newReqs,
 597                                                                     List<Map<String, Object>> existingResourceReqs) {
 598         if (CollectionUtils.isEmpty(existingResourceReqs)) {
 599             existingResourceReqs = new ArrayList<>();
 600         }
 601         Set<Map<String, Object>> combinedReqs = new TreeSet<>((map1, map2) ->
 602             map1.keySet().equals(map2.keySet()) ? 0 : map1.keySet().iterator().next().compareTo(map2.keySet().iterator().next()));
 603         combinedReqs.addAll(existingResourceReqs);
 604         if (CollectionUtils.isEmpty(newReqs)) {
 605             return new ArrayList<>(combinedReqs);
 606         }
 607         combinedReqs.addAll(newReqs);
 608         return new ArrayList<>(combinedReqs);
 609     }
 610
 611     private Map<String, Object> combineEntries(Map<String, Object> newMap, Map<String, Object> existingMap) {
 612         if (MapUtils.isEmpty(newMap)) {
 613             newMap = new HashMap<>();
 614         }
 615         Map<String, Object> combinedEntries = new HashMap<>(newMap);
 616         if (MapUtils.isEmpty(existingMap)) {
 617             return combinedEntries;
 618         }
 619         combinedEntries.putAll(existingMap);
 620         return combinedEntries;
 621     }
 622
 623     protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
 624                                             CsarInfo csarInfo,
 625                                             Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
 626                                             boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
 627         throws BusinessLogicException {
 628         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 629         Service createdService;
 630         CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
 631         try {
 632             ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
 633                 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
 634             log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
 635             csfyp.setYamlName(yamlName);
 636             csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
 637             csfyp.setCreatedArtifacts(createdArtifacts);
 638             csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
 639             csfyp.setNodeTypesInfo(nodeTypesInfo);
 640             csfyp.setCsarInfo(csarInfo);
 641             csfyp.setNodeName(nodeName);
 642             createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
 643             log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
 644         } catch (ComponentException | BusinessLogicException e) {
 645             log.debug("Create Service from yaml failed", e);
 646             throw e;
 647         } catch (StorageException e) {
 648             log.debug("create Service From Yaml failed,get StorageException:{}", e);
 649             throw e;
 650         }
 651         return createdService;
 652     }
 653
 654     protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
 655                                                   Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
 656                                                   boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
 657                                                   final String userId)
 658         throws BusinessLogicException {
 659         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 660         String yamlName = csfyp.getYamlName();
 661         ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
 662         List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
 663         String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
 664         Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
 665         CsarInfo csarInfo = csfyp.getCsarInfo();
 666         String nodeName = csfyp.getNodeName();
 667         if (shouldLock) {
 668             Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
 669             if (lockResult.isRight()) {
 670                 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 671                 throw new ComponentException(lockResult.right().value());
 672             }
 673             log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
 674         }
 675         boolean rollback = false;
 676         try {
 677             log.trace("************* Adding properties to service from interface yaml {}", yamlName);
 678             Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
 679             if (properties != null && !properties.isEmpty()) {
 680                 final List<PropertyDefinition> propertiesList = new ArrayList<>();
 681                 properties.forEach((propertyName, propertyDefinition) -> {
 682                     propertyDefinition.setName(propertyName);
 683                     propertiesList.add(propertyDefinition);
 684                 });
 685                 service.setProperties(propertiesList);
 686             }
 687             log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
 688             service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
 689             log.trace("************* Going to add inputs from yaml {}", yamlName);
 690             Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
 691             service = serviceImportParseLogic.createInputsOnService(service, inputs);
 692             log.trace("************* Finished to add inputs from yaml {}", yamlName);
 693             ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
 694             service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
 695             log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
 696             Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
 697             log.trace("************* Going to create nodes, RI's and Relations  from yaml {}", yamlName);
 698             service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
 699                 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
 700             log.trace("************* Finished to create nodes, RI and Relation  from yaml {}", yamlName);
 701             log.trace("************* Going to add outputs from yaml {}", yamlName);
 702             Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
 703             service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
 704             log.trace("************* Finished to add outputs from yaml {}", yamlName);
 705
 706             Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
 707                 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
 708             if (validateUpdateVfGroupNamesRes.isRight()) {
 709                 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 710                 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
 711             }
 712             Map<String, GroupDefinition> groups;
 713             log.trace("************* Going to add groups from yaml {}", yamlName);
 714             if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
 715                 groups = validateUpdateVfGroupNamesRes.left().value();
 716             } else {
 717                 groups = parsedToscaYamlInfo.getGroups();
 718             }
 719             Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
 720             if (createGroupsOnResource.isRight()) {
 721                 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 722                 throw new ComponentException(createGroupsOnResource.right().value());
 723             }
 724             service = createGroupsOnResource.left().value();
 725
 726             Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
 727             if (createPoliciesOnResource.isRight()) {
 728                 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 729                 throw new ComponentException(createPoliciesOnResource.right().value());
 730             }
 731             service = createPoliciesOnResource.left().value();
 732             log.trace("************* Going to add artifacts from yaml {}", yamlName);
 733             NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
 734             Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 735                 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
 736             if (createArtifactsEither.isRight()) {
 737                 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 738                 throw new ComponentException(createArtifactsEither.right().value());
 739             }
 740             service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
 741             service = updateInputs(service, userId);
 742
 743             ASDCKpiApi.countCreatedResourcesKPI();
 744             return service;
 745         } catch (ComponentException | StorageException | BusinessLogicException e) {
 746             rollback = true;
 747             serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
 748             throw e;
 749         } finally {
 750             if (!inTransaction) {
 751                 if (rollback) {
 752                     janusGraphDao.rollback();
 753                 } else {
 754                     janusGraphDao.commit();
 755                 }
 756             }
 757             if (shouldLock) {
 758                 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
 759             }
 760         }
 761     }
 762
 763     private Service updateInputs(final Service component, final String userId) {
 764         final List<InputDefinition> inputs = component.getInputs();
 765         final List<ComponentInstance> componentInstances = component.getComponentInstances();
 766         final String componentUniqueId = component.getUniqueId();
 767         final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
 768         for (final InputDefinition input : inputs) {
 769             if (isInputFromComponentInstanceProperty(input.getName(), componentInstances, componentInstancesProperties)) {
 770                 associateInputToComponentInstanceProperty(userId, input, componentInstances, componentInstancesProperties,
 771                     componentUniqueId);
 772             } else {
 773                 associateInputToServiceProperty(userId, input, component);
 774             }
 775
 776         }
 777
 778         final Either<List<InputDefinition>, StorageOperationStatus> either
 779             = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
 780         if (either.isRight()) {
 781             throw new ComponentException(ActionStatus.GENERAL_ERROR);
 782         }
 783
 784         return component;
 785     }
 786
 787     private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances,
 788                                                          final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties) {
 789         if (CollectionUtils.isNotEmpty(componentInstances)) {
 790             // get instance's names
 791             final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
 792                 .collect(toList());
 793             final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
 794                 .filter(cin -> inputName.startsWith(cin + "_")).findFirst();
 795             if (componentInstancesNameOptional.isPresent() && MapUtils.isNotEmpty(componentInstancesProperties)) {
 796                 final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
 797                     .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
 798                 if (componentInstanceIdOptional.isPresent()) {
 799                     // get property's name
 800                     final String propertyNameFromInput = extractPropertyNameFromInputName(inputName, componentInstancesNames);
 801                     return componentInstancesProperties.get(componentInstanceIdOptional.get()).stream()
 802                         .anyMatch(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
 803                             && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName()));
 804                 }
 805             }
 806         }
 807         return false;
 808     }
 809
 810     private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
 811                                                            final List<ComponentInstance> componentInstances,
 812                                                            final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties,
 813                                                            String componentUniqueId) {
 814         // From Instance
 815         final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
 816             .collect(toList());
 817         final String propertyNameFromInput = extractPropertyNameFromInputName(input.getName(), componentInstancesNames);
 818
 819         final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
 820             .filter(cin -> input.getName().startsWith(cin + "_")).findFirst();
 821
 822         final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
 823             .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
 824
 825         final String componentInstanceId = componentInstanceIdOptional.get();
 826         final List<ComponentInstanceProperty> componentInstanceProperties = componentInstancesProperties.get(componentInstanceId);
 827
 828         final ComponentInstanceProperty componentInstanceProperty = componentInstanceProperties.stream()
 829             .filter(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
 830                 && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName())).findFirst().get();
 831
 832         // From Instance
 833         updateInput(input, componentInstanceProperty, userId, componentInstanceId);
 834
 835         final Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> either =
 836             toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId,
 837                 Collections.singletonList(componentInstanceProperty)), componentUniqueId);
 838         if (either.isRight()) {
 839             throw new ComponentException(ActionStatus.GENERAL_ERROR);
 840         }
 841     }
 842
 843     private void associateInputToServiceProperty(final String userId,
 844                                                  final InputDefinition input, final Service component) {
 845         final List<PropertyDefinition> properties = component.getProperties();
 846         if (CollectionUtils.isNotEmpty(properties)) {
 847             final String propertyNameFromInput = input.getName();
 848             final Optional<PropertyDefinition> propDefOptional = properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput))
 849                 .findFirst();
 850             if (propDefOptional.isPresent()) {
 851                 // From SELF
 852                 final String componentUniqueId = component.getUniqueId();
 853                 final PropertyDefinition propertyDefinition = propDefOptional.get();
 854                 updateProperty(propertyDefinition, input, componentUniqueId);
 855                 final JSONObject jsonObject = new JSONObject();
 856                 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName());
 857                 propertyDefinition.setValue(jsonObject.toJSONString());
 858                 updateInput(input, propertyDefinition, userId, componentUniqueId);
 859
 860                 final Either<PropertyDefinition, StorageOperationStatus> either
 861                     = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition);
 862                 if (either.isRight()) {
 863                     throw new ComponentException(ActionStatus.GENERAL_ERROR);
 864                 }
 865             }
 866         }
 867     }
 868
 869     private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
 870         propertyDefinition.setParentUniqueId(componentUniqueId);
 871         final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
 872         getInputValueDataDefinition.setInputId(input.getUniqueId());
 873         getInputValueDataDefinition.setInputName(input.getName());
 874         getInputValueDataDefinition.setPropName(propertyDefinition.getName());
 875         propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition));
 876     }
 877
 878     private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition,
 879                              final String userId, final String componentUniqueId) {
 880         input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition)));
 881         input.setInstanceUniqueId(componentUniqueId);
 882         input.setOwnerId(userId);
 883         input.setPropertyId(propertyDefinition.getUniqueId());
 884         input.setParentPropertyType(propertyDefinition.getType());
 885     }
 886
 887     private String extractPropertyNameFromInputName(final String inputName, final List<String> componentInstancesNames) {
 888         final AtomicReference<String> result = new AtomicReference<>(inputName);
 889         componentInstancesNames.forEach(cin -> result.set(result.get().replace(cin + "_", "")));
 890         return result.get();
 891     }
 892
 893     protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
 894                                                                        List<ArtifactDefinition> createdArtifacts, String yamlFileName,
 895                                                                        CsarInfo csarInfo, Resource preparedResource,
 896                                                                        NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
 897                                                                        boolean inTransaction, boolean shouldLock) {
 898         String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
 899         Resource resource = preparedResource;
 900         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
 901             .getNodeTypesArtifactsToHandle();
 902         if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
 903             if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
 904                 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
 905                     nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
 906                 if (handleNodeTypeArtifactsRes.isRight()) {
 907                     return Either.right(handleNodeTypeArtifactsRes.right().value());
 908                 }
 909             }
 910         } else {
 911             Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
 912                 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
 913             log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
 914             if (createdCsarArtifactsEither.isRight()) {
 915                 return createdCsarArtifactsEither;
 916             }
 917             resource = createdCsarArtifactsEither.left().value();
 918         }
 919         return Either.left(resource);
 920     }
 921
 922     protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
 923                                                                      ArtifactOperationInfo artifactOperation, boolean shouldLock,
 924                                                                      boolean inTransaction) {
 925         if (csarInfo.getCsar() != null) {
 926             createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
 927             Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
 928                 inTransaction, artifactOperation);
 929             if (eitherCreateResult.isRight()) {
 930                 return Either.right(eitherCreateResult.right().value());
 931             }
 932             Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
 933             if (eitherGerResource.isRight()) {
 934                 ResponseFormat responseFormat = componentsUtils
 935                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
 936                 return Either.right(responseFormat);
 937             }
 938             resource = eitherGerResource.left().value();
 939             Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
 940                 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
 941             if (artifacsMetaCsarStatus.isLeft()) {
 942                 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
 943                     artifacsMetaCsarStatus);
 944             } else {
 945                 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
 946             }
 947         }
 948         return Either.left(resource);
 949     }
 950
 951     protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
 952                                                                   boolean shouldLock, boolean inTransaction) {
 953         String vendorLicenseModelId = null;
 954         String vfLicenseModelId = null;
 955         if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
 956             Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
 957             if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
 958                 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
 959                     if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
 960                         vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
 961                     }
 962                     if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
 963                         vfLicenseModelId = artifactEntry.getValue().getUniqueId();
 964                     }
 965                 }
 966             }
 967         }
 968         createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
 969             Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
 970             Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
 971             artifactOperation, null, true, shouldLock, inTransaction);
 972         createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
 973             ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
 974             Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
 975     }
 976
 977     private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
 978                                                                              List<ArtifactDefinition> createdArtifacts,
 979                                                                              ArtifactOperationInfo artifactOperation, boolean shouldLock,
 980                                                                              boolean inTransaction,
 981                                                                              Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
 982         try {
 983             String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
 984             String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
 985             Either<Resource, ResponseFormat> createArtifactsFromCsar;
 986             if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
 987                 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
 988                     .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
 989             } else {
 990                 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
 991                     .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
 992                         inTransaction);
 993                 if ((result.left().value() instanceof Resource) && result.isLeft()) {
 994                     Resource service1 = (Resource) result.left().value();
 995                     createArtifactsFromCsar = Either.left(service1);
 996                 } else {
 997                     createArtifactsFromCsar = Either.right(result.right().value());
 998                 }
 999             }
1000             if (createArtifactsFromCsar.isRight()) {
1001                 log.debug("Couldn't create artifacts from artifacts.meta");
1002                 return Either.right(createArtifactsFromCsar.right().value());
1003             }
1004             return Either.left(createArtifactsFromCsar.left().value());
1005         } catch (Exception e) {
1006             log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
1007             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1008         }
1009     }
1010
1011     private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
1012                                                                                                List<ArtifactDefinition> createdArtifacts,
1013                                                                                                boolean shouldLock, boolean inTransaction,
1014                                                                                                ArtifactOperationInfo artifactOperation) {
1015         Either<T, ResponseFormat> resStatus = null;
1016         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
1017         try {
1018             Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
1019             if (artifactPathAndNameList.isRight()) {
1020                 return Either.right(
1021                     getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
1022             }
1023             EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
1024             if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1025                 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1026                 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
1027             } else {
1028                 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
1029                     component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
1030                 if (findVfCsarArtifactsToHandleRes.isRight()) {
1031                     resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
1032                 }
1033                 if (resStatus == null) {
1034                     vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
1035                 }
1036             }
1037             if (resStatus == null && vfCsarArtifactsToHandle != null) {
1038                 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
1039                     vfCsarArtifactsToHandle);
1040             }
1041             if (resStatus == null) {
1042                 resStatus = Either.left(component);
1043             }
1044         } catch (Exception e) {
1045             resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1046             log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
1047         } finally {
1048             CsarUtils.handleWarningMessages(collectedWarningMessages);
1049         }
1050         return resStatus;
1051     }
1052
1053     protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
1054                                                                               List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1055                                                                               boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1056         return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1057     }
1058
1059     protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
1060                                                                                    List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1061                                                                                    boolean inTransaction, Either<T, ResponseFormat> resStatus,
1062                                                                                    EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
1063         for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
1064             .entrySet()) {
1065             Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
1066                 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
1067                     e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
1068                     new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
1069                     inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
1070             if (optionalCreateInDBError.isPresent()) {
1071                 resStatus = Either.right(optionalCreateInDBError.get());
1072                 break;
1073             }
1074         }
1075         return resStatus;
1076     }
1077
1078     protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
1079                                                                                   String artifactFileName, String artifactType,
1080                                                                                   ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
1081                                                                                   String artifactDisplayName, String artifactDescription,
1082                                                                                   String artifactId, ArtifactOperationInfo operation,
1083                                                                                   List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
1084                                                                                   boolean shouldLock, boolean inTransaction) {
1085         byte[] artifactFileBytes = null;
1086         if (csarInfo.getCsar().containsKey(artifactPath)) {
1087             artifactFileBytes = csarInfo.getCsar().get(artifactPath);
1088         }
1089         Either<Boolean, ResponseFormat> result = Either.left(true);
1090         if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
1091             || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
1092             if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
1093                 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
1094                     .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
1095                 if (handleDelete.isRight()) {
1096                     result = Either.right(handleDelete.right().value());
1097                 }
1098                 return result;
1099             }
1100             if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
1101                 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
1102             }
1103         }
1104         if (artifactFileBytes != null) {
1105             Map<String, Object> vendorLicenseModelJson = ArtifactUtils
1106                 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
1107                     artifactDescription, artifactFileBytes, null, isFromCsar);
1108             Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
1109                 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
1110             serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
1111             if (eitherNonMetaArtifacts.isRight()) {
1112                 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
1113                     "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
1114                     BeEcompErrorManager.ErrorSeverity.WARNING);
1115                 return Either.right(eitherNonMetaArtifacts.right().value());
1116             }
1117         }
1118         return result;
1119     }
1120
1121     private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
1122                                                                                      Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1123                                                                                      List<ArtifactDefinition> createdArtifacts, User user,
1124                                                                                      boolean inTransaction, boolean ignoreLifecycleState) {
1125         List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
1126         Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
1127         Either<Resource, ResponseFormat> changeStateResponse;
1128         try {
1129             changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
1130             if (changeStateResponse.isRight()) {
1131                 return Either.right(changeStateResponse.right().value());
1132             }
1133             nodeTypeResource = changeStateResponse.left().value();
1134             List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
1135             log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
1136             for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
1137                 .entrySet()) {
1138                 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
1139                 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
1140                 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
1141                     log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
1142                     handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
1143                         .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
1144                             new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
1145                     if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
1146                         createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1147                     }
1148                     handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1149                 }
1150             }
1151             handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
1152         } catch (Exception e) {
1153             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1154             handleNodeTypeArtifactsRes = Either.right(responseFormat);
1155             log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
1156         }
1157         return handleNodeTypeArtifactsRes;
1158     }
1159
1160     private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
1161         Either<Resource, ResponseFormat> checkoutResourceRes;
1162         try {
1163             if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
1164                 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1165                 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
1166                     .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
1167                         new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1168                             LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
1169                 if (checkoutRes.isRight()) {
1170                     checkoutResourceRes = Either.right(checkoutRes.right().value());
1171                 } else {
1172                     checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
1173                 }
1174             } else {
1175                 checkoutResourceRes = Either.left(resource);
1176             }
1177         } catch (Exception e) {
1178             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1179             checkoutResourceRes = Either.right(responseFormat);
1180             log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
1181         }
1182         return checkoutResourceRes;
1183     }
1184
1185     protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
1186                                                                       String yamlFileName, CsarInfo csarInfo, Service preparedService,
1187                                                                       NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
1188                                                                       boolean inTransaction, boolean shouldLock) {
1189         Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
1190             new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
1191         log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
1192         if (createdCsarArtifactsEither.isRight()) {
1193             return createdCsarArtifactsEither;
1194         }
1195         return Either.left(createdCsarArtifactsEither.left().value());
1196     }
1197
1198     protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
1199                                                                     ArtifactOperationInfo artifactOperation, boolean shouldLock,
1200                                                                     boolean inTransaction) {
1201         if (csarInfo.getCsar() != null) {
1202             String vendorLicenseModelId = null;
1203             String vfLicenseModelId = null;
1204             if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
1205                 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
1206                 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
1207                     for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
1208                         if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
1209                             vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
1210                         }
1211                         if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
1212                             vfLicenseModelId = artifactEntry.getValue().getUniqueId();
1213                         }
1214                     }
1215                 }
1216             }
1217             createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
1218                 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
1219                 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
1220                 artifactOperation, null, true, shouldLock, inTransaction);
1221             createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
1222                 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
1223                 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
1224                 inTransaction);
1225             Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
1226                 inTransaction, artifactOperation);
1227             if (eitherCreateResult.isRight()) {
1228                 return Either.right(eitherCreateResult.right().value());
1229             }
1230             Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1231             if (eitherGerResource.isRight()) {
1232                 ResponseFormat responseFormat = componentsUtils
1233                     .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
1234                         ComponentTypeEnum.SERVICE);
1235                 return Either.right(responseFormat);
1236             }
1237             service = eitherGerResource.left().value();
1238             Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
1239                 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
1240             if (artifacsMetaCsarStatus.isLeft()) {
1241                 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
1242                 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1243                 Either<Service, ResponseFormat> createArtifactsFromCsar;
1244                 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1245                     createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1246                         .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
1247                 } else {
1248                     Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1249                         .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1250                             inTransaction);
1251                     if ((result.left().value() instanceof Service) && result.isLeft()) {
1252                         Service service1 = (Service) result.left().value();
1253                         createArtifactsFromCsar = Either.left(service1);
1254                     } else {
1255                         createArtifactsFromCsar = Either.right(result.right().value());
1256                     }
1257                 }
1258                 if (createArtifactsFromCsar.isRight()) {
1259                     log.debug("Couldn't create artifacts from artifacts.meta");
1260                     return Either.right(createArtifactsFromCsar.right().value());
1261                 }
1262                 return Either.left(createArtifactsFromCsar.left().value());
1263             } else {
1264                 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
1265             }
1266         }
1267         return Either.left(service);
1268     }
1269
1270     protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
1271                                                                              List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1272                                                                              boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1273         return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1274     }
1275
1276     protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
1277         Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
1278         List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
1279         if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
1280             existingArtifacts.addAll(component.getDeploymentArtifacts().values());
1281         }
1282         if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
1283             existingArtifacts.addAll(component.getArtifacts().values());
1284         }
1285         existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
1286         List<String> artifactsToIgnore = new ArrayList<>();
1287         if (component.getGroups() != null) {
1288             component.getGroups().forEach(g -> {
1289                 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
1290                     artifactsToIgnore.addAll(g.getArtifacts());
1291                 }
1292             });
1293         }
1294         existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
1295         return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
1296     }
1297
1298     private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
1299         boolean result = true;
1300         if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
1301             result = false;
1302         }
1303         return result;
1304     }
1305
1306     private boolean isValidArtifactType(ArtifactDefinition artifact) {
1307         final String artifactType = artifact.getArtifactType();
1308         return artifactType != null
1309             && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
1310             && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
1311     }
1312
1313     protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
1314         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
1315         User user) {
1316         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
1317             ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1318         Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1319         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
1320             .left(nodeTypeArtifactsToHandle);
1321         try {
1322             List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
1323             List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
1324             List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
1325             for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
1326                 ArtifactDefinition foundArtifact;
1327                 if (!existingArtifactsToHandle.isEmpty()) {
1328                     foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
1329                         .findFirst().orElse(null);
1330                     if (foundArtifact != null) {
1331                         if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
1332                             if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
1333                                 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
1334                                 artifactsToUpdate.add(currNewArtifact);
1335                             }
1336                             existingArtifactsToHandle.remove(foundArtifact);
1337                             artifactsToUpload.remove(currNewArtifact);
1338                         } else {
1339                             log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
1340                             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
1341                                 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
1342                                     currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
1343                             AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
1344                                 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
1345                                 foundArtifact.getArtifactChecksum());
1346                             artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
1347                                 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
1348                             responseWrapper.setInnerElement(responseFormat);
1349                             break;
1350                         }
1351                     }
1352                 }
1353             }
1354             if (responseWrapper.isEmpty()) {
1355                 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
1356                     if (currArtifact.getIsFromCsar()) {
1357                         artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1358                             ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1359                             currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1360                     } else {
1361                         artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1362                             ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1363                             currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1364                     }
1365                 }
1366             }
1367             if (responseWrapper.isEmpty()) {
1368                 if (!artifactsToUpload.isEmpty()) {
1369                     nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
1370                 }
1371                 if (!artifactsToUpdate.isEmpty()) {
1372                     nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
1373                 }
1374                 if (!artifactsToDelete.isEmpty()) {
1375                     nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
1376                 }
1377             }
1378             if (!responseWrapper.isEmpty()) {
1379                 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1380             }
1381         } catch (Exception e) {
1382             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1383             responseWrapper.setInnerElement(responseFormat);
1384             log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
1385             nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1386         }
1387         return nodeTypeArtifactsToHandleRes;
1388     }
1389
1390     protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
1391                                                                                         Map<String, Set<List<String>>> collectedWarningMessages) {
1392         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
1393             .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
1394             .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
1395             .map(e -> e.left().value()).collect(toList());
1396         Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
1397         for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
1398             if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
1399                 return Either.right(nonMetaArtifactInfo.getArtifactName());
1400             }
1401         }
1402         return Either.left(artifactPathAndNameList);
1403     }
1404
1405     protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
1406         if (groups != null && !groups.isEmpty()) {
1407             List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
1408             serviceImportParseLogic.handleGroupsProperties(service, groups);
1409             serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
1410             Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
1411             if (createGroups.isRight()) {
1412                 return Either.right(createGroups.right().value());
1413             }
1414         } else {
1415             return Either.left(service);
1416         }
1417         return getServiceResponseFormatEither(service);
1418     }
1419
1420     private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
1421                                                                      final Map<String, PolicyDefinition> policies) {
1422         if (MapUtils.isEmpty(policies)) {
1423             return Either.left(service);
1424         }
1425         Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = service.getComponentInstancesAttributes();
1426         final Map<String, List<AttributeDefinition>> instanceAttributeMap = new HashMap<>();
1427         if (MapUtils.isNotEmpty(componentInstancesAttributes)) {
1428             instanceAttributeMap.putAll(componentInstancesAttributes
1429                 .entrySet().stream()
1430                 .collect(toMap(Entry::getKey, entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))));
1431         }
1432         policies.values().stream()
1433             .map(PolicyDataDefinition::getProperties)
1434             .flatMap(Collection::stream)
1435             .filter(PropertyDataDefinition::isToscaFunction)
1436             .forEach(policyDefinition -> toscaFunctionService
1437                 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
1438                     instanceAttributeMap)
1439             );
1440         policyBusinessLogic.createPolicies(service, policies);
1441         return getServiceResponseFormatEither(service);
1442     }
1443
1444     private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
1445         Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1446         if (updatedResource.isRight()) {
1447             ResponseFormat responseFormat = componentsUtils
1448                 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
1449                     ComponentTypeEnum.SERVICE);
1450             return Either.right(responseFormat);
1451         }
1452         return Either.left(updatedResource.left().value());
1453     }
1454
1455     protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
1456         List<GroupDefinition> result = new ArrayList<>();
1457         List<ComponentInstance> componentInstances = component.getComponentInstances();
1458         if (groups != null) {
1459             for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
1460                 String groupName = entry.getKey();
1461                 GroupDefinition groupDefinition = entry.getValue();
1462                 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
1463                 updatedGroupDefinition.setMembers(null);
1464                 Map<String, String> members = groupDefinition.getMembers();
1465                 if (members != null) {
1466                     serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
1467                 }
1468                 result.add(updatedGroupDefinition);
1469             }
1470         }
1471         return result;
1472     }
1473
1474     protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
1475                                                     Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1476                                                     String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1477                                                     Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1478                                                     Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1479                                                     String nodeName) {
1480         try {
1481             log.debug("************* Going to create all nodes {}", yamlName);
1482             handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1483                 csarInfo, nodeName);
1484             log.debug("************* Going to create all resource instances {}", yamlName);
1485             resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1486             log.debug("************* Finished to create all resource instances {}", yamlName);
1487             resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
1488             log.debug("************* Going to create positions {}", yamlName);
1489             compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
1490             log.debug("************* Finished to set positions {}", yamlName);
1491             return resource;
1492         } catch (Exception e) {
1493             throw new ComponentException(ActionStatus.GENERAL_ERROR);
1494         }
1495     }
1496
1497     protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
1498                                                         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1499         log.debug("#createResourceInstancesRelations - Going to create relations ");
1500         List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
1501         if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
1502             resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
1503             log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1504                 resource.getUniqueId(), yamlName);
1505             BeEcompErrorManager.getInstance()
1506                 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1507                     BeEcompErrorManager.ErrorSeverity.ERROR);
1508             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1509         }
1510         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1511         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1512         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1513         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1514         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1515         Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1516         Map<String, Resource> originCompMap = new HashMap<>();
1517         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1518         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1519         Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1520         Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1521         log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1522         final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1523         if (applicationDataTypeCache != null) {
1524             Resource finalResource = resource;
1525             uploadResInstancesMap.values().forEach(
1526                 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1527                     componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1528                     instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter,
1529                     instInterfaces, i));
1530         }
1531         serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1532         serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1533         serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1534         serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1535         serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1536         serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1537         resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1538         serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1539         serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1540         handleSubstitutionMappings(resource, uploadResInstancesMap);
1541         log.debug("************* in create relations, getResource start");
1542         Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1543         log.debug("************* in create relations, getResource end");
1544         if (eitherGetResource.isRight()) {
1545             throw new ComponentException(
1546                 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1547         }
1548         return eitherGetResource.left().value();
1549     }
1550
1551     protected void processProperty(Resource resource, Map<String, DataTypeDefinition> allDataTypes,
1552                                    Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1553                                    List<UploadPropInfo> propertyList) {
1554         UploadPropInfo propertyInfo = propertyList.get(0);
1555         String propName = propertyInfo.getName();
1556         if (!currPropertiesMap.containsKey(propName)) {
1557             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1558         }
1559         processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1560     }
1561
1562     private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1563                                  List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1564                                  List<InputDefinition> inputs2) {
1565         InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1566         ComponentInstanceInput property = null;
1567         String value = null;
1568         List<GetInputValueDataDefinition> getInputs = null;
1569         boolean isValidate = true;
1570         if (propertyInfo.getValue() != null) {
1571             getInputs = propertyInfo.getGet_input();
1572             isValidate = getInputs == null || getInputs.isEmpty();
1573             if (isValidate) {
1574                 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1575             } else {
1576                 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1577             }
1578         }
1579         property = new ComponentInstanceInput(curPropertyDef, value, null);
1580         String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1581         property.setValue(validPropertyVAlue);
1582         if (isNotEmpty(getInputs)) {
1583             List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1584             for (GetInputValueDataDefinition getInput : getInputs) {
1585                 List<InputDefinition> inputs = inputs2;
1586                 if (CollectionUtils.isEmpty(inputs)) {
1587                     throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1588                 }
1589                 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1590                 if (!optional.isPresent()) {
1591                     throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1592                 }
1593                 InputDefinition input = optional.get();
1594                 getInput.setInputId(input.getUniqueId());
1595                 getInputValues.add(getInput);
1596                 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1597                 processGetInput(getInputValues, inputs, getInputIndex);
1598             }
1599             property.setGetInputValues(getInputValues);
1600         }
1601         instPropList.add(property);
1602         currPropertiesMap.remove(property.getName());
1603     }
1604
1605     protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1606         if (resource.getResourceType() == ResourceTypeEnum.VF) {
1607             Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1608             if (getResourceRes.isRight()) {
1609                 ResponseFormat responseFormat = componentsUtils
1610                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1611                 throw new ComponentException(responseFormat);
1612             }
1613             getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1614             if (getResourceRes.isRight()) {
1615                 ResponseFormat responseFormat = componentsUtils
1616                     .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1617                 throw new ComponentException(responseFormat);
1618             }
1619         }
1620     }
1621
1622     protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1623                                                Map<String, Resource> nodeNamespaceMap) {
1624         Either<Resource, ResponseFormat> eitherResource = null;
1625         log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1626         if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1627             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1628             throw new ComponentException(responseFormat);
1629         }
1630         Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1631         if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1632             nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1633         }
1634         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1635         uploadResInstancesMap.values()
1636             .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1637         if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1638             try {
1639                 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1640             } catch (StorageException exp) {
1641                 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1642                     log.debug("Failed to add component instances to container component {}", resource.getName());
1643                     ResponseFormat responseFormat = componentsUtils
1644                         .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1645                     eitherResource = Either.right(responseFormat);
1646                     throw new ByResponseFormatComponentException(eitherResource.right().value());
1647                 }
1648             }
1649         }
1650         log.debug("*************Going to get resource {}", resource.getUniqueId());
1651         Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1652             .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1653         log.debug("*************finished to get resource {}", resource.getUniqueId());
1654         if (eitherGetResource.isRight()) {
1655             ResponseFormat responseFormat = componentsUtils
1656                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1657             throw new ComponentException(responseFormat);
1658         }
1659         if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1660             resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1661             log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1662             BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1663             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1664         }
1665         return eitherGetResource.left().value();
1666     }
1667
1668     protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1669                                    Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1670                                    List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1671                                    String nodeName) {
1672         try {
1673             for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1674                 if (nodeTypeEntry.getValue().isNested()) {
1675                     handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1676                         nodeTypeEntry.getKey());
1677                     log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1678                 }
1679             }
1680             Map<String, Object> mappedToscaTemplate = null;
1681             if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1682                 .containsKey(nodeName)) {
1683                 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1684             }
1685             if (MapUtils.isEmpty(mappedToscaTemplate)) {
1686                 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1687             }
1688             createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1689                 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1690         } catch (ComponentException e) {
1691             ResponseFormat responseFormat =
1692                 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1693             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1694             throw e;
1695         } catch (StorageException e) {
1696             ResponseFormat responseFormat = componentsUtils
1697                 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1698             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1699             throw e;
1700         } catch (Exception e) {
1701             log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1702             throw new ComponentException(ActionStatus.GENERAL_ERROR);
1703         }
1704     }
1705
1706     protected Resource handleNestedVfc(Service service,
1707                                        Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1708                                        List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1709                                        String nodeName) {
1710         try {
1711             String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1712             Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1713             createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1714                 csarInfo);
1715             log.debug("************* Finished to create node types from yaml {}", yamlName);
1716             if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1717                 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1718                 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1719             }
1720             return new Resource();
1721         } catch (Exception e) {
1722             log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1723             throw new ComponentException(ActionStatus.GENERAL_ERROR);
1724         }
1725     }
1726
1727     protected Resource handleNestedVfc(Resource resource,
1728                                        Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1729                                        List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1730                                        String nodeName) {
1731         String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1732         Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1733         log.debug("************* Going to create node types from yaml {}", yamlName);
1734         createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1735             csarInfo);
1736         if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1737             log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1738             resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1739         }
1740         return resource;
1741     }
1742
1743     protected Resource handleComplexVfc(Resource resource,
1744                                         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1745                                         List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1746                                         String nodeName, String yamlName) {
1747         Resource oldComplexVfc = null;
1748         Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1749         Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1750             .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1751         if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1752             oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1753                 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1754         }
1755         if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1756             throw new ComponentException(ActionStatus.GENERAL_ERROR);
1757         } else if (oldComplexVfcRes.isLeft()) {
1758             log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1759             Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1760                 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1761                     ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1762             if (eitherValidation.isLeft()) {
1763                 oldComplexVfc = oldComplexVfcRes.left().value();
1764             }
1765         }
1766         newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1767             newComplexVfc);
1768         csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1769         LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1770             LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1771         log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1772         final Resource result = serviceImportParseLogic
1773             .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1774         csarInfo.getCreatedNodes().put(nodeName, result);
1775         csarInfo.removeNodeFromQueue();
1776         return result;
1777     }
1778
1779     private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1780                                                                        boolean needLock,
1781                                                                        Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1782                                                                        List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1783                                                                        Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1784         Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1785             TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1786         if (toscaVersion.isRight()) {
1787             throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1788         }
1789         Map<String, Object> mapToConvert = new HashMap<>();
1790         mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1791         Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1792         createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1793             nodeTypes);
1794         return csarInfo.getCreatedNodes();
1795     }
1796
1797     protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1798                                    Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1799                                    List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1800                                    Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1801         Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1802         Resource vfcCreated = null;
1803         while (nodesNameValueIter.hasNext()) {
1804             Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1805             Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1806                 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1807             if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1808                 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1809                 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1810                     nodeType.getKey());
1811                 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1812             } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1813                 .containsKey(nodeType.getKey())) {
1814                 log.trace("************* Going to create node {}", nodeType.getKey());
1815                 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1816                     mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1817                 log.debug("************* Finished to create node {}", nodeType.getKey());
1818                 vfcCreated = resourceCreated.getLeft();
1819                 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1820             }
1821             if (vfcCreated != null) {
1822                 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1823             }
1824             mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1825         }
1826     }
1827
1828     protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1829                                                                                    User user, Map<String, Object> mapToConvert, Resource resourceVf,
1830                                                                                    boolean needLock,
1831                                                                                    Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1832                                                                                    List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1833                                                                                    boolean forceCertificationAllowed, CsarInfo csarInfo,
1834                                                                                    boolean isNested) {
1835         final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE,
1836             true);
1837         UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(),
1838             validatedUser);
1839         String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1840         return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock,
1841             nodeTypeArtifactsToHandle,
1842             nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1843     }
1844
1845     protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1846                                                    Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1847                                                    String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1848                                                    Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1849                                                    Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1850                                                    String nodeName) {
1851         log.debug("************* Going to create all nodes {}", yamlName);
1852         handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1853             nodeTypesInfo, csarInfo, nodeName);
1854         if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1855             log.debug("************* Going to create all resource instances {}", yamlName);
1856             service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1857             log.debug("************* Going to create all relations {}", yamlName);
1858             service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1859             log.debug("************* Going to create positions {}", yamlName);
1860             compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1861             log.debug("************* Finished to set positions {}", yamlName);
1862         }
1863         return service;
1864     }
1865
1866     protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1867                                                       Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1868         log.debug("#createResourceInstancesRelations - Going to create relations ");
1869         List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1870         if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1871             log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1872                 service.getUniqueId(), yamlName);
1873             BeEcompErrorManager.getInstance()
1874                 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1875                     BeEcompErrorManager.ErrorSeverity.ERROR);
1876             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1877         }
1878         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1879         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1880         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1881         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1882         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1883         Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1884         Map<String, Resource> originCompMap = new HashMap<>();
1885         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1886         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1887         Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1888         Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1889         log.debug("enter ServiceImportBusinessLogic  createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1890         final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1891         if (applicationDataTypeCache != null) {
1892             final Map<String, DataTypeDefinition> allDataTypesMap =
1893                 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1894             final Service service1 = service;
1895             uploadResInstancesMap.values().forEach(
1896                 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1897                     allDataTypesMap, instProperties,
1898                     instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1899                     instNodeFilter, instInterfaces, i)
1900             );
1901         }
1902         updatePropertyToscaFunctionData(service, instProperties, instAttributes);
1903         serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1904         serviceImportParseLogic.associateComponentInstanceInterfacesToComponent(
1905             yamlName,
1906             service,
1907             instInterfaces
1908         );
1909         serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1910         serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1911         serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1912         serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1913         serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1914         log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1915         serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1916         ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1917         Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1918         Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1919         serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1920         serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1921         service = getResourceAfterCreateRelations(service);
1922         addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1923         serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1924         log.debug("************* in create relations, getResource start");
1925         Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1926         log.debug("************* in create relations, getResource end");
1927         if (eitherGetResource.isRight()) {
1928             throw new ComponentException(componentsUtils
1929                 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1930                     service.getComponentType()));
1931         }
1932         return eitherGetResource.left().value();
1933     }
1934
1935     private void updatePropertyToscaFunctionData(final Component service,
1936                                                  final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
1937                                                  final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
1938         final Component updatedService =
1939             toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
1940                 .on(storageOperationStatus -> {
1941                         final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
1942                         final ResponseFormat responseFormat =
1943                             componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
1944                         throw new ComponentException(responseFormat);
1945                     }
1946                 );
1947         instancePropertyMap.values().forEach(instancePropertyList ->
1948             instancePropertyList.stream()
1949                 .filter(PropertyDataDefinition::isToscaFunction)
1950                 .forEach(instanceProperty -> {
1951                     toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
1952                         updatedService, instancePropertyMap, instanceAttributeMap);
1953                     instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
1954                 })
1955         );
1956     }
1957
1958     protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1959                                             Map<String, DataTypeDefinition> allDataTypes,
1960                                             Map<String, List<ComponentInstanceProperty>> instProperties,
1961                                             Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1962                                             Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1963                                             Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1964                                             Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1965                                             Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1966                                             Map<String, List<ComponentInstanceInput>> instInputs,
1967                                             Map<String, UploadNodeFilterInfo> instNodeFilter,
1968                                             Map<String, Map<String, InterfaceDefinition>> instInterfaces,
1969                                             UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1970         log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1971         Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1972             .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1973         if (currentCompInstanceOpt.isEmpty()) {
1974             log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1975             BeEcompErrorManager.getInstance()
1976                 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1977                     BeEcompErrorManager.ErrorSeverity.ERROR);
1978             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1979             throw new ComponentException(responseFormat);
1980         }
1981         ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1982         String resourceInstanceId = currentCompInstance.getUniqueId();
1983         Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1984         if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1985             instRequirements.put(currentCompInstance, originResource.getRequirements());
1986         }
1987         if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1988             processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1989         }
1990         if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1991             instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1992         }
1993         if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1994             instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1995         }
1996         if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1997             instAttributes.put(resourceInstanceId, originResource.getAttributes());
1998             addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
1999         }
2000         if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
2001             instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
2002         }
2003         if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
2004
2005             ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi(
2006                 uploadComponentInstanceInfo,
2007                 component,
2008                 originResource,
2009                 currentCompInstance,
2010                 instInterfaces
2011             );
2012             if (addInterfacesToRiRes.getStatus() != 200) {
2013                 throw new ComponentException(addInterfacesToRiRes);
2014             }
2015         }
2016         if (originResource.getResourceType() != ResourceTypeEnum.VF) {
2017             ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
2018                 currentCompInstance, instProperties, allDataTypes);
2019             if (addPropertiesValueToRiRes.getStatus() != 200) {
2020                 throw new ComponentException(addPropertiesValueToRiRes);
2021             }
2022         } else {
2023             addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
2024         }
2025     }
2026
2027     protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
2028                                        ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
2029                                        Map<String, DataTypeDefinition> allDataTypes) {
2030         Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2031         try {
2032             if (MapUtils.isNotEmpty(propMap)) {
2033                 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2034                 List<ComponentInstanceInput> instPropList = new ArrayList<>();
2035                 if (CollectionUtils.isEmpty(originResource.getInputs())) {
2036                     log.debug("failed to find properties ");
2037                     throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
2038                 }
2039                 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
2040                 for (List<UploadPropInfo> propertyList : propMap.values()) {
2041                     processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList);
2042                 }
2043                 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
2044                 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
2045             }
2046         } catch (Exception e) {
2047             log.debug("failed to add Inputs Values To Ri");
2048             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2049         }
2050     }
2051
2052     protected void processProperty(Component component, Map<String, DataTypeDefinition> allDataTypes,
2053                                    Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
2054                                    List<UploadPropInfo> propertyList) {
2055         UploadPropInfo propertyInfo = propertyList.get(0);
2056         String propName = propertyInfo.getName();
2057         if (!currPropertiesMap.containsKey(propName)) {
2058             log.debug("failed to find property {} ", propName);
2059             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
2060         }
2061         processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
2062     }
2063
2064     protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
2065                                    GetInputValueDataDefinition getInputIndex) {
2066         Optional<InputDefinition> optional;
2067         if (getInputIndex != null) {
2068             optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
2069             if (!optional.isPresent()) {
2070                 log.debug("Failed to find input {} ", getInputIndex.getInputName());
2071                 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2072             }
2073             InputDefinition inputIndex = optional.get();
2074             getInputIndex.setInputId(inputIndex.getUniqueId());
2075             getInputValues.add(getInputIndex);
2076         }
2077     }
2078
2079     private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
2080                                                      Map<String, UploadAttributeInfo> attributeMap) {
2081         if (attributeMap == null) {
2082             return;
2083         }
2084         attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
2085             .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
2086                 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
2087                     Gson gson = new Gson();
2088                     String json = gson.toJson(attributeValue.getValue());
2089                     attr.setValue(json);
2090                 } else {
2091                     attr.setValue(String.valueOf(attributeValue.getValue()));
2092                 }
2093             })));
2094     }
2095
2096     protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
2097                                                    Resource originResource, ComponentInstance currentCompInstance,
2098                                                    Map<String, List<ComponentInstanceProperty>> instProperties,
2099                                                    Map<String, DataTypeDefinition> allDataTypes) {
2100         Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2101         Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
2102         List<PropertyDefinition> originalPropertyList = originResource.getProperties();
2103         if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
2104             log.debug("failed to find properties ");
2105             return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
2106         }
2107         if (CollectionUtils.isEmpty(originalPropertyList)) {
2108             return componentsUtils.getResponseFormat(ActionStatus.OK);
2109         }
2110         originalPropertyList.stream()
2111             .filter(property -> !currPropertiesMap.containsKey(property.getName()))
2112             .forEach(property -> currPropertiesMap.put(property.getName(), property));
2113         List<ComponentInstanceProperty> instPropList = new ArrayList<>();
2114         if (MapUtils.isNotEmpty(propMap)) {
2115             for (final List<UploadPropInfo> propertyList : propMap.values()) {
2116                 UploadPropInfo propertyInfo = propertyList.get(0);
2117                 String propName = propertyInfo.getName();
2118                 if (!currPropertiesMap.containsKey(propName)) {
2119                     log.debug("failed to find property {} ", propName);
2120                     return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
2121                 }
2122                 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
2123                 String value = null;
2124                 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
2125                 boolean isValidate = true;
2126                 if (propertyInfo.getValue() != null) {
2127                     getInputs.addAll(propertyInfo.getGet_input());
2128                     isValidate = getInputs.isEmpty();
2129                     if (isValidate) {
2130                         value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
2131                     } else {
2132                         value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2133                     }
2134                 }
2135                 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
2136                 String validatedPropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, true, allDataTypes);
2137
2138                 addSubPropertyYamlToscaFunctions(validatedPropValue, value, property.getType(), propertyInfo, allDataTypes);
2139
2140                 if (CollectionUtils.isNotEmpty(propertyInfo.getSubPropertyToscaFunctions())) {
2141                     validatedPropValue = value;
2142                 }
2143
2144                 property.setValue(validatedPropValue);
2145
2146                 if (tryHandlingAsYamlToscaFunction(validatedPropValue, value, propertyInfo)) {
2147                     try {
2148                         final Object yamlValue = new Yaml().loadAs(value, Object.class);
2149                         CustomYamlFunction toscaFunction = new CustomYamlFunction();
2150                         toscaFunction.setYamlValue(yamlValue);
2151                         property.setToscaFunction(toscaFunction);
2152                     } catch (Exception exception) {
2153                         log.info("Cannot create YAML value for {}", propName);
2154                     }
2155                 } else {
2156                     property.setToscaFunction(propertyInfo.getToscaFunction());
2157                 }
2158                 property.setSubPropertyToscaFunctions(propertyInfo.getSubPropertyToscaFunctions());
2159                 if (!getInputs.isEmpty() && CollectionUtils.isEmpty(property.getSubPropertyToscaFunctions())) {
2160                     final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
2161                     for (final GetInputValueDataDefinition getInput : getInputs) {
2162                         final List<InputDefinition> inputs = component.getInputs();
2163                         if (inputs == null || inputs.isEmpty()) {
2164                             log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
2165                             serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
2166                                 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
2167                         }
2168                         InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
2169                         getInput.setInputId(input.getUniqueId());
2170                         getInputValues.add(getInput);
2171                         GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
2172                         if (getInputIndex != null) {
2173                             input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
2174                             getInputIndex.setInputId(input.getUniqueId());
2175                             getInputValues.add(getInputIndex);
2176                         }
2177                     }
2178                     property.setGetInputValues(getInputValues);
2179                 }
2180                 instPropList.add(property);
2181                 currPropertiesMap.remove(property.getName());
2182             }
2183         }
2184         if (!currPropertiesMap.isEmpty()) {
2185             for (PropertyDefinition value : currPropertiesMap.values()) {
2186                 instPropList.add(new ComponentInstanceProperty(value));
2187             }
2188         }
2189         instProperties.put(currentCompInstance.getUniqueId(), instPropList);
2190         return componentsUtils.getResponseFormat(ActionStatus.OK);
2191     }
2192
2193     private boolean tryHandlingAsYamlToscaFunction(String validatedPropValue, String value, UploadPropInfo propertyInfo) {
2194         return StringUtils.isEmpty(validatedPropValue) && StringUtils.isNotEmpty(value) && propertyInfo.getToscaFunction() == null
2195             && CollectionUtils.isEmpty(propertyInfo.getSubPropertyToscaFunctions());
2196     }
2197
2198     private void addSubPropertyYamlToscaFunctions(final String validatedPropValue, final String value, final String propertyType,
2199                                                   final UploadPropInfo propertyInfo, final Map<String, DataTypeDefinition> allDataTypes) {
2200         if (StringUtils.isNotEmpty(validatedPropValue) || StringUtils.isEmpty(value) || ToscaPropertyType.isValidType(propertyType) != null) {
2201             return;
2202         }
2203         try {
2204             final JsonObject jsonObject = JsonParser.parseString(value).getAsJsonObject();
2205
2206             final DataTypeDefinition dataTypeDefinition = allDataTypes.get(propertyType);
2207             final List<String> propertyNames =
2208                 dataTypeDefinition.getProperties().stream().map(PropertyDataDefinition::getName).collect(Collectors.toList());
2209
2210             boolean hasSubPropertyValues = jsonObject.entrySet().stream().allMatch(entry -> propertyNames.contains(entry.getKey()));
2211
2212             if (hasSubPropertyValues) {
2213                 for (final PropertyDefinition prop : dataTypeDefinition.getProperties()) {
2214                     if (propertyInfo.getSubPropertyToscaFunctions().stream()
2215                         .anyMatch(subPropertyToscaFunction -> subPropertyToscaFunction.getSubPropertyPath().get(0).equals(prop.getName()))) {
2216                         continue;
2217                     }
2218                     Optional<SubPropertyToscaFunction> subPropertyToscaFunction = createSubPropertyYamlToscaFunction(jsonObject, prop, allDataTypes);
2219                     if (subPropertyToscaFunction.isPresent()) {
2220                         propertyInfo.getSubPropertyToscaFunctions().add(subPropertyToscaFunction.get());
2221                     }
2222                 }
2223             }
2224         } catch (Exception exception) {
2225             log.info("Cannot create YAML value for {}", value);
2226         }
2227     }
2228
2229     private Optional<SubPropertyToscaFunction> createSubPropertyYamlToscaFunction(final JsonObject jsonObject, final PropertyDefinition prop,
2230                                                                                   final Map<String, DataTypeDefinition> allDataTypes) {
2231         JsonElement propJsonElement = jsonObject.get(prop.getName());
2232         if (propJsonElement != null) {
2233             final String subPropValue = propJsonElement.toString();
2234             final ComponentInstanceProperty subProperty = new ComponentInstanceProperty(prop, subPropValue, null);
2235             final String validateSubPropValue =
2236                 serviceBusinessLogic.validatePropValueBeforeCreate(subProperty, subPropValue, true, allDataTypes);
2237
2238             if (StringUtils.isEmpty(validateSubPropValue) && StringUtils.isNotEmpty(subPropValue)) {
2239                 try {
2240                     Object yamlValue = new Yaml().loadAs(subPropValue, Object.class);
2241                     SubPropertyToscaFunction subPropertyToscaFunction = new SubPropertyToscaFunction();
2242                     CustomYamlFunction toscaFunction = new CustomYamlFunction();
2243                     toscaFunction.setYamlValue(yamlValue);
2244                     subPropertyToscaFunction.setToscaFunction(toscaFunction);
2245                     subPropertyToscaFunction.setSubPropertyPath(Collections.singletonList(prop.getName()));
2246                     return Optional.of(subPropertyToscaFunction);
2247                 } catch (Exception exception) {
2248                     log.info("Cannot create YAML value for {}", subPropValue);
2249                 }
2250             }
2251         }
2252         return Optional.empty();
2253     }
2254
2255     protected ResponseFormat addInterfaceValuesToRi(
2256         UploadComponentInstanceInfo uploadComponentInstanceInfo,
2257         Component component,
2258         Resource originResource, ComponentInstance currentCompInstance,
2259         Map<String, Map<String, InterfaceDefinition>> instInterfaces
2260     ) {
2261         Map<String, UploadInterfaceInfo> instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces();
2262         Map<String, InterfaceDefinition> currInterfacesMap = new HashMap<>();
2263         Map<String, InterfaceDefinition> interfacesFromNodeType = originResource.getInterfaces();
2264         if ((MapUtils.isNotEmpty(instanceInterfacesMap)) && (MapUtils.isEmpty(interfacesFromNodeType))) {
2265             log.debug("failed to find interfaces ");
2266             return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
2267         }
2268         if (interfacesFromNodeType == null || interfacesFromNodeType.isEmpty()) {
2269             return componentsUtils.getResponseFormat(ActionStatus.OK);
2270         }
2271         for (Map.Entry<String, InterfaceDefinition> entryInstances : interfacesFromNodeType.entrySet()) {
2272             String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1);
2273             if (!currInterfacesMap.containsKey(interfaceName)) {
2274                 currInterfacesMap.put(interfaceName, entryInstances.getValue());
2275             }
2276         }
2277
2278         Map<String, InterfaceDefinition> instInterfacesMap = new HashMap<>();
2279         if (MapUtils.isNotEmpty(instanceInterfacesMap)) {
2280             for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) {
2281                 String interfaceName = uploadInterfaceInfo.getName();
2282                 if (!currInterfacesMap.containsKey(interfaceName)) {
2283                     log.debug("failed to find interface {} ", interfaceName);
2284                     return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName);
2285                 }
2286                 InterfaceDefinition currentInterfaceDef = currInterfacesMap.get(interfaceName);
2287                 Map<String, OperationDataDefinition> operationsToAdd = new HashMap<>();
2288
2289                 Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
2290                 for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
2291                     OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().get(operation.getKey());
2292                     OperationDataDefinition instanceOperation = operation.getValue();
2293                     //Inputs
2294                     ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
2295                     mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
2296                     templateOperation.setInputs(instanceInputs);
2297                     //Implementation
2298                     templateOperation.setImplementation(instanceOperation.getImplementation());
2299                     //Description
2300                     templateOperation.setDescription(instanceOperation.getDescription());
2301                     operationsToAdd.put(operation.getKey(), templateOperation);
2302                 }
2303                 InterfaceDefinition interfaceDef = new InterfaceDefinition();
2304                 interfaceDef.setModel(component.getModel());
2305                 interfaceDef.setType(currentInterfaceDef.getType());
2306                 interfaceDef.setUniqueId(currentInterfaceDef.getType());
2307                 interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
2308                 interfaceDef.setOperations(operationsToAdd);
2309                 instInterfacesMap.put(currentInterfaceDef.getType(), interfaceDef);
2310                 currInterfacesMap.remove(interfaceName);
2311             }
2312         }
2313         if (!currInterfacesMap.isEmpty()) {
2314             for (InterfaceDefinition value : currInterfacesMap.values()) {
2315                 instInterfacesMap.put(value.getUniqueId(), value);
2316             }
2317         }
2318         instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap);
2319         return componentsUtils.getResponseFormat(ActionStatus.OK);
2320     }
2321
2322     private void mergeOperationInputDefinitions(ListDataDefinition<OperationInputDefinition> inputsFromNodeType,
2323                                                 ListDataDefinition<OperationInputDefinition> instanceInputs) {
2324         if (inputsFromNodeType == null || CollectionUtils.isEmpty(inputsFromNodeType.getListToscaDataDefinition()) || instanceInputs == null
2325             || CollectionUtils.isEmpty(instanceInputs.getListToscaDataDefinition())) {
2326             return;
2327         }
2328         instanceInputs.getListToscaDataDefinition().forEach(
2329             instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter(
2330                 templateInput -> templateInput.getName().equals(instanceInput.getName())
2331             ).forEach(
2332                 newInstanceInput -> {
2333                     instanceInput.setSourceProperty(newInstanceInput.getSourceProperty());
2334                     instanceInput.setSource(newInstanceInput.getSource());
2335                     instanceInput.setType(newInstanceInput.getType());
2336                 }
2337             )
2338         );
2339         instanceInputs.getListToscaDataDefinition().stream()
2340             .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch(
2341                 inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName())
2342             ))
2343             .forEach(oldInput -> oldInput.setType("string"));
2344     }
2345
2346     protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
2347                                                         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2348                                                         UploadComponentInstanceInfo uploadComponentInstanceInfo,
2349                                                         ComponentInstance currentCompInstance, Resource originResource) {
2350         log.debug("enter processComponentInstanceCapabilities");
2351         Map<String, List<CapabilityDefinition>> originCapabilities;
2352         if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2353             originCapabilities = new HashMap<>();
2354             Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2355             originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
2356             uploadComponentInstanceInfo.getCapabilities().values()
2357                 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
2358             updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2359         } else {
2360             originCapabilities = originResource.getCapabilities();
2361         }
2362         instCapabilties.put(currentCompInstance, originCapabilities);
2363     }
2364
2365     protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
2366                                                     Map<String, List<CapabilityDefinition>> originCapabilities,
2367                                                     Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
2368         originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
2369             .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
2370     }
2371
2372     protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
2373                                         Map<String, DataTypeDefinition> allDataTypes) {
2374         properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
2375     }
2376
2377     protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
2378                                          Map<String, DataTypeDefinition> allDataTypes) {
2379         String value = null;
2380         List<GetInputValueDataDefinition> getInputs = null;
2381         boolean isValidate = true;
2382         if (null != propertyInfo && propertyInfo.getValue() != null) {
2383             getInputs = propertyInfo.getGet_input();
2384             isValidate = getInputs == null || getInputs.isEmpty();
2385             if (isValidate) {
2386                 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
2387             } else {
2388                 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2389             }
2390         }
2391         property.setValue(value);
2392         return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
2393     }
2394
2395     protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2396         Resource originResource;
2397         log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
2398         if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2399             Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2400                 .getToscaFullElement(currentCompInstance.getComponentUid());
2401             if (getOriginResourceRes.isRight()) {
2402                 ResponseFormat responseFormat = componentsUtils
2403                     .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
2404                 throw new ComponentException(responseFormat);
2405             }
2406             originResource = getOriginResourceRes.left().value();
2407             originCompMap.put(originResource.getUniqueId(), originResource);
2408         } else {
2409             originResource = originCompMap.get(currentCompInstance.getComponentUid());
2410         }
2411         return originResource;
2412     }
2413
2414     protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
2415                                                                                                       Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2416         Either<Resource, StorageOperationStatus> updateRes = null;
2417         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
2418         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
2419         StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
2420         if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2421             log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
2422                 resource.getUniqueId(), status);
2423             updateRes = Either.right(status);
2424         }
2425         if (updateRes == null) {
2426             fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
2427                 updatedInstRequirements);
2428             status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
2429             if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2430                 updateRes = Either.right(status);
2431             }
2432         }
2433         if (updateRes == null) {
2434             updateRes = Either.left(resource);
2435         }
2436         return updateRes;
2437     }
2438
2439     protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
2440                                                            Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2441                                                            Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
2442                                                            Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
2443         componentInstances.stream().forEach(i -> {
2444             fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
2445             fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
2446         });
2447     }
2448
2449     protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
2450                                                ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
2451         Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
2452         Set<String> updatedCapNames = new HashSet<>();
2453         if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
2454             for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
2455                 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
2456                         c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
2457                     .map(c -> {
2458                         c.setParentName(c.getName());
2459                         c.setName(capabilitiesNamesToUpdate.get(c.getName()));
2460                         updatedCapNames.add(c.getName());
2461                         return c;
2462                     }).collect(toList()));
2463             }
2464         }
2465         if (MapUtils.isNotEmpty(updatedCapabilities)) {
2466             updatedInstCapabilties.put(instance, updatedCapabilities);
2467         }
2468     }
2469
2470     protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
2471                                                ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
2472         Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
2473         Set<String> updatedReqNames = new HashSet<>();
2474         if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
2475             for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
2476                 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
2477                         r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
2478                     .map(r -> {
2479                         r.setParentName(r.getName());
2480                         r.setName(requirementsNamesToUpdate.get(r.getName()));
2481                         updatedReqNames.add(r.getName());
2482                         return r;
2483                     }).collect(toList()));
2484             }
2485         }
2486         if (MapUtils.isNotEmpty(updatedRequirements)) {
2487             updatedInstRequirements.put(instance, updatedRequirements);
2488         }
2489     }
2490
2491     protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2492                                     List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2493         for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2494             UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2495             ComponentInstance currentCompInstance = null;
2496             for (ComponentInstance compInstance : componentInstancesList) {
2497                 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
2498                     currentCompInstance = compInstance;
2499                     break;
2500                 }
2501             }
2502             if (currentCompInstance == null) {
2503                 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
2504                 BeEcompErrorManager.getInstance()
2505                     .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
2506                         BeEcompErrorManager.ErrorSeverity.ERROR);
2507                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2508                 throw new ComponentException(responseFormat);
2509             }
2510             ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
2511             if (addRelationToRiRes.getStatus() != 200) {
2512                 throw new ComponentException(addRelationToRiRes);
2513             }
2514         }
2515     }
2516
2517     protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
2518                                              List<RequirementCapabilityRelDef> relations) {
2519         List<ComponentInstance> componentInstancesList = service.getComponentInstances();
2520         ComponentInstance currentCompInstance = null;
2521         for (ComponentInstance compInstance : componentInstancesList) {
2522             if (compInstance.getName().equals(nodesInfoValue.getName())) {
2523                 currentCompInstance = compInstance;
2524                 break;
2525             }
2526         }
2527         if (currentCompInstance == null) {
2528             log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
2529             BeEcompErrorManager.getInstance()
2530                 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
2531                     BeEcompErrorManager.ErrorSeverity.ERROR);
2532             return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2533         }
2534         String resourceInstanceId = currentCompInstance.getUniqueId();
2535         Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
2536         if (regMap != null) {
2537             Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
2538             while (nodesRegValue.hasNext()) {
2539                 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
2540                 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
2541                 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
2542                     log.debug("Going to create  relation {}", uploadRegInfo.getName());
2543                     String regName = uploadRegInfo.getName();
2544                     RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
2545                     regCapRelDef.setFromNode(resourceInstanceId);
2546                     log.debug("try to find available requirement {} ", regName);
2547                     Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
2548                         .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
2549                     if (eitherReqStatus.isRight()) {
2550                         log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
2551                         return eitherReqStatus.right().value();
2552                     }
2553                     RequirementDefinition validReq = eitherReqStatus.left().value();
2554                     List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
2555                     if (reqAndRelationshipPairList == null) {
2556                         reqAndRelationshipPairList = new ArrayList<>();
2557                     }
2558                     RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
2559                     reqAndRelationshipPair.setRequirement(regName);
2560                     reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
2561                     reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
2562                     RelationshipImpl relationship = new RelationshipImpl();
2563                     relationship.setType(validReq.getCapability());
2564                     reqAndRelationshipPair.setRelationships(relationship);
2565                     ComponentInstance currentCapCompInstance = null;
2566                     for (ComponentInstance compInstance : componentInstancesList) {
2567                         if (compInstance.getName().equals(uploadRegInfo.getNode())) {
2568                             currentCapCompInstance = compInstance;
2569                             break;
2570                         }
2571                     }
2572                     if (currentCapCompInstance == null) {
2573                         log.debug("The component instance  with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
2574                         BeEcompErrorManager.getInstance()
2575                             .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
2576                                 BeEcompErrorManager.ErrorSeverity.ERROR);
2577                         return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2578                     }
2579                     regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
2580                     log.debug("try to find aviable Capability  req name is {} ", validReq.getName());
2581                     CapabilityDefinition aviableCapForRel = serviceImportParseLogic
2582                         .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
2583                     if (aviableCapForRel == null) {
2584                         BeEcompErrorManager.getInstance().logInternalDataError(
2585                             "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
2586                                 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
2587                         return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2588                     }
2589                     reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
2590                     reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
2591                     reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
2592                     CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
2593                     capReqRel.setRelation(reqAndRelationshipPair);
2594                     if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
2595                         capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
2596                     }
2597                     reqAndRelationshipPairList.add(capReqRel);
2598                     regCapRelDef.setRelationships(reqAndRelationshipPairList);
2599                     relations.add(regCapRelDef);
2600                 }
2601             }
2602         }
2603         return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
2604     }
2605
2606     private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
2607         final List<OperationUi> operationUiList = new ArrayList<>();
2608         operations.forEach((operationKey, operationValues) -> {
2609             if (operationKey.equals(relationshipTemplate)) {
2610                 operationUiList.addAll(operationValues);
2611             }
2612         });
2613         return operationUiList;
2614     }
2615
2616     protected Service getResourceAfterCreateRelations(Service service) {
2617         ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
2618         Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
2619         if (eitherGetResource.isRight()) {
2620             serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
2621         }
2622         return eitherGetResource.left().value();
2623     }
2624
2625     protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2626                                              Map<String, Resource> nodeNamespaceMap) {
2627         Either<Resource, ResponseFormat> eitherResource = null;
2628         log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
2629         if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
2630             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
2631             throw new ComponentException(responseFormat);
2632         }
2633         Map<String, Resource> existingNodeTypeMap = new HashMap<>();
2634         if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
2635             nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
2636         }
2637         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
2638         uploadResInstancesMap.values()
2639             .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
2640         if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
2641             try {
2642                 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
2643             } catch (StorageException exp) {
2644                 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
2645                     log.debug("Failed to add component instances to container component {}", service.getName());
2646                     ResponseFormat responseFormat = componentsUtils
2647                         .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
2648                     eitherResource = Either.right(responseFormat);
2649                     throw new ComponentException(eitherResource.right().value());
2650                 }
2651             }
2652         }
2653         Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2654             .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
2655         log.debug("*************finished to get resource {}", service.getUniqueId());
2656         if (eitherGetResource.isRight()) {
2657             ResponseFormat responseFormat = componentsUtils
2658                 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2659                     ComponentTypeEnum.SERVICE);
2660             throw new ComponentException(responseFormat);
2661         }
2662         if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
2663             log.debug("Error when create resource instance from csar. ComponentInstances list empty");
2664             BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
2665             throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
2666         }
2667         return eitherGetResource.left().value();
2668     }
2669
2670     protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
2671                                                 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
2672                                                 Map<ComponentInstance, Resource> resourcesInstancesMap) {
2673         log.debug("*************Going to create  resource instances {}", uploadComponentInstanceInfo.getName());
2674         try {
2675             if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2676                 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
2677             }
2678             Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
2679             ComponentInstance componentInstance = new ComponentInstance();
2680             componentInstance.setComponentUid(refResource.getUniqueId());
2681             Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
2682             if (directives != null && !directives.isEmpty()) {
2683                 componentInstance.setDirectives(new ArrayList<>(directives));
2684             }
2685             UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
2686             if (uploadNodeFilterInfo != null) {
2687                 componentInstance
2688                     .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
2689             }
2690             ComponentTypeEnum containerComponentType = component.getComponentType();
2691             NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
2692             if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
2693                 .isNotEmpty(refResource.getCapabilities())) {
2694                 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
2695                 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
2696                     .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
2697                         uploadComponentInstanceInfo.getCapabilities());
2698                 componentInstance.setCapabilities(validComponentInstanceCapabilities);
2699             }
2700             if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
2701                 ResponseFormat responseFormat = componentsUtils
2702                     .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2703                         uploadComponentInstanceInfo.getType());
2704                 throw new ComponentException(responseFormat);
2705             }
2706             Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2707             componentInstance.setName(uploadComponentInstanceInfo.getName());
2708             componentInstance.setIcon(origResource.getIcon());
2709             resourcesInstancesMap.put(componentInstance, origResource);
2710         } catch (Exception e) {
2711             throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2712         }
2713     }
2714
2715     protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2716                                                             Map<String, Resource> nodeNamespaceMap) {
2717         Resource refResource;
2718         try {
2719             if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2720                 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2721             } else {
2722                 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
2723                     .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
2724                 if (findResourceEither.isRight()) {
2725                     ResponseFormat responseFormat = componentsUtils
2726                         .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
2727                     throw new ComponentException(responseFormat);
2728                 }
2729                 refResource = findResourceEither.left().value();
2730                 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2731             }
2732             String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2733             if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2734                 ResponseFormat responseFormat = componentsUtils
2735                     .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2736                         componentState);
2737                 throw new ComponentException(responseFormat);
2738             }
2739             if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2740                 log.debug("validateResourceInstanceBeforeCreate -  ref resource type is  ", refResource.getResourceType());
2741                 ResponseFormat responseFormat = componentsUtils
2742                     .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2743                         uploadComponentInstanceInfo.getType());
2744                 throw new ComponentException(responseFormat);
2745             }
2746             return refResource;
2747         } catch (Exception e) {
2748             throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2749         }
2750     }
2751
2752     protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2753                                           Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2754                                           List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2755                                           CsarInfo csarInfo, String nodeName) {
2756         try {
2757             for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2758                 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2759                 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2760                     handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2761                         nodeTypeEntry.getKey());
2762                     log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2763                 }
2764             }
2765             Map<String, Object> mappedToscaTemplate = null;
2766             if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2767                 .containsKey(nodeName)) {
2768                 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2769             }
2770             if (MapUtils.isEmpty(mappedToscaTemplate)) {
2771                 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2772             }
2773             createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2774                 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2775         } catch (ComponentException | StorageException e) {
2776             throw e;
2777         } catch (Exception e) {
2778             log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2779             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2780         }
2781     }
2782
2783     protected boolean validateResourceNotExisted(String type) {
2784         try {
2785             Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2786             return latestResource.isRight();
2787         } catch (Exception e) {
2788             log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2789             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2790         }
2791     }
2792
2793     protected Resource handleNestedVF(Service service,
2794                                       Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2795                                       List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2796                                       String nodeName) {
2797         try {
2798             String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2799             Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2800             createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2801                 csarInfo);
2802             log.debug("************* Finished to create node types from yaml {}", yamlName);
2803             if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2804                 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2805                 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2806             }
2807             return new Resource();
2808         } catch (Exception e) {
2809             log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2810             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2811         }
2812     }
2813
2814     protected Resource handleComplexVfc(
2815         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2816         List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2817         try {
2818             Resource oldComplexVfc = null;
2819             Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2820             Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2821                 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2822             if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2823                 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2824                     serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2825                         .getRight());
2826             }
2827             if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2828                 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2829                     oldComplexVfcRes.right().value());
2830                 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2831             } else if (oldComplexVfcRes.isLeft()) {
2832                 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2833                 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2834                     .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2835                         ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2836                 if (eitherValidation.isLeft()) {
2837                     oldComplexVfc = oldComplexVfcRes.left().value();
2838                 }
2839             }
2840             newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2841                 newComplexVfc);
2842             csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2843             LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2844                 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2845             log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2846             final Resource result = serviceImportParseLogic
2847                 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2848             csarInfo.getCreatedNodes().put(nodeName, result);
2849             csarInfo.removeNodeFromQueue();
2850             return result;
2851         } catch (Exception e) {
2852             log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2853             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2854         }
2855     }
2856
2857     protected Resource handleComplexVfc(
2858         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2859         List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2860         Resource oldComplexVfc, Resource newComplexVfc) {
2861         Resource handleComplexVfcRes;
2862         try {
2863             Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2864             String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2865             Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2866                 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2867             CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2868             if (oldComplexVfc == null) {
2869                 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2870                     false, true, nodeName);
2871             } else {
2872                 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2873                     createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2874             }
2875             return handleComplexVfcRes;
2876         } catch (Exception e) {
2877             log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2878             throw new ComponentException(ActionStatus.GENERAL_ERROR);
2879         }
2880     }
2881
2882     protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2883                                               List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2884                                               CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2885                                               Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2886                                               String nodeName, boolean isNested) {
2887         boolean inTransaction = true;
2888         boolean shouldLock = false;
2889         Resource preparedResource = null;
2890         ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2891         try {
2892             uploadComponentInstanceInfoMap = csarBusinessLogic
2893                 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2894             Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2895             if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2896                 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2897             }
2898             preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2899                 isNested).left;
2900             log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2901             serviceImportParseLogic.handleResourceGenericType(preparedResource);
2902             handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2903                 csarInfo, nodeName);
2904             preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2905             preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2906             preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2907         } catch (ComponentException e) {
2908             ResponseFormat responseFormat =
2909                 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2910             log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2911             componentsUtils
2912                 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2913             throw e;
2914         } catch (StorageException e) {
2915             ResponseFormat responseFormat = componentsUtils
2916                 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2917             log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2918             componentsUtils
2919                 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2920             throw e;
2921         }
2922         Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2923             uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2924         if (validateUpdateVfGroupNamesRes.isRight()) {
2925             throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2926         }
2927         Map<String, GroupDefinition> groups;
2928         if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2929             groups = validateUpdateVfGroupNamesRes.left().value();
2930         } else {
2931             groups = uploadComponentInstanceInfoMap.getGroups();
2932         }
2933         serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2934         preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2935         NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2936         Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2937             createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2938         if (updateArtifactsEither.isRight()) {
2939             log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2940             throw new ComponentException(updateArtifactsEither.right().value());
2941         }
2942         preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2943         ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2944         if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2945             ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2946             throw new ComponentException(responseFormat);
2947         }
2948         compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2949         return preparedResource;
2950     }
2951
2952     protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2953                                               Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2954                                               Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2955                                               boolean shouldLock, boolean inTransaction, String nodeName) {
2956         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2957         Resource createdResource;
2958         try {
2959             ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2960                 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2961             if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2962                 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2963             }
2964             log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2965             createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2966                 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2967             log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2968         } catch (ComponentException e) {
2969             ResponseFormat responseFormat =
2970                 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2971             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2972             throw e;
2973         } catch (StorageException e) {
2974             ResponseFormat responseFormat = componentsUtils
2975                 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2976             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2977             throw e;
2978         }
2979         return createdResource;
2980     }
2981
2982     protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2983                                                     AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2984                                                     String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2985                                                     Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2986                                                     boolean shouldLock, boolean inTransaction, String nodeName) {
2987         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2988         if (shouldLock) {
2989             Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2990                 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2991             if (lockResult.isRight()) {
2992                 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2993                 throw new ComponentException(lockResult.right().value());
2994             }
2995             log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2996         }
2997         try {
2998             log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2999             Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
3000             resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
3001             log.trace("************* Going to add inputs from yaml {}", yamlName);
3002             Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
3003             Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
3004             String type = (String) metadata.get("type");
3005             if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
3006                 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
3007             }
3008             Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
3009             resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
3010             Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
3011             resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
3012                 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
3013             log.trace("************* Finished to create nodes, RI and Relation  from yaml {}", yamlName);
3014             // validate update vf module group names
3015             Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
3016                 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
3017             if (validateUpdateVfGroupNamesRes.isRight()) {
3018                 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3019                 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
3020             }
3021             Map<String, GroupDefinition> groups;
3022             log.trace("************* Going to add groups from yaml {}", yamlName);
3023             if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
3024                 groups = validateUpdateVfGroupNamesRes.left().value();
3025             } else {
3026                 groups = parsedToscaYamlInfo.getGroups();
3027             }
3028             Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
3029             if (createGroupsOnResource.isRight()) {
3030                 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3031                 throw new ComponentException(createGroupsOnResource.right().value());
3032             }
3033             resource = createGroupsOnResource.left().value();
3034             log.trace("************* Going to add artifacts from yaml {}", yamlName);
3035             NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
3036             Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
3037                 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
3038             if (createArtifactsEither.isRight()) {
3039                 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3040                 throw new ComponentException(createArtifactsEither.right().value());
3041             }
3042             resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
3043             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
3044             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
3045             ASDCKpiApi.countCreatedResourcesKPI();
3046             return resource;
3047         } catch (ComponentException | StorageException e) {
3048             serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3049             throw e;
3050         } finally {
3051             if (!inTransaction) {
3052                 janusGraphDao.commit();
3053             }
3054             if (shouldLock) {
3055                 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
3056             }
3057         }
3058     }
3059
3060     protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
3061         if (groups != null && !groups.isEmpty()) {
3062             List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
3063             serviceImportParseLogic.handleGroupsProperties(resource, groups);
3064             serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
3065             Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
3066             if (createGroups.isRight()) {
3067                 return Either.right(createGroups.right().value());
3068             }
3069         } else {
3070             return Either.left(resource);
3071         }
3072         Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
3073         if (updatedResource.isRight()) {
3074             ResponseFormat responseFormat = componentsUtils
3075                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
3076             return Either.right(responseFormat);
3077         }
3078         return Either.left(updatedResource.left().value());
3079     }
3080
3081     protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
3082         List<GroupDefinition> result = new ArrayList<>();
3083         List<ComponentInstance> componentInstances = component.getComponentInstances();
3084         if (groups != null) {
3085             for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
3086                 String groupName = entry.getKey();
3087                 GroupDefinition groupDefinition = entry.getValue();
3088                 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
3089                 updatedGroupDefinition.setMembers(null);
3090                 Map<String, String> members = groupDefinition.getMembers();
3091                 if (members != null) {
3092                     updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
3093                 }
3094                 result.add(updatedGroupDefinition);
3095             }
3096         }
3097         return result;
3098     }
3099
3100     protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
3101                                       List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
3102         Set<String> compInstancesNames = members.keySet();
3103         if (CollectionUtils.isEmpty(componentInstances)) {
3104             String membersAstString = compInstancesNames.stream().collect(joining(","));
3105             log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
3106                 groupName, component.getNormalizedName());
3107             throw new ComponentException(componentsUtils
3108                 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3109                     serviceImportParseLogic.getComponentTypeForResponse(component)));
3110         }
3111         Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
3112         memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
3113         Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
3114             .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
3115         if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
3116             List<String> foundMembers = new ArrayList<>();
3117             if (relevantInstances != null) {
3118                 foundMembers = relevantInstances.keySet().stream().collect(toList());
3119             }
3120             compInstancesNames.removeAll(foundMembers);
3121             String membersAstString = compInstancesNames.stream().collect(joining(","));
3122             throw new ComponentException(componentsUtils
3123                 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3124                     serviceImportParseLogic.getComponentTypeForResponse(component)));
3125         }
3126         updatedGroupDefinition.setMembers(relevantInstances);
3127     }
3128
3129     protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
3130         Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
3131             .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
3132         if (eitherValidation.isRight()) {
3133             ResponseFormat errorResponse = componentsUtils
3134                 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
3135             throw new ComponentException(errorResponse);
3136         }
3137         if (Boolean.TRUE.equals(eitherValidation.left().value())) {
3138             log.debug("resource with name: {}, already exists", resource.getName());
3139             ResponseFormat errorResponse = componentsUtils
3140                 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
3141             throw new ComponentException(errorResponse);
3142         }
3143         log.debug("send resource {} to dao for create", resource.getName());
3144         serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
3145         if (!isNormative) {
3146             log.debug("enrich resource with creator, version and state");
3147             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
3148             resource.setVersion(INITIAL_VERSION);
3149             resource.setHighestVersion(true);
3150             if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
3151                 resource.setAbstract(false);
3152             }
3153         }
3154         return toscaOperationFacade.createToscaComponent(resource).left()
3155             .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
3156     }
3157
3158     protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
3159                                                                                    boolean inTransaction, boolean needLock, boolean isNested) {
3160         String lockedResourceId = oldResource.getUniqueId();
3161         log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
3162             oldResource.getLifecycleState());
3163         ImmutablePair<Resource, ActionStatus> resourcePair = null;
3164         try {
3165             serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
3166             oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
3167             serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
3168             serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
3169             serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
3170                 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
3171             createNewResourceToOldResource(newResource, oldResource, user);
3172             Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
3173             if (overrideResource.isRight()) {
3174                 ResponseFormat responseFormat = new ResponseFormat();
3175                 serviceBusinessLogic.throwComponentException(responseFormat);
3176             }
3177             log.debug("Resource updated successfully!!!");
3178             resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
3179             return resourcePair;
3180         } finally {
3181             if (resourcePair == null) {
3182                 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
3183                 janusGraphDao.rollback();
3184             } else if (!inTransaction) {
3185                 janusGraphDao.commit();
3186             }
3187             if (needLock) {
3188                 log.debug("unlock resource {}", lockedResourceId);
3189                 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
3190             }
3191         }
3192     }
3193
3194     protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
3195         newResource.setContactId(newResource.getContactId().toLowerCase());
3196         newResource.setCreatorUserId(user.getUserId());
3197         newResource.setCreatorFullName(user.getFullName());
3198         newResource.setLastUpdaterUserId(user.getUserId());
3199         newResource.setLastUpdaterFullName(user.getFullName());
3200         newResource.setUniqueId(oldResource.getUniqueId());
3201         newResource.setVersion(oldResource.getVersion());
3202         newResource.setInvariantUUID(oldResource.getInvariantUUID());
3203         newResource.setLifecycleState(oldResource.getLifecycleState());
3204         newResource.setUUID(oldResource.getUUID());
3205         newResource.setNormalizedName(oldResource.getNormalizedName());
3206         newResource.setSystemName(oldResource.getSystemName());
3207         if (oldResource.getCsarUUID() != null) {
3208             newResource.setCsarUUID(oldResource.getCsarUUID());
3209         }
3210         if (oldResource.getCsarVersionId() != null) {
3211             newResource.setCsarVersionId(oldResource.getCsarVersionId());
3212         }
3213         if (oldResource.getImportedToscaChecksum() != null) {
3214             newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
3215         }
3216         if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
3217             newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
3218         }
3219         if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
3220             newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
3221         }
3222         if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
3223             serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
3224         }
3225         if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
3226             newResource.setInterfaces(oldResource.getInterfaces());
3227         }
3228         if (CollectionUtils.isEmpty(newResource.getProperties())) {
3229             newResource.setProperties(oldResource.getProperties());
3230         }
3231         if (newResource.getModel() == null) {
3232             newResource.setModel(oldResource.getModel());
3233         }
3234     }
3235
3236     protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
3237                                                                          boolean needLock,
3238                                                                          Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3239                                                                          List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
3240                                                                          Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
3241         try {
3242             Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
3243                 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
3244             if (toscaVersion.isRight()) {
3245                 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
3246             }
3247             Map<String, Object> mapToConvert = new HashMap<>();
3248             mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
3249             Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
3250             createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3251                 mapToConvert, nodeTypes);
3252             return csarInfo.getCreatedNodes();
3253         } catch (Exception e) {
3254             log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
3255             throw new ComponentException(ActionStatus.GENERAL_ERROR);
3256         }
3257     }
3258
3259     protected void createNodeTypes(String yamlName, Service service, boolean needLock,
3260                                    Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3261                                    List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3262                                    Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
3263         Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
3264         Resource vfcCreated = null;
3265         while (nodesNameValueIter.hasNext()) {
3266             Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
3267             String nodeTypeKey = nodeType.getKey();
3268             Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
3269                 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
3270             if (nodeTypesInfo.containsKey(nodeTypeKey)) {
3271                 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3272                     nodeTypeKey);
3273                 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
3274             } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
3275                 .containsKey(nodeTypeKey)) {
3276                 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
3277                     .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
3278                         nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
3279                 log.debug("************* Finished to create node {}", nodeTypeKey);
3280                 vfcCreated = resourceCreated.getLeft();
3281                 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
3282             }
3283             if (vfcCreated != null) {
3284                 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
3285             }
3286             mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
3287         }
3288     }
3289 }