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