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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import static java.util.stream.Collectors.joining;
  24 import static java.util.stream.Collectors.toList;
  25 import static java.util.stream.Collectors.toMap;
  26 import static java.util.stream.Collectors.toSet;
  27 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
  28 import static org.apache.commons.collections.MapUtils.isEmpty;
  29 import static org.apache.commons.collections.MapUtils.isNotEmpty;
  30 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
  31 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
  32 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
  33 import static org.openecomp.sdc.common.api.Constants.DEFAULT_GROUP_VF_MODULE;
  34
  35 import com.google.common.annotations.VisibleForTesting;
  36 import fj.data.Either;
  37 import java.util.ArrayList;
  38 import java.util.Collection;
  39 import java.util.Collections;
  40 import java.util.EnumMap;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.Iterator;
  44 import java.util.List;
  45 import java.util.ListIterator;
  46 import java.util.Map;
  47 import java.util.Map.Entry;
  48 import java.util.Optional;
  49 import java.util.Set;
  50 import java.util.function.Function;
  51 import java.util.regex.Pattern;
  52 import java.util.stream.Collectors;
  53 import javax.servlet.ServletContext;
  54 import org.apache.commons.codec.binary.Base64;
  55 import org.apache.commons.collections.CollectionUtils;
  56 import org.apache.commons.collections.MapUtils;
  57 import org.apache.commons.collections4.ListUtils;
  58 import org.apache.commons.lang.StringUtils;
  59 import org.apache.commons.lang3.tuple.ImmutablePair;
  60 import org.openecomp.sdc.be.catalog.enums.ChangeTypeEnum;
  61 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
  62 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
  63 import org.openecomp.sdc.be.components.csar.CsarInfo;
  64 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  65 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  66 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  67 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  68 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  69 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  70 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  71 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
  72 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  73 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  74 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction.LifecycleChanceActionEnum;
  75 import org.openecomp.sdc.be.components.merge.TopologyComparator;
  76 import org.openecomp.sdc.be.components.merge.property.PropertyDataValueMergeBusinessLogic;
  77 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
  78 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
  79 import org.openecomp.sdc.be.components.property.PropertyConstraintsUtils;
  80 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
  81 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
  82 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
  83 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
  84 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
  85 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
  86 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
  87 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  88 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  89 import org.openecomp.sdc.be.config.ConfigurationManager;
  90 import org.openecomp.sdc.be.dao.api.ActionStatus;
  91 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  92 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  93 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  94 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
  95 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  96 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  97 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  98 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  99 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
 100 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
 101 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 102 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
 103 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
 104 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
 105 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 106 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
 107 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 108 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 109 import org.openecomp.sdc.be.impl.ComponentsUtils;
 110 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
 111 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
 112 import org.openecomp.sdc.be.model.ArtifactDefinition;
 113 import org.openecomp.sdc.be.model.AttributeDefinition;
 114 import org.openecomp.sdc.be.model.CapabilityDefinition;
 115 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
 116 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
 117 import org.openecomp.sdc.be.model.Component;
 118 import org.openecomp.sdc.be.model.ComponentInstance;
 119 import org.openecomp.sdc.be.model.ComponentInstanceInput;
 120 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 121 import org.openecomp.sdc.be.model.ComponentParametersView;
 122 import org.openecomp.sdc.be.model.DataTypeDefinition;
 123 import org.openecomp.sdc.be.model.GroupDefinition;
 124 import org.openecomp.sdc.be.model.InputDefinition;
 125 import org.openecomp.sdc.be.model.InterfaceDefinition;
 126 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
 127 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 128 import org.openecomp.sdc.be.model.NodeTypeInfo;
 129 import org.openecomp.sdc.be.model.Operation;
 130 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
 131 import org.openecomp.sdc.be.model.PolicyDefinition;
 132 import org.openecomp.sdc.be.model.PropertyDefinition;
 133 import org.openecomp.sdc.be.model.RelationshipImpl;
 134 import org.openecomp.sdc.be.model.RelationshipInfo;
 135 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
 136 import org.openecomp.sdc.be.model.RequirementDefinition;
 137 import org.openecomp.sdc.be.model.Resource;
 138 import org.openecomp.sdc.be.model.UploadArtifactInfo;
 139 import org.openecomp.sdc.be.model.UploadCapInfo;
 140 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
 141 import org.openecomp.sdc.be.model.UploadInfo;
 142 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
 143 import org.openecomp.sdc.be.model.UploadPropInfo;
 144 import org.openecomp.sdc.be.model.UploadReqInfo;
 145 import org.openecomp.sdc.be.model.UploadResourceInfo;
 146 import org.openecomp.sdc.be.model.User;
 147 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 148 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 149 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
 150 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
 151 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
 152 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ToscaOperationException;
 153 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
 154 import org.openecomp.sdc.be.model.operations.StorageException;
 155 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
 156 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
 157 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
 158 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
 159 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
 160 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
 161 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 162 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
 163 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 164 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
 165 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
 166 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
 167 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 168 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
 169 import org.openecomp.sdc.be.tosca.CsarUtils;
 170 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
 171 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
 172 import org.openecomp.sdc.be.user.UserBusinessLogic;
 173 import org.openecomp.sdc.be.utils.CommonBeUtils;
 174 import org.openecomp.sdc.be.utils.TypeUtils;
 175 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 176 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
 177 import org.openecomp.sdc.common.api.Constants;
 178 import org.openecomp.sdc.common.datastructure.Wrapper;
 179 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
 180 import org.openecomp.sdc.common.log.elements.LoggerSupportability;
 181 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
 182 import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions;
 183 import org.openecomp.sdc.common.log.enums.StatusCode;
 184 import org.openecomp.sdc.common.log.wrappers.Logger;
 185 import org.openecomp.sdc.common.util.GeneralUtility;
 186 import org.openecomp.sdc.common.util.ValidationUtils;
 187 import org.openecomp.sdc.exception.ResponseFormat;
 188 import org.springframework.beans.factory.annotation.Autowired;
 189 import org.springframework.context.annotation.Lazy;
 190 import org.springframework.web.context.WebApplicationContext;
 191 import org.yaml.snakeyaml.DumperOptions;
 192 import org.yaml.snakeyaml.Yaml;
 193
 194 @org.springframework.stereotype.Component("resourceBusinessLogic")
 195 public class ResourceBusinessLogic extends ComponentBusinessLogic {
 196
 197         private static final String DELETE_RESOURCE = "Delete Resource";
 198         private static final String IN_RESOURCE = "  in resource {} ";
 199         private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
 200         public static final String INITIAL_VERSION = "0.1";
 201         private static final Logger log = Logger.getLogger(ResourceBusinessLogic.class);
 202         private static final String CERTIFICATION_ON_IMPORT = "certification on import";
 203         private static final String CREATE_RESOURCE = "Create Resource";
 204         private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
 205         private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
 206         private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
 207         private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
 208         private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {}  in resource {} ";
 209         private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(ResourceBusinessLogic.class.getName());
 210
 211
 212         private IInterfaceLifecycleOperation interfaceTypeOperation;
 213         private LifecycleBusinessLogic lifecycleBusinessLogic;
 214
 215         private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 216         private final ResourceImportManager resourceImportManager;
 217         private final InputsBusinessLogic inputsBusinessLogic;
 218         private final CompositionBusinessLogic compositionBusinessLogic;
 219         private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
 220     private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
 221     private final MergeInstanceUtils mergeInstanceUtils;
 222     private final UiComponentDataConverter uiComponentDataConverter;
 223     private final CsarBusinessLogic csarBusinessLogic;
 224     private final PropertyBusinessLogic propertyBusinessLogic;
 225         private final PolicyBusinessLogic policyBusinessLogic;
 226
 227         @Autowired
 228     public ResourceBusinessLogic(IElementOperation elementDao,
 229         IGroupOperation groupOperation,
 230         IGroupInstanceOperation groupInstanceOperation,
 231         IGroupTypeOperation groupTypeOperation,
 232         GroupBusinessLogic groupBusinessLogic,
 233         InterfaceOperation interfaceOperation,
 234         InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
 235         ArtifactsBusinessLogic artifactsBusinessLogic,
 236         ComponentInstanceBusinessLogic componentInstanceBusinessLogic, @Lazy ResourceImportManager resourceImportManager,
 237         InputsBusinessLogic inputsBusinessLogic, CompositionBusinessLogic compositionBusinessLogic,
 238         ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
 239         CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic, MergeInstanceUtils mergeInstanceUtils,
 240         UiComponentDataConverter uiComponentDataConverter, CsarBusinessLogic csarBusinessLogic,
 241         ArtifactsOperations artifactToscaOperation, PropertyBusinessLogic propertyBusinessLogic,
 242                 ComponentContactIdValidator componentContactIdValidator,
 243                 ComponentNameValidator componentNameValidator, ComponentTagsValidator componentTagsValidator,
 244                 ComponentValidator componentValidator,
 245                 ComponentIconValidator componentIconValidator,
 246                 ComponentProjectCodeValidator componentProjectCodeValidator,
 247                 ComponentDescriptionValidator componentDescriptionValidator, PolicyBusinessLogic policyBusinessLogic) {
 248         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
 249             interfaceOperation, interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation,
 250                                 componentContactIdValidator, componentNameValidator, componentTagsValidator, componentValidator,
 251                                 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
 252         this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
 253         this.resourceImportManager = resourceImportManager;
 254         this.inputsBusinessLogic = inputsBusinessLogic;
 255         this.compositionBusinessLogic = compositionBusinessLogic;
 256         this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
 257         this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
 258         this.mergeInstanceUtils = mergeInstanceUtils;
 259         this.uiComponentDataConverter = uiComponentDataConverter;
 260         this.csarBusinessLogic = csarBusinessLogic;
 261         this.propertyBusinessLogic = propertyBusinessLogic;
 262                 this.policyBusinessLogic = policyBusinessLogic;
 263     }
 264
 265         @Autowired
 266         private ICapabilityTypeOperation capabilityTypeOperation;
 267
 268         @Autowired
 269         private TopologyComparator topologyComparator;
 270
 271         @Autowired
 272         private ComponentValidator componentValidator;
 273
 274         @Autowired
 275         private PropertyDataValueMergeBusinessLogic propertyDataValueMergeBusinessLogic;
 276
 277         @Autowired
 278         private SoftwareInformationBusinessLogic softwareInformationBusinessLogic;
 279
 280         public LifecycleBusinessLogic getLifecycleBusinessLogic() {
 281                 return lifecycleBusinessLogic;
 282         }
 283
 284     @Autowired
 285     public void setLifecycleManager(LifecycleBusinessLogic lifecycleBusinessLogic) {
 286         this.lifecycleBusinessLogic = lifecycleBusinessLogic;
 287     }
 288
 289         @VisibleForTesting
 290         protected void setComponentValidator(ComponentValidator componentValidator) {
 291                 this.componentValidator = componentValidator;
 292         }
 293
 294         public IElementOperation getElementDao() {
 295                 return elementDao;
 296         }
 297
 298         public void setElementDao(IElementOperation elementDao) {
 299                 this.elementDao = elementDao;
 300         }
 301
 302         public UserBusinessLogic getUserAdmin() {
 303                 return this.userAdmin;
 304         }
 305
 306         @Autowired
 307         public void setUserAdmin(UserBusinessLogic userAdmin) {
 308                 this.userAdmin = userAdmin;
 309         }
 310
 311         public ComponentsUtils getComponentsUtils() {
 312                 return this.componentsUtils;
 313         }
 314
 315         @Autowired
 316         public void setComponentsUtils(ComponentsUtils componentsUtils) {
 317                 this.componentsUtils = componentsUtils;
 318         }
 319
 320         public ArtifactsBusinessLogic getArtifactsManager() {
 321                 return artifactsBusinessLogic;
 322         }
 323
 324         public void setArtifactsManager(ArtifactsBusinessLogic artifactsManager) {
 325                 this.artifactsBusinessLogic = artifactsManager;
 326         }
 327
 328         public ApplicationDataTypeCache getApplicationDataTypeCache() {
 329                 return applicationDataTypeCache;
 330         }
 331
 332     @Autowired
 333     public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
 334         this.applicationDataTypeCache = applicationDataTypeCache;
 335     }
 336
 337     @Autowired
 338     public void setInterfaceTypeOperation(IInterfaceLifecycleOperation interfaceTypeOperation) {
 339         this.interfaceTypeOperation = interfaceTypeOperation;
 340     }
 341
 342         /**
 343          * the method returns a list of all the resources that are certified, the
 344          * returned resources are only abstract or only none abstract according to
 345          * the given param
 346          *
 347          * @param getAbstract
 348          * @param userId
 349          *            TODO
 350          * @return
 351          */
 352         public List<Resource> getAllCertifiedResources(boolean getAbstract, HighestFilterEnum highestFilter,
 353                                                                                                    String userId) {
 354                 User user = validateUserExists(userId);
 355                 Boolean isHighest = null;
 356                 switch (highestFilter) {
 357                         case ALL:
 358                                 break;
 359                         case HIGHEST_ONLY:
 360                                 isHighest = true;
 361                                 break;
 362                         case NON_HIGHEST_ONLY:
 363                                 isHighest = false;
 364                                 break;
 365                         default:
 366                                 break;
 367                 }
 368                 Either<List<Resource>, StorageOperationStatus> getResponse = toscaOperationFacade
 369                                 .getAllCertifiedResources(getAbstract, isHighest);
 370
 371                 if (getResponse.isRight()) {
 372                         throw new StorageException(getResponse.right()
 373                                         .value());
 374                 }
 375
 376                 return getResponse.left()
 377                                 .value();
 378         }
 379
 380         public Either<Map<String, Boolean>, ResponseFormat> validateResourceNameExists(String resourceName,
 381                                                                                                                                                                    ResourceTypeEnum resourceTypeEnum, String userId) {
 382
 383                 validateUserExists(userId);
 384
 385                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
 386                                 .validateComponentNameUniqueness(resourceName, resourceTypeEnum, ComponentTypeEnum.RESOURCE);
 387                 // DE242223
 388         janusGraphDao.commit();
 389
 390                 if (dataModelResponse.isLeft()) {
 391                         Map<String, Boolean> result = new HashMap<>();
 392                         result.put("isValid", dataModelResponse.left()
 393                                         .value());
 394                         log.debug("validation was successfully performed.");
 395                         return Either.left(result);
 396                 }
 397
 398                 ResponseFormat responseFormat = componentsUtils
 399                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
 400                                                 .value()));
 401
 402                 return Either.right(responseFormat);
 403         }
 404
 405         public Resource createResource(Resource resource, AuditingActionEnum auditingAction, User user,
 406                                                                    Map<String, byte[]> csarUIPayload, String payloadName) {
 407                 validateResourceBeforeCreate(resource, user, false);
 408                 String csarUUID = payloadName == null ? resource.getCsarUUID() : payloadName;
 409                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Starting to create resource from CSAR by user {} ", user.getUserId());
 410                 if (StringUtils.isNotEmpty(csarUUID)) {
 411                         csarBusinessLogic.validateCsarBeforeCreate(resource, auditingAction, user, csarUUID);
 412                         log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
 413
 414                         Resource createResourceFromCsar = createResourceFromCsar(resource, user, csarUIPayload, csarUUID);
 415                         return updateCatalog(createResourceFromCsar, ChangeTypeEnum.LIFECYCLE).left()
 416                                         .map(r -> (Resource) r)
 417                                         .left()
 418                                         .value();
 419                 }
 420
 421                 final Resource createResourceByDao = createResourceByDao(resource, user, auditingAction, false, false);
 422                 return updateCatalog(createResourceByDao, ChangeTypeEnum.LIFECYCLE).left()
 423                                 .map(r -> (Resource) r)
 424                                 .left()
 425                                 .value();
 426         }
 427
 428         public Resource validateAndUpdateResourceFromCsar(Resource resource, User user, Map<String, byte[]> csarUIPayload,
 429                                                                                                           String payloadName, String resourceUniqueId) {
 430                 String csarUUID = payloadName;
 431                 String csarVersion = null;
 432                 Resource updatedResource = null;
 433                 if (payloadName == null) {
 434                         csarUUID = resource.getCsarUUID();
 435                         csarVersion = resource.getCsarVersion();
 436                 }
 437                 if (csarUUID != null && !csarUUID.isEmpty()) {
 438                         Resource oldResource = getResourceByUniqueId(resourceUniqueId);
 439                         validateCsarUuidMatching(oldResource, resource, csarUUID, resourceUniqueId, user);
 440                         validateCsarIsNotAlreadyUsed(oldResource, resource, csarUUID, user);
 441                         if (oldResource != null && ValidationUtils.hasBeenCertified(oldResource.getVersion())) {
 442                                 overrideImmutableMetadata(oldResource, resource);
 443                         }
 444                         validateResourceBeforeCreate(resource, user, false);
 445                         String oldCsarVersion = oldResource != null ? oldResource.getCsarVersion() : null;
 446                         log.debug("CsarUUID is {} - going to update resource with UniqueId {} from CSAR", csarUUID,
 447                                         resourceUniqueId);
 448                         // (on boarding flow): If the update includes same csarUUID and
 449                         // same csarVersion as already in the VF - no need to import the
 450                         // csar (do only metadata changes if there are).
 451                         if (csarVersion != null && oldCsarVersion != null && oldCsarVersion.equals(csarVersion)) {
 452                                 updatedResource = updateResourceMetadata(resourceUniqueId, resource, oldResource, user, false);
 453                         } else {
 454                                 updatedResource = updateResourceFromCsar(oldResource, resource, user,
 455                                                 AuditingActionEnum.UPDATE_RESOURCE_METADATA, false, csarUIPayload, csarUUID);
 456                         }
 457                 } else {
 458                         log.debug("Failed to update resource {}, csarUUID or payload name is missing", resource.getSystemName());
 459                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CSAR_UUID,
 460                                         resource.getName());
 461                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.CREATE_RESOURCE);
 462                         throw new ByActionStatusComponentException(ActionStatus.MISSING_CSAR_UUID, resource.getName());
 463                 }
 464                 return updatedResource;
 465         }
 466
 467         private void validateCsarIsNotAlreadyUsed(Resource oldResource, Resource resource, String csarUUID, User user) {
 468                 // (on boarding flow): If the update includes a csarUUID: verify this
 469                 // csarUUID is not in use by another VF, If it is - use same error as
 470                 // above:
 471                 // "Error: The VSP with UUID %1 was already imported for VF %2. Please
 472                 // select another or update the existing VF." %1 - csarUUID, %2 - VF
 473                 // name
 474                 Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = toscaOperationFacade
 475                                 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUUID, resource.getSystemName());
 476                 if (resourceLinkedToCsarRes.isRight()) {
 477                         if (StorageOperationStatus.NOT_FOUND != resourceLinkedToCsarRes.right().value()) {
 478                                 log.debug("Failed to find previous resource by CSAR {} and system name {}", csarUUID,
 479                                                 resource.getSystemName());
 480                                 throw new StorageException(resourceLinkedToCsarRes.right()
 481                                                 .value());
 482                         }
 483                 } else if (!resourceLinkedToCsarRes.left()
 484                                 .value()
 485                                 .getUniqueId()
 486                                 .equals(oldResource.getUniqueId())
 487                                 && !resourceLinkedToCsarRes.left()
 488                                 .value()
 489                                 .getName()
 490                                 .equals(oldResource.getName())) {
 491                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VSP_ALREADY_EXISTS, csarUUID,
 492                                         resourceLinkedToCsarRes.left()
 493                                                         .value()
 494                                                         .getName());
 495                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
 496                         throw new ByActionStatusComponentException(ActionStatus.VSP_ALREADY_EXISTS, csarUUID, resourceLinkedToCsarRes.left()
 497                                         .value()
 498                                         .getName());
 499                 }
 500         }
 501
 502         private void validateCsarUuidMatching(Resource resource, Resource oldResource, String csarUUID,
 503                                                                                   String resourceUniqueId, User user) {
 504                 // (on boarding flow): If the update includes csarUUID which is
 505                 // different from the csarUUID of the VF - fail with
 506                 // error: "Error: Resource %1 cannot be updated using since it is linked
 507                 // to a different VSP" %1 - VF name
 508                 String oldCsarUUID = oldResource.getCsarUUID();
 509                 if (oldCsarUUID != null && !oldCsarUUID.isEmpty() && !csarUUID.equals(oldCsarUUID)) {
 510                         log.debug(
 511                                         "Failed to update resource with UniqueId {} using Csar {}, since the resource is linked to a different VSP {}",
 512                                         resourceUniqueId, csarUUID, oldCsarUUID);
 513                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(
 514                                         ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID, oldCsarUUID);
 515                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
 516                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID,
 517                                         oldCsarUUID);
 518                 }
 519         }
 520
 521         private Resource getResourceByUniqueId(String resourceUniqueId) {
 522                 Either<Resource, StorageOperationStatus> oldResourceRes = toscaOperationFacade
 523                                 .getToscaFullElement(resourceUniqueId);
 524                 if (oldResourceRes.isRight()) {
 525                         log.debug("Failed to find previous resource by UniqueId {}, status: {}", resourceUniqueId,
 526                                         oldResourceRes.right()
 527                                                         .value());
 528                         throw new StorageException(oldResourceRes.right()
 529                                         .value());
 530                 }
 531                 return oldResourceRes.left()
 532                                 .value();
 533         }
 534
 535         private void overrideImmutableMetadata(Resource oldResource, Resource resource) {
 536                 resource.setName(oldResource.getName());
 537                 resource.setIcon(oldResource.getIcon());
 538                 resource.setTags(oldResource.getTags());
 539                 resource.setCategories(oldResource.getCategories());
 540                 resource.setDerivedFrom(oldResource.getDerivedFrom());
 541         }
 542
 543         private Resource updateResourceFromCsar(Resource oldResource, Resource newResource, User user,
 544                                                                                         AuditingActionEnum updateResource, boolean inTransaction, Map<String, byte[]> csarUIPayload,
 545                                                                                         String csarUUID) {
 546                 Resource updatedResource = null;
 547                 validateLifecycleState(oldResource, user);
 548                 String lockedResourceId = oldResource.getUniqueId();
 549                 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 550                 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(newResource, oldResource, user, csarUIPayload, csarUUID);
 551                 lockComponent(lockedResourceId, oldResource, "update Resource From Csar");
 552
 553                 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
 554
 555                 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
 556                                 nodeTypesInfo, csarInfo, oldResource);
 557                 if (findNodeTypesArtifactsToHandleRes.isRight()) {
 558                         log.debug("failed to find node types for update with artifacts during import csar {}. ",
 559                                         csarInfo.getCsarUUID());
 560                         throw new ByResponseFormatComponentException(findNodeTypesArtifactsToHandleRes.right()
 561                                         .value());
 562                 }
 563                 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = findNodeTypesArtifactsToHandleRes
 564                                 .left()
 565                                 .value();
 566                 try {
 567                         updatedResource = updateResourceFromYaml(oldResource, newResource, updateResource, createdArtifacts,
 568                                         csarInfo.getMainTemplateName(), csarInfo.getMainTemplateContent(), csarInfo, nodeTypesInfo,
 569                                         nodeTypesArtifactsToHandle, null, false);
 570
 571                 } catch (ComponentException | StorageException e) {
 572                         rollback(inTransaction, newResource, createdArtifacts, null);
 573                         throw e;
 574         }
 575         finally {
 576             janusGraphDao.commit();
 577                         log.debug("unlock resource {}", lockedResourceId);
 578                         graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
 579                 }
 580                 return updatedResource;
 581
 582         }
 583
 584         private void validateLifecycleState(Resource oldResource, User user) {
 585                 if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT == oldResource.getLifecycleState()
 586                                 && !oldResource.getLastUpdaterUserId()
 587                                 .equals(user.getUserId())) {
 588                         log.debug(
 589                                         "#validateLifecycleState - Current user is not last updater, last updater userId: {}, current user userId: {}",
 590                                         oldResource.getLastUpdaterUserId(), user.getUserId());
 591                         throw new ByActionStatusComponentException(ActionStatus.RESTRICTED_OPERATION);
 592                 }
 593         }
 594
 595         private Resource updateResourceFromYaml(Resource oldResource, Resource newResource, AuditingActionEnum actionEnum,
 596                                                                                         List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent, CsarInfo csarInfo,
 597                                                                                         Map<String, NodeTypeInfo> nodeTypesInfo,
 598                                                                                         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
 599                                                                                         String nodeName, boolean isNested) {
 600                 boolean inTransaction = true;
 601                 boolean shouldLock = false;
 602                 Resource preparedResource = null;
 603                 ParsedToscaYamlInfo uploadComponentInstanceInfoMap;
 604                 try {
 605                         uploadComponentInstanceInfoMap = csarBusinessLogic.getParsedToscaYamlInfo(yamlFileContent, yamlFileName,
 606                                         nodeTypesInfo, csarInfo, nodeName, oldResource);
 607                         Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
 608             if (MapUtils.isEmpty(instances) && newResource.getResourceType() != ResourceTypeEnum.PNF) {
 609                 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
 610             }
 611             preparedResource = updateExistingResourceByImport(newResource, oldResource, csarInfo.getModifier(),
 612                                         inTransaction, shouldLock, isNested).left;
 613                         log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
 614                         handleResourceGenericType(preparedResource);
 615                         handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle,
 616                                         createdArtifacts, nodeTypesInfo, csarInfo, nodeName);
 617                         preparedResource = createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
 618                         Map<String, Resource> existingNodeTypesByResourceNames = new HashMap<>();
 619                         preparedResource = createResourceInstances(yamlFileName, preparedResource, oldResource, instances, csarInfo.getCreatedNodes(), existingNodeTypesByResourceNames);
 620                         preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, oldResource, instances, existingNodeTypesByResourceNames);
 621                 } catch (ComponentException e) {
 622                         ResponseFormat responseFormat = e.getResponseFormat() == null
 623                                         ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
 624                         log.debug("#updateResourceFromYaml - failed to update newResource from yaml {} .The error is {}", yamlFileName,
 625                                         responseFormat);
 626                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(),
 627                                         preparedResource == null ? oldResource : preparedResource, actionEnum);
 628                         throw e;
 629                 } catch (StorageException e) {
 630                         ResponseFormat responseFormat = componentsUtils
 631                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
 632                         log.debug("#updateResourceFromYaml - failed to update newResource from yaml {} .The error is {}", yamlFileName,
 633                                         responseFormat);
 634                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(),
 635                                         preparedResource == null ? oldResource : preparedResource, actionEnum);
 636                         throw e;
 637                 }
 638                 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
 639                                 .validateUpdateVfGroupNames(uploadComponentInstanceInfoMap.getGroups(),
 640                                                 preparedResource.getSystemName());
 641                 if (validateUpdateVfGroupNamesRes.isRight()) {
 642
 643                         throw new ByResponseFormatComponentException(validateUpdateVfGroupNamesRes.right()
 644                                         .value());
 645                 }
 646                 // add groups to newResource
 647                 Map<String, GroupDefinition> groups;
 648
 649                 if (!validateUpdateVfGroupNamesRes.left()
 650                                 .value()
 651                                 .isEmpty()) {
 652                         groups = validateUpdateVfGroupNamesRes.left()
 653                                         .value();
 654                 } else {
 655                         groups = uploadComponentInstanceInfoMap.getGroups();
 656                 }
 657                 handleGroupsProperties(preparedResource, groups);
 658                 Either<Boolean, ActionStatus> isTopologyChanged = topologyComparator.isTopologyChanged(oldResource, preparedResource);
 659
 660                 preparedResource = updateGroupsOnResource(preparedResource, groups);
 661
 662                 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,
 663                                 nodeTypesArtifactsToHandle);
 664
 665                 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactOperationEnum.UPDATE,
 666                                 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts,
 667                                 inTransaction, shouldLock);
 668                 if (updateArtifactsEither.isRight()) {
 669                         log.debug("failed to update artifacts {}", updateArtifactsEither.right()
 670                                         .value());
 671                         throw new ByResponseFormatComponentException(updateArtifactsEither.right()
 672                                         .value());
 673                 }
 674                 preparedResource = getResourceWithGroups(updateArtifactsEither.left()
 675                                 .value()
 676                                 .getUniqueId());
 677
 678                 updateGroupsName(oldResource, preparedResource, isTopologyChanged.left().value());
 679                 updateResourceInstancesNames(oldResource, csarInfo, preparedResource, isTopologyChanged.left().value());
 680
 681                 final String preparedResourceId = preparedResource != null ? preparedResource.getUniqueId() : "";
 682                 preparedResource = getResourceWithGroups(preparedResourceId);
 683
 684                 updateVolumeGroup(preparedResource);
 685
 686                 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldResource, preparedResource);
 687                 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
 688                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus,
 689                                         preparedResource);
 690                         throw new ByResponseFormatComponentException(responseFormat);
 691                 }
 692                 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier()
 693                                 .getUserId());
 694                 return preparedResource;
 695         }
 696
 697         protected void updateVolumeGroup(Resource preparedResource) {
 698                 List<GroupDefinition> groups = preparedResource.safeGetGroups();
 699                 for (GroupDefinition group : groups) {
 700                         Map<String, ArtifactDefinition> createdNewArtifacts = preparedResource.getDeploymentArtifacts();
 701                         if (DEFAULT_GROUP_VF_MODULE.equals(group.getType())) {
 702                                 List<PropertyDataDefinition> volumePropList = group.getProperties().stream().filter(p -> "volume_group".equals(p.getName())).collect(Collectors.toList());
 703                                 if (!volumePropList.isEmpty()) {
 704                                         PropertyDataDefinition volumeProp = volumePropList.get(0);
 705                                         if (volumeProp != null) {
 706                                                 boolean isVolumeGroup = isVolumeGroup(group.getArtifacts(), new ArrayList<>(createdNewArtifacts.values()));
 707
 708                                                 if (!volumePropList.get(0).getValue().equals(String.valueOf(isVolumeGroup))) {
 709                                                         volumeProp.setValue(String.valueOf(isVolumeGroup));
 710                                                         volumeProp.setDefaultValue(String.valueOf(isVolumeGroup));
 711                                                 }
 712                                         }
 713                                 }
 714                         }
 715                 }
 716         }
 717
 718         private void updateGroupsName(Resource oldResource, Resource preparedResource, boolean isTopologyChanged) {
 719                 if (oldResource == null || preparedResource == null) {
 720                         log.debug("Failed to update groups name : oldResource or preparedResource is null");
 721                 } else if (CollectionUtils.isNotEmpty(oldResource.getGroups())
 722                         && CollectionUtils.isNotEmpty(preparedResource.getGroups())) {
 723                         Map<String, String> oldGroups = oldResource.getGroups()
 724                                 .stream()
 725                                 .collect(toMap(GroupDataDefinition::getInvariantName, GroupDataDefinition::getName));
 726
 727                         List<GroupDefinition> updatedGroups = preparedResource.getGroups()
 728                                 .stream()
 729                                 .filter(group -> oldGroups.containsKey(group.getInvariantName()) && !group.getName()
 730                                         .equals(oldGroups.get(group.getInvariantName())))
 731                                 .collect(toList());
 732
 733                         if (CollectionUtils.isNotEmpty(updatedGroups)) {
 734                                 if (isTopologyChanged) {
 735                                         updatedGroups.stream().filter(group -> !group.isVspOriginated())
 736                                                 .forEach(group -> group.setName(oldGroups.get(group.getInvariantName())));
 737                                 } else {
 738                                         updatedGroups.forEach(group -> group.setName(oldGroups.get(group.getInvariantName())));
 739                                 }
 740                                 groupBusinessLogic.updateGroups(preparedResource, updatedGroups, false);
 741                         }
 742                 }
 743         }
 744
 745         private void updateResourceInstancesNames(Resource oldResource, CsarInfo csarInfo, Resource preparedResource,
 746                 boolean isTopologyChanged) {
 747                 if (oldResource == null || preparedResource == null) {
 748                         log.debug("Failed to update resource instances names : oldResource or preparedResource is null");
 749                 } else {
 750                         if (CollectionUtils.isNotEmpty(oldResource.getComponentInstances())) {
 751                                 Map<String, String> oldInstances = oldResource.getComponentInstances()
 752                                         .stream()
 753                                         .collect(toMap(ComponentInstance::getInvariantName, ComponentInstance::getName));
 754                                 List<ComponentInstance> updatedInstances = preparedResource.getComponentInstances()
 755                                         .stream()
 756                                         .filter(i -> oldInstances.containsKey(i.getInvariantName()) && !i.getName()
 757                                                 .equals(oldInstances.get(i.getInvariantName())))
 758                                         .collect(toList());
 759                                 if (CollectionUtils.isNotEmpty(updatedInstances)) {
 760                                         if (isTopologyChanged) {
 761                                                 updatedInstances.stream().filter(i -> !i.isCreatedFromCsar())
 762                                                         .forEach(i -> i.setName(oldInstances.get(i.getInvariantName())));
 763                                         } else {
 764                                                 updatedInstances.forEach(i -> i.setName(oldInstances.get(i.getInvariantName())));
 765                                         }
 766                                 }
 767                         }
 768
 769                         componentInstanceBusinessLogic.updateComponentInstance(ComponentTypeEnum.RESOURCE_PARAM_NAME,
 770                                 null, preparedResource.getUniqueId(), csarInfo.getModifier()
 771                                         .getUserId(),
 772                                 preparedResource.getComponentInstances(), false);
 773                 }
 774         }
 775
 776         private Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation,
 777                                                                                                                                          List<ArtifactDefinition> createdArtifacts, String yamlFileName, CsarInfo csarInfo,
 778                                                                                                                                          Resource preparedResource, NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
 779                                                                                                                                          boolean inTransaction, boolean shouldLock) {
 780
 781                 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
 782                 Resource resource = preparedResource;
 783
 784                 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
 785                                 .getNodeTypesArtifactsToHandle();
 786                 if (preparedResource.getResourceType() == ResourceTypeEnum.CVFC) {
 787                         if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null
 788                                         && !nodeTypesArtifactsToHandle.get(nodeName)
 789                                         .isEmpty()) {
 790                                 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(
 791                                                 preparedResource, nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts,
 792                                                 csarInfo.getModifier(), inTransaction, true);
 793                                 if (handleNodeTypeArtifactsRes.isRight()) {
 794                                         return Either.right(handleNodeTypeArtifactsRes.right()
 795                                                         .value());
 796                                 }
 797                         }
 798                 } else {
 799                         Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource,
 800                                         csarInfo, createdArtifacts,
 801                                         new ArtifactOperationInfo(false, false, operation), shouldLock,
 802                                         inTransaction);
 803                         log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
 804                         if (createdCsarArtifactsEither.isRight()) {
 805                                 return createdCsarArtifactsEither;
 806
 807                         }
 808                         resource = createdCsarArtifactsEither.left()
 809                                         .value();
 810                 }
 811                 return Either.left(resource);
 812         }
 813
 814         private Resource handleResourceGenericType(Resource resource) {
 815                 Resource genericResource = fetchAndSetDerivedFromGenericType(resource);
 816                 if (resource.shouldGenerateInputs()) {
 817                         generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
 818                 }
 819                 return genericResource;
 820         }
 821
 822         private Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandle(
 823                 final Map<String, NodeTypeInfo> nodeTypesInfo, final CsarInfo csarInfo, final Resource oldResource) {
 824
 825                 final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 826                 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat>
 827                         nodeTypesArtifactsToHandleRes = Either.left(nodeTypesArtifactsToHandle);
 828
 829                 try {
 830                         final Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = CsarUtils
 831                                 .extractVfcsArtifactsFromCsar(csarInfo.getCsar());
 832                         final Map<String, ImmutablePair<String, String>> extractedVfcToscaNames = extractVfcToscaNames(
 833                                 nodeTypesInfo, oldResource.getName(), csarInfo);
 834                         log.debug("Going to fetch node types for resource with name {} during import csar with UUID {}. ",
 835                                 oldResource.getName(), csarInfo.getCsarUUID());
 836                         extractedVfcToscaNames.forEach((namespace, vfcToscaNames) -> findAddNodeTypeArtifactsToHandle(csarInfo,
 837                                 nodeTypesArtifactsToHandle, oldResource, extractedVfcsArtifacts, namespace, vfcToscaNames));
 838                 } catch (Exception e) {
 839                         final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 840                         nodeTypesArtifactsToHandleRes = Either.right(responseFormat);
 841                         log.debug("Exception occurred when findNodeTypesUpdatedArtifacts, error is:{}", e.getMessage(), e);
 842                 }
 843                 return nodeTypesArtifactsToHandleRes;
 844         }
 845
 846         private void findAddNodeTypeArtifactsToHandle(CsarInfo csarInfo,
 847                                                                                                   Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
 848                                                                                                   Resource resource, Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts, String namespace,
 849                                                                                                   ImmutablePair<String, String> vfcToscaNames) {
 850
 851                 EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> curNodeTypeArtifactsToHandle = null;
 852                 log.debug("Going to fetch node type with tosca name {}. ", vfcToscaNames.getLeft());
 853                 Resource curNodeType = findVfcResource(csarInfo, resource, vfcToscaNames.getLeft(), vfcToscaNames.getRight(),
 854                                 null);
 855                 if (!isEmpty(extractedVfcsArtifacts)) {
 856                         List<ArtifactDefinition> currArtifacts = new ArrayList<>();
 857                         if (extractedVfcsArtifacts.containsKey(namespace)) {
 858                                 handleAndAddExtractedVfcsArtifacts(currArtifacts, extractedVfcsArtifacts.get(namespace));
 859                         }
 860                         curNodeTypeArtifactsToHandle = findNodeTypeArtifactsToHandle(curNodeType, currArtifacts);
 861                 } else if (curNodeType != null) {
 862                         // delete all artifacts if have not received artifacts from
 863                         // csar
 864                         curNodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
 865                         List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
 866                         // delete all informational artifacts
 867                         artifactsToDelete.addAll(curNodeType.getArtifacts()
 868                                         .values()
 869                                         .stream()
 870                                         .filter(a -> a.getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL)
 871                                         .collect(toList()));
 872                         // delete all deployment artifacts
 873                         artifactsToDelete.addAll(curNodeType.getDeploymentArtifacts()
 874                                         .values());
 875                         if (!artifactsToDelete.isEmpty()) {
 876                                 curNodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
 877                         }
 878                 }
 879                 if (isNotEmpty(curNodeTypeArtifactsToHandle)) {
 880                         nodeTypesArtifactsToHandle.put(namespace, curNodeTypeArtifactsToHandle);
 881                 }
 882         }
 883
 884         private Resource findVfcResource(CsarInfo csarInfo, Resource resource, String currVfcToscaName,
 885                                                                          String previousVfcToscaName, StorageOperationStatus status) {
 886                 if (status != null && status != StorageOperationStatus.NOT_FOUND) {
 887                         log.debug("Error occurred during fetching node type with tosca name {}, error: {}", currVfcToscaName,
 888                                         status);
 889                         ResponseFormat responseFormat = componentsUtils
 890                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(status), csarInfo.getCsarUUID());
 891                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
 892                                         AuditingActionEnum.CREATE_RESOURCE);
 893                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status), csarInfo.getCsarUUID());
 894                 } else if (StringUtils.isNotEmpty(currVfcToscaName)) {
 895                         return (Resource) toscaOperationFacade.getLatestByToscaResourceName(currVfcToscaName)
 896                                         .left()
 897                                         .on(st -> findVfcResource(csarInfo, resource, previousVfcToscaName, null, st));
 898                 }
 899                 return null;
 900         }
 901
 902         private EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> findNodeTypeArtifactsToHandle(Resource curNodeType,
 903                                                                                                                                                                                                    List<ArtifactDefinition> extractedArtifacts) {
 904
 905                 try {
 906                         List<ArtifactDefinition> artifactsToUpload = new ArrayList<>(extractedArtifacts);
 907                         List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
 908                         List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
 909                         processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
 910                                         artifactsToDelete, collectExistingArtifacts(curNodeType));
 911                         return putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete);
 912                 } catch (Exception e) {
 913                         log.debug("Exception occurred when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
 914                         throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 915                 }
 916         }
 917
 918         private EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> putFoundArtifacts(
 919                         List<ArtifactDefinition> artifactsToUpload, List<ArtifactDefinition> artifactsToUpdate,
 920                         List<ArtifactDefinition> artifactsToDelete) {
 921                 EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = null;
 922                 if (!artifactsToUpload.isEmpty() || !artifactsToUpdate.isEmpty() || !artifactsToDelete.isEmpty()) {
 923                         nodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
 924                         if (!artifactsToUpload.isEmpty()) {
 925                                 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload);
 926                         }
 927                         if (!artifactsToUpdate.isEmpty()) {
 928                                 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate);
 929                         }
 930                         if (!artifactsToDelete.isEmpty()) {
 931                                 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
 932                         }
 933                 }
 934                 return nodeTypeArtifactsToHandle;
 935         }
 936
 937         private void processExistingNodeTypeArtifacts(List<ArtifactDefinition> extractedArtifacts,
 938                                                                                                   List<ArtifactDefinition> artifactsToUpload, List<ArtifactDefinition> artifactsToUpdate,
 939                                                                                                   List<ArtifactDefinition> artifactsToDelete, Map<String, ArtifactDefinition> existingArtifacts) {
 940                 if (!existingArtifacts.isEmpty()) {
 941                         extractedArtifacts.stream()
 942                                         .forEach(a -> processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, a));
 943                         artifactsToDelete.addAll(existingArtifacts.values());
 944                 }
 945         }
 946
 947         private void processNodeTypeArtifact(List<ArtifactDefinition> artifactsToUpload,
 948                                                                                  List<ArtifactDefinition> artifactsToUpdate, Map<String, ArtifactDefinition> existingArtifacts,
 949                                                                                  ArtifactDefinition currNewArtifact) {
 950                 Optional<ArtifactDefinition> foundArtifact = existingArtifacts.values()
 951                                 .stream()
 952                                 .filter(a -> a.getArtifactName()
 953                                                 .equals(currNewArtifact.getArtifactName()))
 954                                 .findFirst();
 955                 if (foundArtifact.isPresent()) {
 956                         if (foundArtifact.get()
 957                                         .getArtifactType()
 958                                         .equals(currNewArtifact.getArtifactType())) {
 959                                 updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact.get());
 960                                 existingArtifacts.remove(foundArtifact.get()
 961                                                 .getArtifactLabel());
 962                                 artifactsToUpload.remove(currNewArtifact);
 963                         } else {
 964                                 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
 965                                 throw new ByActionStatusComponentException(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR,
 966                                                 currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(), foundArtifact.get()
 967                                                 .getArtifactType());
 968                         }
 969                 }
 970         }
 971
 972         private void updateFoundArtifact(List<ArtifactDefinition> artifactsToUpdate, ArtifactDefinition currNewArtifact,
 973                                                                          ArtifactDefinition foundArtifact) {
 974                 if (!foundArtifact.getArtifactChecksum()
 975                                 .equals(currNewArtifact.getArtifactChecksum())) {
 976                         foundArtifact.setPayload(currNewArtifact.getPayloadData());
 977                         foundArtifact.setPayloadData(Base64.encodeBase64String(currNewArtifact.getPayloadData()));
 978                         foundArtifact.setArtifactChecksum(
 979                                         GeneralUtility.calculateMD5Base64EncodedByByteArray(currNewArtifact.getPayloadData()));
 980                         artifactsToUpdate.add(foundArtifact);
 981                 }
 982         }
 983
 984         private Map<String, ArtifactDefinition> collectExistingArtifacts(Resource curNodeType) {
 985                 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
 986                 if (curNodeType == null) {
 987                         return existingArtifacts;
 988                 }
 989                 if (MapUtils.isNotEmpty(curNodeType.getDeploymentArtifacts())) {
 990                         existingArtifacts.putAll(curNodeType.getDeploymentArtifacts());
 991                 }
 992                 if (MapUtils.isNotEmpty(curNodeType.getArtifacts())) {
 993                         existingArtifacts.putAll(curNodeType.getArtifacts()
 994                                         .entrySet()
 995                                         .stream()
 996                                         .filter(e -> e.getValue()
 997                                                         .getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL)
 998                                         .collect(toMap(Map.Entry::getKey, Map.Entry::getValue)));
 999                 }
1000                 return existingArtifacts;
1001         }
1002
1003         /**
1004          * Changes resource life cycle state to checked out
1005          *
1006          * @param resource
1007          * @param user
1008          * @param inTransaction
1009          * @return
1010          */
1011         private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
1012                 Either<Resource, ResponseFormat> checkoutResourceRes;
1013                 try {
1014                         if (!resource.getComponentMetadataDefinition()
1015                                         .getMetadataDataDefinition()
1016                                         .getState()
1017                                         .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1018                                 log.debug(
1019                                                 "************* Going to change life cycle state of resource {} to not certified checked out. ",
1020                                                 resource.getName());
1021                                 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic.changeComponentState(
1022                                                 resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
1023                                                 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1024                                                                 LifecycleChanceActionEnum.CREATE_FROM_CSAR),
1025                                                 inTransaction, true);
1026                                 if (checkoutRes.isRight()) {
1027                                         log.debug("Could not change state of component {} with uid {} to checked out. Status is {}. ",
1028                                                         resource.getComponentType()
1029                                                                         .getNodeType(),
1030                                                         resource.getUniqueId(), checkoutRes.right()
1031                                                                         .value()
1032                                                                         .getStatus());
1033                                         checkoutResourceRes = Either.right(checkoutRes.right()
1034                                                         .value());
1035                                 } else {
1036                                         checkoutResourceRes = Either.left((Resource) checkoutRes.left()
1037                                                         .value());
1038                                 }
1039                         } else {
1040                                 checkoutResourceRes = Either.left(resource);
1041                         }
1042                 } catch (Exception e) {
1043                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1044                         checkoutResourceRes = Either.right(responseFormat);
1045                         log.debug("Exception occurred when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(),
1046                                         e);
1047                 }
1048                 return checkoutResourceRes;
1049         }
1050
1051         /**
1052          * Handles Artifacts of NodeType
1053          *
1054          * @param nodeTypeResource
1055          * @param nodeTypeArtifactsToHandle
1056          * @param user
1057          * @param inTransaction
1058          * @return
1059          */
1060         public Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
1061                                                                                                                                                                         Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1062                                                                                                                                                                         List<ArtifactDefinition> createdArtifacts, User user, boolean inTransaction, boolean ignoreLifecycleState) {
1063                 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
1064                 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
1065                 Either<Resource, ResponseFormat> changeStateResponse;
1066                 try {
1067                         changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
1068                         if (changeStateResponse.isRight()) {
1069                                 return Either.right(changeStateResponse.right()
1070                                                 .value());
1071                         }
1072                         nodeTypeResource = changeStateResponse.left()
1073                                         .value();
1074
1075                         List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
1076                         log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
1077                         for (Entry<ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
1078                                         .entrySet()) {
1079                                 ArtifactOperationEnum curOperation = curOperationEntry.getKey();
1080                                 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
1081                                 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
1082                                         log.debug("************* Going to {} artifact to vfc {}", curOperation.name(),
1083                                                         nodeTypeResource.getName());
1084                                         handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
1085                                                         .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user,
1086                                                                         createdArtifacts, new ArtifactOperationInfo(false,
1087                                                                                         ignoreLifecycleState, curOperation),
1088                                                                         false, inTransaction);
1089                                         if (ArtifactOperationEnum.isCreateOrLink(curOperation)) {
1090                                                 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1091                                         }
1092                                         handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1093                                 }
1094                         }
1095                         if (handleNodeTypeArtifactsRes == null) {
1096                                 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
1097                         }
1098                 } catch (Exception e) {
1099                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1100                         handleNodeTypeArtifactsRes = Either.right(responseFormat);
1101                         log.debug("Exception occurred when handleVfcArtifacts, error is:{}", e.getMessage(), e);
1102                 }
1103                 return handleNodeTypeArtifactsRes;
1104         }
1105
1106         private Map<String, ImmutablePair<String, String>> extractVfcToscaNames(final Map<String, NodeTypeInfo> nodeTypesInfo,
1107                                                                                                                                                         final String vfResourceName,
1108                                                                                                                                                         final CsarInfo csarInfo) {
1109                 final Map<String, ImmutablePair<String, String>> vfcToscaNames = new HashMap<>();
1110
1111                 final Map<String, Object> nodes = extractAllNodes(nodeTypesInfo, csarInfo);
1112                 if (!nodes.isEmpty()) {
1113                         final Iterator<Entry<String, Object>> nodesNameEntry = nodes.entrySet().iterator();
1114                         while (nodesNameEntry.hasNext()) {
1115                                 final Entry<String, Object> nodeType = nodesNameEntry.next();
1116                                 final ImmutablePair<String, String> toscaResourceName = buildNestedToscaResourceName(
1117                                         ResourceTypeEnum.VFC.name(), vfResourceName, nodeType.getKey());
1118                                 vfcToscaNames.put(nodeType.getKey(), toscaResourceName);
1119                         }
1120                 }
1121                 for (final NodeTypeInfo cvfc : nodeTypesInfo.values()) {
1122                         vfcToscaNames.put(cvfc.getType(), buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(),
1123                                 vfResourceName, cvfc.getType()));
1124                 }
1125                 return vfcToscaNames;
1126         }
1127
1128         private Map<String, Object> extractAllNodes(Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1129                 Map<String, Object> nodes = new HashMap<>();
1130                 for (NodeTypeInfo nodeTypeInfo : nodeTypesInfo.values()) {
1131                         extractNodeTypes(nodes, nodeTypeInfo.getMappedToscaTemplate());
1132                 }
1133                 extractNodeTypes(nodes, csarInfo.getMappedToscaMainTemplate());
1134                 return nodes;
1135         }
1136
1137         private void extractNodeTypes(Map<String, Object> nodes, Map<String, Object> mappedToscaTemplate) {
1138                 Either<Map<String, Object>, ResultStatusEnum> eitherNodeTypes = ImportUtils
1139                                 .findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
1140                 if (eitherNodeTypes.isLeft()) {
1141                         nodes.putAll(eitherNodeTypes.left()
1142                                         .value());
1143                 }
1144         }
1145
1146         public Resource createResourceFromCsar(Resource resource, User user, Map<String, byte[]> csarUIPayload,
1147                                                                                    String csarUUID) {
1148                 log.trace("************* created successfully from YAML, resource TOSCA ");
1149                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,StatusCode.STARTED,"Starting to create Resource From Csar by user {}", user.getUserId() );
1150                 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, csarUIPayload, csarUUID);
1151                 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
1152                 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
1153                                 nodeTypesInfo, csarInfo, resource);
1154                 if (findNodeTypesArtifactsToHandleRes.isRight()) {
1155                         log.debug("failed to find node types for update with artifacts during import csar {}. ",
1156                                         csarInfo.getCsarUUID());
1157                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1158                                         StatusCode.ERROR,"error: {}",findNodeTypesArtifactsToHandleRes.right().value());
1159                         throw new ByResponseFormatComponentException(findNodeTypesArtifactsToHandleRes.right().value());
1160                 }
1161                 Resource vfResource = createResourceFromYaml(resource, csarInfo.getMainTemplateContent(),
1162                                 csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo, findNodeTypesArtifactsToHandleRes.left()
1163                                                 .value(),
1164                                 true, false, null);
1165                 log.trace("*************VF Resource created successfully from YAML, resource TOSCA name: {}",
1166                                 vfResource.getToscaResourceName());
1167                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,StatusCode.COMPLETE,"Ended create Resource From Csar by user {}", user.getUserId() );
1168                 return vfResource;
1169         }
1170
1171         private Resource validateResourceBeforeCreate(Resource resource, User user, boolean inTransaction) {
1172                 log.trace("validating resource before create");
1173                 user.copyData(validateUser(user, CREATE_RESOURCE, resource, AuditingActionEnum.CREATE_RESOURCE, false));
1174                 // validate user role
1175                 validateUserRole(user, resource, new ArrayList<>(), AuditingActionEnum.CREATE_RESOURCE, null);
1176                 // VF / PNF "derivedFrom" should be null (or ignored)
1177                 if (ModelConverter.isAtomicComponent(resource)) {
1178                         validateDerivedFromNotEmpty(user, resource, AuditingActionEnum.CREATE_RESOURCE);
1179                 }
1180                 return validateResourceBeforeCreate(resource, user, AuditingActionEnum.CREATE_RESOURCE, inTransaction, null);
1181
1182         }
1183
1184         // resource, yamlFileContents, yamlFileName, nodeTypesInfo,csarInfo,
1185         // nodeTypesArtifactsToCreate, true, false, null
1186         private Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
1187                                                                                         Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1188                                                                                         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1189                                                                                         boolean shouldLock, boolean inTransaction, String nodeName) {
1190
1191                 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1192                 Resource createdResource;
1193                 try {
1194             ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
1195             if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
1196                 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1197             }
1198                         log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
1199                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1200                                         StatusCode.STARTED,"");
1201                         createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo,
1202                                         AuditingActionEnum.IMPORT_RESOURCE, false, createdArtifacts, topologyTemplateYaml, nodeTypesInfo,
1203                                         csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
1204                         log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
1205                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1206                                         StatusCode.COMPLETE,"The resource has been created: {}",resource.getName());
1207                 } catch (ComponentException e) {
1208                         ResponseFormat responseFormat = e.getResponseFormat() == null
1209                                         ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
1210                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
1211                                         AuditingActionEnum.IMPORT_RESOURCE);
1212                         throw e;
1213                 } catch (StorageException e) {
1214                         ResponseFormat responseFormat = componentsUtils
1215                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1216                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
1217                                         AuditingActionEnum.IMPORT_RESOURCE);
1218                         throw e;
1219                 }
1220                 return createdResource;
1221
1222         }
1223
1224         public Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource,
1225                                                                                                                                           Map<String, Object> mappedToscaTemplate, boolean needLock,
1226                                                                                                                                           Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1227                                                                                                                                           List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1228                                                                                                                                           CsarInfo csarInfo) {
1229
1230                 Either<String, ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1231                                 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1232                 if (toscaVersion.isRight()) {
1233                         throw new ByActionStatusComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1234                 }
1235                 Map<String, Object> mapToConvert = new HashMap<>();
1236                 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left()
1237                                 .value());
1238                 Map<String, Object> nodeTypes = getNodeTypesFromTemplate(mappedToscaTemplate);
1239                 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1240                                 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1241                 return csarInfo.getCreatedNodes();
1242         }
1243
1244         private Map<String, Object> getNodeTypesFromTemplate(Map<String, Object> mappedToscaTemplate) {
1245                 return ImportUtils.findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES)
1246                                 .left()
1247                                 .orValue(HashMap::new);
1248         }
1249
1250         private void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1251                                                                  Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1252                                                                  List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1253                                                                  CsarInfo csarInfo, Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1254                 Iterator<Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet()
1255                                 .iterator();
1256                 Resource vfcCreated = null;
1257                 while (nodesNameValueIter.hasNext()) {
1258                         Entry<String, Object> nodeType = nodesNameValueIter.next();
1259                         Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = nodeTypesArtifactsToHandle == null
1260                                         || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1261
1262                         if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1263                                 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1264                                 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1265                                                 nodeTypesInfo, csarInfo, nodeType.getKey());
1266                                 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1267                         } else if (csarInfo.getCreatedNodesToscaResourceNames() != null
1268                                         && !csarInfo.getCreatedNodesToscaResourceNames()
1269                                         .containsKey(nodeType.getKey())) {
1270                                 log.trace("************* Going to create node {}", nodeType.getKey());
1271                                 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName,
1272                                                 nodeType, csarInfo.getModifier(), mapToConvert, resource, needLock, nodeTypeArtifactsToHandle,
1273                                                 nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1274                                 log.debug("************* Finished to create node {}", nodeType.getKey());
1275
1276                                 vfcCreated = resourceCreated.getLeft();
1277                                 csarInfo.getCreatedNodesToscaResourceNames()
1278                                                 .put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1279                         }
1280                         if (vfcCreated != null) {
1281                                 csarInfo.getCreatedNodes()
1282                                                 .put(nodeType.getKey(), vfcCreated);
1283                         }
1284                         mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1285                 }
1286         }
1287
1288         private Resource handleNestedVfc(Resource resource,
1289                                                                          Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1290                                                                          List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1291                                                                          String nodeName) {
1292
1293                 String yamlName = nodesInfo.get(nodeName)
1294                                 .getTemplateFileName();
1295                 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName)
1296                                 .getMappedToscaTemplate();
1297
1298                 log.debug("************* Going to create node types from yaml {}", yamlName);
1299                 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle,
1300                                 createdArtifacts, Collections.emptyMap(), csarInfo);
1301                 log.debug("************* Finished to create node types from yaml {}", yamlName);
1302
1303                 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1304                         log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1305                         resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo,
1306                                         nodeName, yamlName);
1307                 }
1308                 return resource;
1309         }
1310
1311         private Resource handleComplexVfc(final Resource resource,
1312                                                                           final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>
1313                                                                                   nodesArtifactsToHandle,
1314                                                                           final List<ArtifactDefinition>
1315                                                                                   createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1316                                                                           final String nodeName, final String yamlName) {
1317
1318                 Resource oldComplexVfc = null;
1319                 Resource newComplexVfc = buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1320                 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1321                         .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1322                 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1323                         oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1324                                         buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1325                 }
1326                 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1327                         log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ",
1328                                 newComplexVfc.getToscaResourceName(), oldComplexVfcRes.right().value());
1329                         throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1330                 } else if (oldComplexVfcRes.isLeft()) {
1331                         log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1332                         final Either<Boolean, ResponseFormat> eitherValidation = validateNestedDerivedFromDuringUpdate(
1333                                         oldComplexVfcRes.left().value(),
1334                                         newComplexVfc, ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1335                         if (eitherValidation.isLeft()) {
1336                                 oldComplexVfc = oldComplexVfcRes.left().value();
1337                         }
1338                 }
1339                 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName,
1340                         yamlName, oldComplexVfc, newComplexVfc);
1341                 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1342                 final LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1343                         LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1344                 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1345                 final Resource result = propagateStateToCertified(csarInfo.getModifier(), newComplexVfc,
1346                                 lifecycleChangeInfo, true, false, true);
1347                 csarInfo.getCreatedNodes().put(nodeName, result);
1348                 csarInfo.removeNodeFromQueue();
1349                 return result;
1350         }
1351
1352         private Resource handleComplexVfc(
1353                         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1354                         List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1355                         String nodeName, String yamlName, Resource oldComplexVfc, Resource newComplexVfc) {
1356
1357                 Resource handleComplexVfcRes;
1358                 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName)
1359                                 .getMappedToscaTemplate();
1360                 String yamlContent = new String(csarInfo.getCsar()
1361                                 .get(yamlName));
1362                 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet()
1363                                 .stream()
1364                                 .collect(toMap(Entry::getKey, e -> e.getValue()
1365                                                 .getUnmarkedCopy()));
1366                 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
1367                 if (oldComplexVfc == null) {
1368                         handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo,
1369                                         csarInfo, nodesArtifactsToHandle, false, true, nodeName);
1370                 } else {
1371                         handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc,
1372                                         AuditingActionEnum.UPDATE_RESOURCE_METADATA, createdArtifacts, yamlContent, yamlName, csarInfo,
1373                                         newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
1374                 }
1375                 return handleComplexVfcRes;
1376         }
1377
1378         private Resource buildValidComplexVfc(Resource resource, CsarInfo csarInfo, String nodeName,
1379                                                                                   Map<String, NodeTypeInfo> nodesInfo) {
1380
1381                 Resource complexVfc = buildComplexVfcMetadata(resource, csarInfo, nodeName, nodesInfo);
1382                 log.debug("************* Going to validate complex VFC from yaml {}", complexVfc.getName());
1383                 csarInfo.addNodeToQueue(nodeName);
1384                 return validateResourceBeforeCreate(complexVfc, csarInfo.getModifier(), AuditingActionEnum.IMPORT_RESOURCE,
1385                                 true, csarInfo);
1386         }
1387
1388         private String getNodeTypeActualName(final String nodeTypefullName, final String nodeTypeNamePrefix) {
1389
1390                 final String nameWithouNamespacePrefix = nodeTypefullName.substring(nodeTypeNamePrefix.length());
1391                 final String[] findTypes = nameWithouNamespacePrefix.split("\\.");
1392
1393                 if(findTypes.length > 1){
1394                         final String resourceType = findTypes[0];
1395                         return nameWithouNamespacePrefix.substring(resourceType.length());
1396                 }
1397                 return nameWithouNamespacePrefix;
1398         }
1399
1400         private ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(final String yamlName,
1401                                                                                                                                                                  final Entry<String, Object> nodeNameValue,
1402                                                                                                                                                                  User user,
1403                                                                                                                                                                  final Map<String, Object> mapToConvert,
1404                                                                                                                                                                  final Resource resourceVf,
1405                                                                                                                                                                  final boolean needLock,
1406                                                                                                                                                                  final Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1407                                                                                                                                                                  final List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1408                                                                                                                                                                  final boolean forceCertificationAllowed,
1409                                                                                                                                                                  final CsarInfo csarInfo,
1410                                                                                                                                                                  final boolean isNested) {
1411
1412                 final UploadResourceInfo resourceMetaData = fillResourceMetadata(
1413                         yamlName, resourceVf, nodeNameValue.getKey(), user);
1414
1415                 final String singleVfcYaml = buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1416                 user = validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true);
1417                 return createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock,
1418                                 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo,
1419                                 nodeNameValue.getKey(), isNested);
1420         }
1421
1422         private String buildNodeTypeYaml(final Entry<String, Object> nodeNameValue,
1423                                                                          final Map<String, Object> mapToConvert,
1424                                                                          final String nodeResourceType,
1425                                                                          final CsarInfo csarInfo) {
1426                 // We need to create a Yaml from each node_types in order to create
1427                 // resource from each node type using import normative flow.
1428                 final DumperOptions options = new DumperOptions();
1429                 options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
1430                 final Yaml yaml = new Yaml(options);
1431
1432                 final Map<String, Object> node = new HashMap<>();
1433                 node.put(buildNestedToscaResourceName(nodeResourceType, csarInfo.getVfResourceName(), nodeNameValue.getKey())
1434                                 .getLeft(), nodeNameValue.getValue());
1435                 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName(), node);
1436
1437                 return yaml.dumpAsMap(mapToConvert);
1438         }
1439
1440         public Boolean validateResourceCreationFromNodeType(Resource resource, User creator) {
1441                 validateDerivedFromNotEmpty(creator, resource, AuditingActionEnum.CREATE_RESOURCE);
1442                 return true;
1443         }
1444
1445         public ImmutablePair<Resource, ActionStatus> createResourceFromNodeType(String nodeTypeYaml,
1446                                                                                                                                                         UploadResourceInfo resourceMetaData, User creator, boolean isInTransaction, boolean needLock,
1447                                                                                                                                                         Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1448                                                                                                                                                         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, boolean forceCertificationAllowed, CsarInfo csarInfo,
1449                                                                                                                                                         String nodeName, boolean isNested) {
1450
1451                 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1452                                 LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1453                 Function<Resource, Boolean> validator = resource -> validateResourceCreationFromNodeType(
1454                                 resource, creator);
1455                 return resourceImportManager.importCertifiedResource(nodeTypeYaml, resourceMetaData, creator, validator,
1456                                 lifecycleChangeInfo, isInTransaction, true, needLock, nodeTypeArtifactsToHandle,
1457                                 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeName, isNested);
1458         }
1459
1460         /**
1461          * Validates if a given node type name has a valid prefix.
1462          *
1463          * @param nodeName node name from definition file
1464          * @param definedResourceNamespaceList is a list of all node type name prefix allowed
1465          * @return a valid node type name prefix if it`s found
1466          */
1467         public Optional<String> validateNodeTypeNamePrefix(final String nodeName,
1468                                                                                                            final List<String> definedResourceNamespaceList) {
1469                 for (final String validNamespace : definedResourceNamespaceList) {
1470                         if (nodeName.startsWith(validNamespace)) {
1471                                 return Optional.of(validNamespace);
1472                         }
1473                 }
1474                 return Optional.empty();
1475         }
1476
1477         private List<String> getDefinedNodeTypeNamespaceList() {
1478                 return ConfigurationManager.getConfigurationManager().getConfiguration().getDefinedResourceNamespace();
1479         }
1480
1481         private UploadResourceInfo fillResourceMetadata(final String yamlName, final Resource resourceVf,
1482                                                                                                         final String nodeName, final User user) {
1483
1484                 final UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1485
1486                 final String nodeTypeNamePrefix = getNodeTypeNamePrefix(nodeName);
1487                 log.debug("Node type Name prefix {}", nodeTypeNamePrefix);
1488
1489                 if (!nodeName.startsWith(nodeTypeNamePrefix)) {
1490                         log.debug("invalid nodeName:{} does not start with {}.", nodeName, getDefinedNodeTypeNamespaceList());
1491                         throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE, yamlName,
1492                                 resourceMetaData.getName(), nodeName);
1493                 }
1494
1495                 final String actualName = this.getNodeTypeActualName(nodeName, nodeTypeNamePrefix);
1496                 final String namePrefix = nodeName.replace(actualName, "");
1497                 String resourceType = namePrefix.substring(nodeTypeNamePrefix.length());
1498                 log.debug("initial  namePrefix:{} resourceType {}. nodeName {} , actualName {} prefix {}", namePrefix,
1499                         resourceType, nodeName, actualName, nodeTypeNamePrefix);
1500
1501                 // if we import from csar, the node_type name can be
1502                 // org.openecomp.resource.abstract.node_name - in this case we always
1503                 // create a vfc
1504                 if (resourceType.equals(Constants.ABSTRACT)) {
1505                         resourceType = ResourceTypeEnum.VFC.name().toLowerCase();
1506                 }
1507
1508                 if (!ResourceTypeEnum.containsIgnoreCase(resourceType)) {
1509                         resourceType = ResourceTypeEnum.VFC.name().toLowerCase();
1510                 }
1511
1512                 // validating type
1513                 if (!ResourceTypeEnum.containsName(resourceType.toUpperCase())) {
1514                         log.debug("invalid resourceType:{} the type is not one of the valide types:{}.",
1515                                 resourceType.toUpperCase(),     ResourceTypeEnum.values());
1516                         throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE, yamlName,
1517                                 resourceMetaData.getName(), nodeName);
1518                 }
1519
1520                 // Setting name
1521                 resourceMetaData.setName(new StringBuilder(resourceVf.getSystemName()).append(actualName).toString());
1522
1523                 // Setting type from name
1524                 final String type = resourceType.toUpperCase();
1525                 resourceMetaData.setResourceType(type);
1526
1527                 resourceMetaData.setDescription(ImportUtils.Constants.INNER_VFC_DESCRIPTION);
1528                 resourceMetaData.setIcon(ImportUtils.Constants.DEFAULT_ICON);
1529                 resourceMetaData.setContactId(user.getUserId());
1530                 resourceMetaData.setVendorName(resourceVf.getVendorName());
1531                 resourceMetaData.setVendorRelease(resourceVf.getVendorRelease());
1532
1533                 // Setting tag
1534                 final List<String> tags = new ArrayList<>();
1535                 tags.add(resourceMetaData.getName());
1536                 resourceMetaData.setTags(tags);
1537
1538                 // Setting category
1539                 final CategoryDefinition category = new CategoryDefinition();
1540                 category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME);
1541                 final SubCategoryDefinition subCategory = new SubCategoryDefinition();
1542                 subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY);
1543                 category.addSubCategory(subCategory);
1544                 final List<CategoryDefinition> categories = new ArrayList<>();
1545                 categories.add(category);
1546                 resourceMetaData.setCategories(categories);
1547
1548                 return resourceMetaData;
1549         }
1550
1551         private Resource buildComplexVfcMetadata(final Resource resourceVf,
1552                                                                                          final CsarInfo csarInfo,
1553                                                                                          final String nodeName,
1554                                                                                          final Map<String, NodeTypeInfo> nodesInfo) {
1555                 final Resource cvfc = new Resource();
1556                 final NodeTypeInfo nodeTypeInfo = nodesInfo.get(nodeName);
1557                 cvfc.setName(buildCvfcName(csarInfo.getVfResourceName(), nodeName));
1558                 cvfc.setNormalizedName(ValidationUtils.normaliseComponentName(cvfc.getName()));
1559                 cvfc.setSystemName(ValidationUtils.convertToSystemName(cvfc.getName()));
1560                 cvfc.setResourceType(ResourceTypeEnum.CVFC);
1561                 cvfc.setAbstract(true);
1562                 cvfc.setDerivedFrom(nodeTypeInfo.getDerivedFrom());
1563                 cvfc.setDescription(ImportUtils.Constants.CVFC_DESCRIPTION);
1564                 cvfc.setIcon(ImportUtils.Constants.DEFAULT_ICON);
1565                 cvfc.setContactId(csarInfo.getModifier()
1566                                 .getUserId());
1567                 cvfc.setCreatorUserId(csarInfo.getModifier()
1568                                 .getUserId());
1569                 cvfc.setVendorName(resourceVf.getVendorName());
1570                 cvfc.setVendorRelease(resourceVf.getVendorRelease());
1571                 cvfc.setResourceVendorModelNumber(resourceVf.getResourceVendorModelNumber());
1572                 cvfc.setToscaResourceName(buildNestedToscaResourceName(
1573                         ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName).getLeft());
1574                 cvfc.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID());
1575
1576                 final List<String> tags = new ArrayList<>();
1577                 tags.add(cvfc.getName());
1578                 cvfc.setTags(tags);
1579
1580                 final CategoryDefinition category = new CategoryDefinition();
1581                 category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME);
1582                 SubCategoryDefinition subCategory = new SubCategoryDefinition();
1583                 subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY);
1584                 category.addSubCategory(subCategory);
1585                 final List<CategoryDefinition> categories = new ArrayList<>();
1586                 categories.add(category);
1587                 cvfc.setCategories(categories);
1588
1589                 cvfc.setVersion(ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION);
1590                 cvfc.setLifecycleState(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE_NOT_CERTIFIED_CHECKOUT);
1591                 cvfc.setHighestVersion(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION);
1592
1593                 return cvfc;
1594         }
1595
1596         private String buildCvfcName(final String resourceVfName, final String nodeName) {
1597
1598                 String nameWithouNamespacePrefix =
1599                         nodeName.substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length());
1600                 String[] findTypes = nameWithouNamespacePrefix.split("\\.");
1601                 String resourceType = findTypes[0];
1602                 String resourceName = resourceVfName + "-" + nameWithouNamespacePrefix.substring(resourceType.length() + 1);
1603                 return addCvfcSuffixToResourceName(resourceName);
1604         }
1605
1606         private Resource createResourceAndRIsFromYaml(final String yamlName,
1607                                                                                                   Resource resource,
1608                                                                                                   final ParsedToscaYamlInfo parsedToscaYamlInfo,
1609                                                                                                   final AuditingActionEnum actionEnum,
1610                                                                                                   final boolean isNormative,
1611                                                                                                   final List<ArtifactDefinition> createdArtifacts,
1612                                                                                                   final String topologyTemplateYaml,
1613                                                                                                   final Map<String, NodeTypeInfo> nodeTypesInfo,
1614                                                                                                   final CsarInfo csarInfo,
1615                                                                                                   final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1616                                                                                                   final boolean shouldLock,
1617                                                                                                   final boolean inTransaction,
1618                                                                                                   final String nodeName) {
1619
1620                 final List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1621
1622         if (shouldLock) {
1623             final Either<Boolean, ResponseFormat> lockResult = lockComponentByName(resource.getSystemName(), resource,
1624                     CREATE_RESOURCE);
1625             if (lockResult.isRight()) {
1626                 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1627                 throw new ByResponseFormatComponentException(lockResult.right().value());
1628             }
1629             log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
1630         }
1631         try {
1632             log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
1633             loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Starting to add inputs from yaml: {}",yamlName);
1634             final Resource genericResource = fetchAndSetDerivedFromGenericType(resource);
1635             resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
1636             log.trace("************* createResourceFromYaml after full create resource {}", yamlName);
1637             log.trace("************* Going to add inputs from yaml {}", yamlName);
1638             if (resource.shouldGenerateInputs())
1639                 generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
1640
1641             final Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
1642             resource = createInputsOnResource(resource, inputs);
1643             log.trace("************* Finish to add inputs from yaml {}", yamlName);
1644             loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,
1645                                 resource.getComponentMetadataForSupportLog(),
1646                                 StatusCode.COMPLETE,"Finish to add inputs from yaml: {}",yamlName);
1647             if (resource.getResourceType() == ResourceTypeEnum.PNF) {
1648                 log.trace("************* Adding generic properties to PNF");
1649                 resource = (Resource) propertyBusinessLogic.copyPropertyToComponent(resource,
1650                                         genericResource.getProperties());
1651                 log.trace("************* Adding software information to PNF");
1652                 softwareInformationBusinessLogic.setSoftwareInformation(resource, csarInfo);
1653                 log.trace("************* Removing non-mano software information file from PNF");
1654                 if (csarInfo.getSoftwareInformationPath().isPresent() &&
1655                         !softwareInformationBusinessLogic.removeSoftwareInformationFile(csarInfo)) {
1656                     log.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR , ResourceBusinessLogic.class.getName(),
1657                             "catalog-be", "Could not remove the software information file.");
1658                 }
1659             }
1660
1661             final Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo
1662                                 .getInstances();
1663             log.trace("************* Going to create nodes, RI's and Relations  from yaml {}", yamlName);
1664             loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Start create nodes, RI and Relations  from yaml: {}",yamlName);
1665             resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
1666                                 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate,
1667                                 nodeName);
1668             log.trace("************* Finished to create nodes, RI and Relation  from yaml {}", yamlName);
1669             loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,
1670                                 resource.getComponentMetadataForSupportLog(),
1671                                 StatusCode.COMPLETE,"Finished to create nodes, RI and Relation  from yaml: {}",yamlName);
1672             // validate update vf module group names
1673             final Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
1674                                 .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), resource.getSystemName());
1675             if (validateUpdateVfGroupNamesRes.isRight()) {
1676                 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1677                 throw new ByResponseFormatComponentException(validateUpdateVfGroupNamesRes.right().value());
1678             }
1679             // add groups to resource
1680             final Map<String, GroupDefinition> groups;
1681             log.trace("************* Going to add groups from yaml {}", yamlName);
1682             loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,resource.getComponentMetadataForSupportLog(),
1683                                 StatusCode.STARTED,"Start to add groups from yaml: {}",yamlName);
1684             if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
1685                 groups = validateUpdateVfGroupNamesRes.left().value();
1686             } else {
1687                 groups = parsedToscaYamlInfo.getGroups();
1688             }
1689
1690                         final Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
1691                         if (createGroupsOnResource.isRight()) {
1692                                 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1693                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,
1694                                         resource.getComponentMetadataForSupportLog(),
1695                                         StatusCode.ERROR,"ERROR while adding groups from yaml: {}",yamlName);
1696                                 throw new ByResponseFormatComponentException(createGroupsOnResource.right().value());
1697                         }
1698                         resource = createGroupsOnResource.left().value();
1699                         log.trace("************* Finished to add groups from yaml {}", yamlName);
1700                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,
1701                                 resource.getComponentMetadataForSupportLog(),
1702                                 StatusCode.COMPLETE,"Finished to add groups from yaml: {}", yamlName);
1703                         log.trace("************* Going to add artifacts from yaml {}", yamlName);
1704                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1705                                 resource.getComponentMetadataForSupportLog(),
1706                                 StatusCode.STARTED,"Started to add artifacts from yaml: {}",yamlName);
1707
1708                         log.trace("************* Starting to add policies from yaml {}", yamlName);
1709                         Map<String, PolicyDefinition> policies = parsedToscaYamlInfo.getPolicies();
1710                         if (MapUtils.isNotEmpty(policies)) {
1711                                 resource = createPoliciesOnResource(resource, policies);
1712                         }
1713                         log.trace("************* Finished to add policies from yaml {}", yamlName);
1714
1715                         final NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts =
1716                                         new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
1717
1718                         final Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(
1719                                 ArtifactOperationEnum.CREATE, createdArtifacts, yamlName, csarInfo, resource,
1720                                 nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
1721                         if (createArtifactsEither.isRight()) {
1722                                 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1723                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1724                                         resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"error happened {}",
1725                                         createArtifactsEither.right().value());
1726                                 throw new ByResponseFormatComponentException(createArtifactsEither.right().value());
1727                         }
1728                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1729                                 resource.getComponentMetadataForSupportLog(),
1730                                 StatusCode.COMPLETE,"Finished to add artifacts from yaml: "+resource.getToscaResourceName());
1731                         final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
1732                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
1733                         ASDCKpiApi.countCreatedResourcesKPI();
1734                         return resource;
1735
1736         } catch (final ComponentException | StorageException e) {
1737             rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1738             throw e;
1739         } catch (final ToscaOperationException e) {
1740             log.error("An error has occurred during resource and resource instance creation", e);
1741             rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1742             log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, ResourceBusinessLogic.class.getName(),
1743                                 "catalog-be", e.getMessage());
1744             throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1745         } catch (final BusinessLogicException e) {
1746             log.error("An error has occurred during resource and resource instance creation", e);
1747             rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1748             throw new ByResponseFormatComponentException(e.getResponseFormat());
1749         } finally {
1750             if (!inTransaction) {
1751                 janusGraphDao.commit();
1752                         }
1753                         if (shouldLock) {
1754                                 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(),
1755                                         NodeTypeEnum.Resource);
1756                         }
1757                 }
1758         }
1759
1760         private void rollback(boolean inTransaction, Resource resource, List<ArtifactDefinition> createdArtifacts,
1761                                                   List<ArtifactDefinition> nodeTypesNewCreatedArtifacts) {
1762                 if (!inTransaction) {
1763             janusGraphDao.rollback();
1764                 }
1765                 if (isNotEmpty(createdArtifacts) && isNotEmpty(nodeTypesNewCreatedArtifacts)) {
1766                         createdArtifacts.addAll(nodeTypesNewCreatedArtifacts);
1767                         log.debug("Found {} newly created artifacts to deleted, the component name: {}", createdArtifacts.size(),
1768                                         resource.getName());
1769                 }
1770         }
1771
1772         private Resource getResourceWithGroups(String resourceId) {
1773
1774                 ComponentParametersView filter = new ComponentParametersView();
1775                 filter.setIgnoreGroups(false);
1776                 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resourceId,
1777                                 filter);
1778                 if (updatedResource.isRight()) {
1779                         rollbackWithException(componentsUtils.convertFromStorageResponse(updatedResource.right()
1780                                         .value()), resourceId);
1781                 }
1782                 return updatedResource.left()
1783                                 .value();
1784         }
1785
1786         private Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource,
1787                                                                                                                                         Map<String, GroupDefinition> groups) {
1788                 if (groups != null && !groups.isEmpty()) {
1789                         List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
1790                         handleGroupsProperties(resource, groups);
1791                         fillGroupsFinalFields(groupsAsList);
1792                         Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource,
1793                                         groupsAsList, true);
1794                         if (createGroups.isRight()) {
1795                                 return Either.right(createGroups.right()
1796                                                 .value());
1797                         }
1798                 }
1799                 return Either.left(resource);
1800         }
1801
1802         private void handleGroupsProperties(Resource resource, Map<String, GroupDefinition> groups) {
1803                 List<InputDefinition> inputs = resource.getInputs();
1804                 if (MapUtils.isNotEmpty(groups)) {
1805                         groups.values()
1806                                         .stream()
1807                                         .filter(g -> isNotEmpty(g.getProperties()))
1808                                         .flatMap(g -> g.getProperties()
1809                                                         .stream())
1810                                         .forEach(p -> handleGetInputs(p, inputs));
1811                 }
1812         }
1813
1814     private Resource createPoliciesOnResource(Resource resource, Map<String, PolicyDefinition> policies) {
1815                 policyBusinessLogic.createPoliciesFromParsedCsar(resource, policies);
1816                 return resource;
1817     }
1818
1819         private void handleGetInputs(PropertyDataDefinition property, List<InputDefinition> inputs) {
1820                 if (isNotEmpty(property.getGetInputValues())) {
1821                         if (inputs == null || inputs.isEmpty()) {
1822                                 log.debug("Failed to add property {} to group. Inputs list is empty ", property);
1823                                 rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, property.getGetInputValues()
1824                                                 .stream()
1825                                                 .map(GetInputValueDataDefinition::getInputName)
1826                                                 .collect(toList())
1827                                                 .toString());
1828                         }
1829                         ListIterator<GetInputValueDataDefinition> getInputValuesIter = property.getGetInputValues()
1830                                         .listIterator();
1831                         while (getInputValuesIter.hasNext()) {
1832                                 GetInputValueDataDefinition getInput = getInputValuesIter.next();
1833                                 Either<InputDefinition, RuntimeException> inputEither = findInputByName(inputs, getInput);
1834                                 if (inputEither.isRight()) {
1835                                         throw inputEither.right().value();
1836                                 } else {
1837                                         InputDefinition input = inputEither.left().value();
1838                                         getInput.setInputId(input.getUniqueId());
1839                                         if (getInput.getGetInputIndex() != null) {
1840                                                 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1841                                                 Either<InputDefinition, RuntimeException> newInputEither = findInputByName(inputs,
1842                                                         getInputIndex);
1843                                                 if (newInputEither.isRight()) {
1844                                                         throw newInputEither.right().value();
1845                                                 } else {
1846                                                         InputDefinition newInput = newInputEither.left().value();
1847                                                         getInputIndex.setInputId(newInput.getUniqueId());
1848                                                 }
1849                                                 getInputValuesIter.add(getInputIndex);
1850                                         }
1851                                 }
1852                         }
1853                 }
1854         }
1855
1856         static <T> Either<T, RuntimeException> rollbackWithEither(
1857                 final JanusGraphDao janusGraphDao,
1858                 final ActionStatus actionStatus,
1859                 final String... params) {
1860                 if (janusGraphDao != null)
1861                         janusGraphDao.rollback();
1862                 return Either.right(new ByActionStatusComponentException(actionStatus, params));
1863         }
1864
1865         <T> Either<T, RuntimeException> rollbackWithEither(
1866                 final ActionStatus actionStatus,
1867                 final String... params) {
1868                 return rollbackWithEither(janusGraphDao, actionStatus, params);
1869         }
1870
1871         private Either<InputDefinition, RuntimeException> findInputByName(List<InputDefinition> inputs, GetInputValueDataDefinition getInput) {
1872
1873                 final String inputName = getInput != null ? getInput.getInputName() : "";
1874
1875                 if(inputs == null || inputs.isEmpty()) {
1876                         log.debug("#findInputByName - Inputs list is empty");
1877                         return rollbackWithEither(ActionStatus.INPUTS_NOT_FOUND, inputName);
1878                 } else {
1879                         Optional<InputDefinition> inputOpt = inputs.stream()
1880                                 .filter(p -> p.getName().equals(inputName))
1881                                 .findFirst();
1882                         if (!inputOpt.isPresent()) {
1883                                 log.debug("#findInputByName - Failed to find the input {} ", inputName);
1884                                 return rollbackWithEither(ActionStatus.INPUTS_NOT_FOUND, inputName);
1885                         } else {
1886                                 return Either.left(inputOpt.get());
1887                         }
1888                 }
1889         }
1890
1891         private void fillGroupsFinalFields(List<GroupDefinition> groupsAsList) {
1892                 groupsAsList.forEach(groupDefinition -> {
1893                         groupDefinition.setInvariantName(groupDefinition.getName());
1894                         groupDefinition.setCreatedFrom(CreatedFrom.CSAR);
1895                 });
1896         }
1897
1898         private Resource updateGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
1899                 if (isEmpty(groups)) {
1900                         return resource;
1901                 }
1902                 return updateOrCreateGroups(resource, groups);
1903         }
1904
1905         private Resource updateOrCreateGroups(Resource resource, Map<String, GroupDefinition> groups) {
1906                 List<GroupDefinition> groupsFromResource = resource.getGroups();
1907                 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
1908                 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1909                 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1910                 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1911                 if (isNotEmpty(groupsFromResource)) {
1912                         addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1913                         addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1914                 } else {
1915                         groupsToCreate.addAll(groupsAsList);
1916                 }
1917                 if (isNotEmpty(groupsToCreate)) {
1918                         fillGroupsFinalFields(groupsToCreate);
1919                         if (isNotEmpty(groupsFromResource)) {
1920                                 groupBusinessLogic.addGroups(resource, groupsToCreate, true)
1921                                                 .left()
1922                                                 .on(this::throwComponentException);
1923                         } else {
1924                                 groupBusinessLogic.createGroups(resource, groupsToCreate, true)
1925                                                 .left()
1926                                                 .on(this::throwComponentException);
1927                         }
1928                 }
1929                 if (isNotEmpty(groupsToDelete)) {
1930                         groupBusinessLogic.deleteGroups(resource, groupsToDelete)
1931                                         .left()
1932                                         .on(this::throwComponentException);
1933                 }
1934                 if (isNotEmpty(groupsToUpdate)) {
1935                         groupBusinessLogic.updateGroups(resource, groupsToUpdate, true)
1936                                         .left()
1937                                         .on(this::throwComponentException);
1938                 }
1939                 return resource;
1940
1941         }
1942
1943         private void addGroupsToDelete(List<GroupDefinition> groupsFromResource, List<GroupDefinition> groupsAsList,
1944                                                                    List<GroupDefinition> groupsToDelete) {
1945                 for (GroupDefinition group : groupsFromResource) {
1946                         Optional<GroupDefinition> op = groupsAsList.stream()
1947                                         .filter(p -> p.getInvariantName()
1948                                                         .equalsIgnoreCase(group.getInvariantName()))
1949                                         .findAny();
1950                         if (!op.isPresent() && (group.getArtifacts() == null || group.getArtifacts()
1951                                         .isEmpty())) {
1952                                 groupsToDelete.add(group);
1953                         }
1954                 }
1955         }
1956
1957         private void addGroupsToCreateOrUpdate(List<GroupDefinition> groupsFromResource, List<GroupDefinition> groupsAsList,
1958                                                                                    List<GroupDefinition> groupsToUpdate, List<GroupDefinition> groupsToCreate) {
1959                 for (GroupDefinition group : groupsAsList) {
1960                         Optional<GroupDefinition> op = groupsFromResource.stream()
1961                                         .filter(p -> p.getInvariantName()
1962                                                         .equalsIgnoreCase(group.getInvariantName()))
1963                                         .findAny();
1964                         if (op.isPresent()) {
1965                                 GroupDefinition groupToUpdate = op.get();
1966                                 groupToUpdate.setMembers(group.getMembers());
1967                                 groupToUpdate.setCapabilities(group.getCapabilities());
1968                                 groupToUpdate.setProperties(group.getProperties());
1969                                 groupsToUpdate.add(groupToUpdate);
1970                         } else {
1971                                 groupsToCreate.add(group);
1972                         }
1973                 }
1974         }
1975
1976         private Resource createInputsOnResource(Resource resource, Map<String, InputDefinition> inputs) {
1977                 List<InputDefinition> resourceProperties = resource.getInputs();
1978                 if (MapUtils.isNotEmpty(inputs) || isNotEmpty(resourceProperties)) {
1979
1980                         Either<List<InputDefinition>, ResponseFormat> createInputs = inputsBusinessLogic.createInputsInGraph(inputs,
1981                                         resource);
1982                         if (createInputs.isRight()) {
1983                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(),
1984                                                 StatusCode.ERROR,"failed to add inputs from yaml: {}",createInputs.right()
1985                                                                 .value());
1986                                 throw new ByResponseFormatComponentException(createInputs.right()
1987                                                 .value());
1988                         }
1989                         resource.setInputs(createInputs.left().value());
1990                 }
1991                 return resource;
1992         }
1993
1994         private List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups,
1995                                                                                                                                    Resource component) {
1996
1997                 List<GroupDefinition> result = new ArrayList<>();
1998                 List<ComponentInstance> componentInstances = component.getComponentInstances();
1999
2000                 if (groups != null) {
2001                         Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies = validateCyclicGroupsDependencies(groups);
2002                         if (validateCyclicGroupsDependencies.isRight()) {
2003                                 throw new ByResponseFormatComponentException(validateCyclicGroupsDependencies.right().value());
2004                         }
2005                         for (Entry<String, GroupDefinition> entry : groups.entrySet()) {
2006                                 String groupName = entry.getKey();
2007                                 GroupDefinition groupDefinition = entry.getValue();
2008                                 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2009                                 updatedGroupDefinition.setMembers(null);
2010                                 Map<String, String> members = groupDefinition.getMembers();
2011                                 if (members != null) {
2012                                         updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName,
2013                                                         members);
2014                                 }
2015                                 result.add(updatedGroupDefinition);
2016                         }
2017                 }
2018                 return result;
2019         }
2020
2021         private void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition,
2022                                                                         Resource component, List<ComponentInstance> componentInstances, String groupName,
2023                                                                         Map<String, String> members) {
2024                 Set<String> compInstancesNames = members.keySet();
2025
2026                 if (CollectionUtils.isEmpty(componentInstances)) {
2027                         String membersAstString = compInstancesNames.stream()
2028                                         .collect(joining(","));
2029                         log.debug(
2030                                         "The members: {}, in group: {}, cannot be found in component {}. There are no component instances.",
2031                                         membersAstString, groupName, component.getNormalizedName());
2032                         throw new ByActionStatusComponentException(
2033                                         ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString,
2034                                         groupName, component.getNormalizedName(), getComponentTypeForResponse(component));
2035                 }
2036                 // Find all component instances with the member names
2037                 Map<String, String> memberNames = componentInstances.stream()
2038                                 .collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2039                 memberNames.putAll(groups.keySet()
2040                                 .stream()
2041                                 .collect(toMap(g -> g, g -> "")));
2042                 Map<String, String> relevantInstances = memberNames.entrySet()
2043                                 .stream()
2044                                 .filter(n -> compInstancesNames.contains(n.getKey()))
2045                                 .collect(toMap(Entry::getKey, Entry::getValue));
2046
2047                 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2048
2049                         List<String> foundMembers = new ArrayList<>();
2050                         if (relevantInstances != null) {
2051                                 foundMembers = relevantInstances.keySet()
2052                                                 .stream()
2053                                                 .collect(toList());
2054                         }
2055                         compInstancesNames.removeAll(foundMembers);
2056                         String membersAstString = compInstancesNames.stream()
2057                                         .collect(joining(","));
2058                         log.debug("The members: {}, in group: {}, cannot be found in component: {}", membersAstString, groupName,
2059                                         component.getNormalizedName());
2060                         throw new ByActionStatusComponentException(
2061                                         ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString,
2062                                         groupName, component.getNormalizedName(), getComponentTypeForResponse(component));
2063                 }
2064                 updatedGroupDefinition.setMembers(relevantInstances);
2065         }
2066
2067         /**
2068          * This Method validates that there is no cyclic group dependencies. meaning
2069          * group A as member in group B which is member in group A
2070          *
2071          * @param allGroups
2072          * @return
2073          */
2074         private Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies(Map<String, GroupDefinition> allGroups) {
2075
2076                 Either<Boolean, ResponseFormat> result = Either.left(true);
2077                 try {
2078                         Iterator<Entry<String, GroupDefinition>> allGroupsItr = allGroups.entrySet()
2079                                         .iterator();
2080                         while (allGroupsItr.hasNext() && result.isLeft()) {
2081                                 Entry<String, GroupDefinition> groupAEntry = allGroupsItr.next();
2082                                 // Fetches a group member A
2083                                 String groupAName = groupAEntry.getKey();
2084                                 // Finds all group members in group A
2085                                 Set<String> allGroupAMembersNames = new HashSet<>();
2086                                 fillAllGroupMemebersRecursivly(groupAEntry.getKey(), allGroups, allGroupAMembersNames);
2087                                 // If A is a group member of itself found cyclic dependency
2088                                 if (allGroupAMembersNames.contains(groupAName)) {
2089                                         ResponseFormat responseFormat = componentsUtils
2090                                                         .getResponseFormat(ActionStatus.GROUP_HAS_CYCLIC_DEPENDENCY, groupAName);
2091                                         result = Either.right(responseFormat);
2092                                 }
2093                         }
2094                 } catch (Exception e) {
2095                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
2096                         result = Either.right(responseFormat);
2097                         log.debug("Exception occurred when validateCyclicGroupsDependencies, error is:{}", e.getMessage(), e);
2098                 }
2099                 return result;
2100         }
2101
2102         /**
2103          * This Method fills recursively the set groupMembers with all the members
2104          * of the given group which are also of type group.
2105          *
2106          * @param groupName
2107          * @param allGroups
2108          * @param allGroupMembers
2109          * @return
2110          */
2111         private void fillAllGroupMemebersRecursivly(String groupName, Map<String, GroupDefinition> allGroups,
2112                                                                                                 Set<String> allGroupMembers) {
2113
2114                 // Found Cyclic dependency
2115                 if (isfillGroupMemebersRecursivlyStopCondition(groupName, allGroups, allGroupMembers)) {
2116                         return;
2117                 }
2118                 GroupDefinition groupDefinition = allGroups.get(groupName);
2119                 // All Members Of Current Group Resource Instances & Other Groups
2120                 Set<String> currGroupMembers = groupDefinition.getMembers()
2121                                 .keySet();
2122                 // Filtered Members Of Current Group containing only members which
2123                 // are groups
2124                 List<String> currGroupFilteredMembers = currGroupMembers.stream()
2125                                 .
2126                                 // Keep Only Elements of type group and not Resource Instances
2127                                                 filter(allGroups::containsKey)
2128                                 .
2129                                 // Add Filtered Elements to main Set
2130                                                 peek(allGroupMembers::add)
2131                                 .
2132                                 // Collect results
2133                                                 collect(toList());
2134
2135                 // Recursively call the method for all the filtered group members
2136                 for (String innerGroupName : currGroupFilteredMembers) {
2137                         fillAllGroupMemebersRecursivly(innerGroupName, allGroups, allGroupMembers);
2138                 }
2139
2140         }
2141
2142         private boolean isfillGroupMemebersRecursivlyStopCondition(String groupName, Map<String, GroupDefinition> allGroups,
2143                                                                                                                            Set<String> allGroupMembers) {
2144
2145                 boolean stop = false;
2146                 // In Case Not Group Stop
2147                 if (!allGroups.containsKey(groupName)) {
2148                         stop = true;
2149                 }
2150                 // In Case Group Has no members stop
2151                 if (!stop) {
2152                         GroupDefinition groupDefinition = allGroups.get(groupName);
2153                         stop = isEmpty(groupDefinition.getMembers());
2154
2155                 }
2156                 // In Case all group members already contained stop
2157                 if (!stop) {
2158                         final Set<String> allMembers = allGroups.get(groupName)
2159                                         .getMembers()
2160                                         .keySet();
2161                         Set<String> membersOfTypeGroup = allMembers.stream()
2162                                         .
2163                                         // Filter In Only Group members
2164                                                         filter(allGroups::containsKey)
2165                                         .
2166                                         // Collect
2167                                                         collect(toSet());
2168                         stop = allGroupMembers.containsAll(membersOfTypeGroup);
2169                 }
2170                 return stop;
2171         }
2172
2173         private Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
2174                                                                                                   Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap, String topologyTemplateYaml,
2175                                                                                                   List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2176                                                                                                   CsarInfo csarInfo,
2177                                                                                                   Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2178                                                                                                   String nodeName) {
2179
2180                 log.debug("************* Going to create all nodes {}", yamlName);
2181                 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate,
2182                                 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
2183                 log.debug("************* Finished to create all nodes {}", yamlName);
2184                 log.debug("************* Going to create all resource instances {}", yamlName);
2185                 Map<String, Resource> existingNodeTypesByResourceNames = new HashMap<>();
2186                 resource = createResourceInstances(yamlName, resource, null, uploadComponentInstanceInfoMap,
2187                                 csarInfo.getCreatedNodes(), existingNodeTypesByResourceNames);
2188                 log.debug("************* Finished to create all resource instances {}", yamlName);
2189                 log.debug("************* Going to create all relations {}", yamlName);
2190                 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, null, uploadComponentInstanceInfoMap, existingNodeTypesByResourceNames);
2191                 log.debug("************* Finished to create all relations {}", yamlName);
2192                 log.debug("************* Going to create positions {}", yamlName);
2193                 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier()
2194                                 .getUserId());
2195                 log.debug("************* Finished to set positions {}", yamlName);
2196                 return resource;
2197         }
2198
2199         private void handleAndAddExtractedVfcsArtifacts(List<ArtifactDefinition> vfcArtifacts,
2200                                                                                                         List<ArtifactDefinition> artifactsToAdd) {
2201                 List<String> vfcArtifactNames = vfcArtifacts.stream()
2202                                 .map(ArtifactDataDefinition::getArtifactName)
2203                                 .collect(toList());
2204                 artifactsToAdd.stream()
2205                                 .forEach(a -> {
2206                                         if (!vfcArtifactNames.contains(a.getArtifactName())) {
2207                                                 vfcArtifacts.add(a);
2208                                         } else {
2209                                                 log.debug("Can't upload two artifact with the same name {}. ", a.getArtifactName());
2210                                         }
2211                                 });
2212
2213         }
2214
2215         @SuppressWarnings("unchecked")
2216         private void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
2217                                                                  Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2218                                                                  List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2219                                                                  CsarInfo csarInfo, String nodeName) {
2220                 try {
2221                         for (Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2222                                 if (nodeTypeEntry.getValue()
2223                                                 .isNested()) {
2224
2225                                         handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
2226                                                         csarInfo, nodeTypeEntry.getKey());
2227                                         log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2228                                 }
2229                         }
2230                         Map<String, Object> mappedToscaTemplate = null;
2231                         if (StringUtils.isNotEmpty(nodeName) && isNotEmpty(nodeTypesInfo) && nodeTypesInfo.containsKey(nodeName)) {
2232                                 mappedToscaTemplate = nodeTypesInfo.get(nodeName)
2233                                                 .getMappedToscaTemplate();
2234                         }
2235                         if (isEmpty(mappedToscaTemplate)) {
2236                                 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2237                         }
2238                         createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock,
2239                                         nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2240                 } catch (ComponentException e) {
2241                         ResponseFormat responseFormat = e.getResponseFormat() != null ? e.getResponseFormat()
2242                                         : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2243                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
2244                                         AuditingActionEnum.IMPORT_RESOURCE);
2245                         throw e;
2246                 } catch (StorageException e) {
2247                         ResponseFormat responseFormat = componentsUtils
2248                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2249                         componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
2250                                         AuditingActionEnum.IMPORT_RESOURCE);
2251                         throw e;
2252                 }
2253         }
2254
2255         private Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo,
2256                                                                                                                                    List<ArtifactDefinition> createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock,
2257                                                                                                                                    boolean inTransaction) {
2258
2259                 if (csarInfo.getCsar() != null) {
2260                         String vendorLicenseModelId = null;
2261                         String vfLicenseModelId = null;
2262
2263                         if (artifactOperation.isUpdate()) {
2264                                 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
2265                                 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
2266                                         for (Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
2267                                                 if (artifactEntry.getValue()
2268                                                                 .getArtifactName()
2269                                                                 .equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
2270                                                         vendorLicenseModelId = artifactEntry.getValue()
2271                                                                         .getUniqueId();
2272                                                 }
2273                                                 if (artifactEntry.getValue()
2274                                                                 .getArtifactName()
2275                                                                 .equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
2276                                                         vfLicenseModelId = artifactEntry.getValue()
2277                                                                         .getUniqueId();
2278                                                 }
2279                                         }
2280                                 }
2281
2282                         }
2283                         // Specific Behavior for license artifacts
2284                         createOrUpdateSingleNonMetaArtifact(resource, csarInfo,
2285                                         CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL, Constants.VENDOR_LICENSE_MODEL,
2286                                         ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
2287                                         Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME,
2288                                         Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId, artifactOperation, null, true,
2289                                         shouldLock, inTransaction);
2290                         createOrUpdateSingleNonMetaArtifact(resource, csarInfo,
2291                                         CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
2292                                         ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
2293                                         Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId,
2294                                         artifactOperation, null, true, shouldLock, inTransaction);
2295
2296                         Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource,
2297                                         createdArtifacts, shouldLock, inTransaction, artifactOperation);
2298                         if (eitherCreateResult.isRight()) {
2299                                 return Either.right(eitherCreateResult.right()
2300                                                 .value());
2301                         }
2302
2303                         Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
2304                                         .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
2305
2306                         if (artifacsMetaCsarStatus.isLeft()) {
2307                                 String artifactsFileName = artifacsMetaCsarStatus.left()
2308                                                 .value()
2309                                                 .getKey();
2310                                 String artifactsContents = artifacsMetaCsarStatus.left()
2311                                                 .value()
2312                                                 .getValue();
2313                                 Either<Resource, ResponseFormat> createArtifactsFromCsar;
2314                                 if (artifactOperation.isCreateOrLink()) {
2315                                         createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(
2316                                                         csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
2317                                 } else {
2318                                         Either<Component, ResponseFormat> result  = csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(
2319                                                         csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
2320                                                         inTransaction);
2321                                         if ((result.left().value() instanceof Resource) && result.isLeft()) {
2322                                                 Resource service1 = (Resource) result.left().value();
2323                                                 createArtifactsFromCsar = Either.left(service1);
2324                                         } else {
2325                                                 createArtifactsFromCsar = Either.right(result.right().value());
2326                                         }
2327                                 }
2328
2329                                 if (createArtifactsFromCsar.isRight()) {
2330                                         log.debug("Couldn't create artifacts from artifacts.meta");
2331                                         return Either.right(createArtifactsFromCsar.right()
2332                                                         .value());
2333                                 }
2334
2335                                 return Either.left(createArtifactsFromCsar.left()
2336                                                 .value());
2337                         } else {
2338
2339                                 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock,
2340                                                 inTransaction);
2341
2342                         }
2343                 }
2344                 return Either.left(resource);
2345         }
2346
2347         private Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Resource resource, CsarInfo csarInfo,
2348                                                                                                                                                                 String artifactPath, String artifactFileName, String artifactType, ArtifactGroupTypeEnum artifactGroupType,
2349                                                                                                                                                                 String artifactLabel, String artifactDisplayName, String artifactDescription, String artifactId,
2350                                                                                                                                                                 ArtifactOperationInfo operation, List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
2351                                                                                                                                                                 boolean shouldLock, boolean inTransaction) {
2352                 byte[] artifactFileBytes = null;
2353
2354                 if (csarInfo.getCsar()
2355                                 .containsKey(artifactPath)) {
2356                         artifactFileBytes = csarInfo.getCsar()
2357                                         .get(artifactPath);
2358                 }
2359                 Either<Boolean, ResponseFormat> result = Either.left(true);
2360                 if (operation.isUpdate() || operation.isDelete()) {
2361                         if (isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
2362                                 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
2363                                                 .handleDelete(resource.getUniqueId(), artifactId, csarInfo.getModifier(),
2364                                                         resource, shouldLock,
2365                                                                 inTransaction);
2366                                 if (handleDelete.isRight()) {
2367                                         result = Either.right(handleDelete.right()
2368                                                         .value());
2369                                 } else {
2370                                         ArtifactDefinition value = handleDelete.left().value();
2371                                         String updatedArtifactId = value.getUniqueId();
2372                                         if (artifactGroupType == ArtifactGroupTypeEnum.DEPLOYMENT) {
2373                                                 resource.getDeploymentArtifacts().remove(updatedArtifactId);
2374                                         } else {
2375                                                 resource.getArtifacts().remove(updatedArtifactId);
2376                                         }
2377                                 }
2378                                 return result;
2379                         }
2380
2381                         if (StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
2382                                 operation = new ArtifactOperationInfo(false, false,
2383                                                 ArtifactOperationEnum.CREATE);
2384                         }
2385
2386                 }
2387                 if (artifactFileBytes != null) {
2388                         Map<String, Object> vendorLicenseModelJson = ArtifactUtils.buildJsonForUpdateArtifact(artifactId,
2389                                         artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
2390                                         artifactDescription, artifactFileBytes, null, isFromCsar);
2391                         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
2392                                         .createOrUpdateCsarArtifactFromJson(resource, csarInfo.getModifier(), vendorLicenseModelJson,
2393                                                         operation);
2394                         addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
2395                         if (eitherNonMetaArtifacts.isRight()) {
2396                                 BeEcompErrorManager.getInstance()
2397                                                 .logInternalFlowError("UploadLicenseArtifact", "Failed to upload license artifact: "
2398                                                                                 + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
2399                                                                 ErrorSeverity.WARNING);
2400                                 return Either.right(eitherNonMetaArtifacts.right()
2401                                                 .value());
2402                         }
2403                         ArtifactDefinition artifactDefinition = eitherNonMetaArtifacts.left().value().left().value();
2404                         createOrUpdateResourceWithUpdatedArtifact(artifactDefinition,resource, artifactGroupType);
2405                 }
2406
2407                 return result;
2408         }
2409
2410         private void createOrUpdateResourceWithUpdatedArtifact(ArtifactDefinition artifact, Resource resource, ArtifactGroupTypeEnum groupTypeEnum) {
2411                 if (groupTypeEnum == ArtifactGroupTypeEnum.DEPLOYMENT) {
2412                         resource.getDeploymentArtifacts().put(artifact.getArtifactLabel(), artifact);
2413                 } else {
2414                         resource.getArtifacts().put(artifact.getArtifactLabel(), artifact);
2415                 }
2416         }
2417
2418         private boolean isArtifactDeletionRequired(String artifactId, byte[] artifactFileBytes, boolean isFromCsar) {
2419                 return !StringUtils.isEmpty(artifactId) && artifactFileBytes == null && isFromCsar;
2420         }
2421
2422         private void addNonMetaCreatedArtifactsToSupportRollback(ArtifactOperationInfo operation,
2423                                                                                                                          List<ArtifactDefinition> createdArtifacts,
2424                                                                                                                          Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts) {
2425                 if (operation.isCreateOrLink() && createdArtifacts != null
2426                                 && eitherNonMetaArtifacts.isLeft()) {
2427                         Either<ArtifactDefinition, Operation> eitherResult = eitherNonMetaArtifacts.left()
2428                                         .value();
2429                         if (eitherResult.isLeft()) {
2430                                 createdArtifacts.add(eitherResult.left()
2431                                                 .value());
2432                         }
2433                 }
2434         }
2435
2436         private Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
2437                                                                                                                                                         List<ArtifactDefinition> createdArtifacts, boolean shouldLock, boolean inTransaction,
2438                                                                                                                                                         ArtifactOperationInfo artifactOperation) {
2439
2440                 Either<Resource, ResponseFormat> resStatus = null;
2441                 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
2442
2443                 try {
2444                         Either<List<NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo,
2445                                         collectedWarningMessages);
2446                         if (artifactPathAndNameList.isRight()) {
2447                                 return Either.right(getComponentsUtils().getResponseFormatByArtifactId(
2448                                                 ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right()
2449                                                                 .value()));
2450                         }
2451                         EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
2452
2453                         if (artifactOperation.isCreateOrLink()) {
2454                                 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
2455                                 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left()
2456                                                 .value());
2457                         } else {
2458                                 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
2459                                                 resource, artifactPathAndNameList.left()
2460                                                                 .value(),
2461                                                 csarInfo.getModifier());
2462
2463                                 if (findVfCsarArtifactsToHandleRes.isRight()) {
2464                                         resStatus = Either.right(findVfCsarArtifactsToHandleRes.right()
2465                                                         .value());
2466                                 }
2467                                 if (resStatus == null) {
2468                                         vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left()
2469                                                         .value();
2470                                 }
2471                         }
2472                         if (resStatus == null && vfCsarArtifactsToHandle != null) {
2473                                 resStatus = processCsarArtifacts(csarInfo, resource, createdArtifacts, shouldLock, inTransaction,
2474                                                 resStatus, vfCsarArtifactsToHandle);
2475                         }
2476                         if (resStatus == null) {
2477                                 resStatus = Either.left(resource);
2478                         }
2479                 } catch (Exception e) {
2480                         resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2481                         log.debug("Exception occurred in createNonMetaArtifacts, message:{}", e.getMessage(), e);
2482                 } finally {
2483                         CsarUtils.handleWarningMessages(collectedWarningMessages);
2484                 }
2485                 return resStatus;
2486         }
2487
2488         private Either<Resource, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Resource resource,
2489                                                                                                                                   List<ArtifactDefinition> createdArtifacts, boolean shouldLock, boolean inTransaction,
2490                                                                                                                                   Either<Resource, ResponseFormat> resStatus,
2491                                                                                                                                   EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
2492                 for (Entry<ArtifactOperationEnum, List<NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
2493                                 .entrySet()) {
2494
2495                         Optional<ResponseFormat> optionalCreateInDBError =
2496                                         // Stream of artifacts to be created
2497                                         currArtifactOperationPair.getValue()
2498                                                         .stream()
2499                                                         // create each artifact
2500                                                         .map(e -> createOrUpdateSingleNonMetaArtifact(resource, csarInfo, e.getPath(),
2501                                                                         e.getArtifactName(), e.getArtifactType(),
2502                                                                         e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(),
2503                                                                         CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
2504                                                                         new ArtifactOperationInfo(false, false,
2505                                                                                         currArtifactOperationPair.getKey()),
2506                                                                         createdArtifacts, e.isFromCsar(), shouldLock, inTransaction))
2507                                                         // filter in only error
2508                                                         .filter(Either::isRight)
2509                                                         .
2510                                                         // Convert the error from either to
2511                                                         // ResponseFormat
2512                                                                         map(e -> e.right()
2513                                                                         .value())
2514                                                         .
2515                                                         // Check if an error occurred
2516                                                                         findAny();
2517                         // Error found on artifact Creation
2518                         if (optionalCreateInDBError.isPresent()) {
2519                                 resStatus = Either.right(optionalCreateInDBError.get());
2520                                 break;
2521                         }
2522                 }
2523                 return resStatus;
2524         }
2525
2526         private Either<List<NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
2527                                                                                                                                                         Map<String, Set<List<String>>> collectedWarningMessages) {
2528                 List<NonMetaArtifactInfo> artifactPathAndNameList =
2529                                 // Stream of file paths contained in csar
2530                                 csarInfo.getCsar()
2531                                                 .entrySet()
2532                                                 .stream()
2533                                                 // Filter in only VF artifact path location
2534                                                 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN)
2535                                                                 .matcher(e.getKey())
2536                                                                 .matches())
2537                                                 // Validate and add warnings
2538                                                 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages))
2539                                                 // Filter in Non Warnings
2540                                                 .filter(Either::isLeft)
2541                                                 // Convert from Either to NonMetaArtifactInfo
2542                                                 .map(e -> e.left()
2543                                                                 .value())
2544                                                 // collect to List
2545                                                 .collect(toList());
2546                 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
2547                 for (NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
2548                         if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName())
2549                                         .matches()) {
2550                                 return Either.right(nonMetaArtifactInfo.getArtifactName());
2551                         }
2552                 }
2553                 return Either.left(artifactPathAndNameList);
2554         }
2555
2556         private Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
2557                         Resource resource, List<NonMetaArtifactInfo> artifactPathAndNameList, User user) {
2558
2559                 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
2560                 // collect all Deployment and Informational artifacts of VF
2561                 if (resource.getDeploymentArtifacts() != null && !resource.getDeploymentArtifacts()
2562                                 .isEmpty()) {
2563                         existingArtifacts.addAll(resource.getDeploymentArtifacts()
2564                                         .values());
2565                 }
2566                 if (resource.getArtifacts() != null && !resource.getArtifacts()
2567                                 .isEmpty()) {
2568                         existingArtifacts.addAll(resource.getArtifacts()
2569                                         .values());
2570                 }
2571                 existingArtifacts = existingArtifacts.stream()
2572                                 // filter MANDATORY artifacts, LICENSE artifacts and artifacts
2573                                 // was created from HEAT.meta
2574                                 .filter(this::isNonMetaArtifact)
2575                                 .collect(toList());
2576
2577                 List<String> artifactsToIgnore = new ArrayList<>();
2578                 // collect IDs of Artifacts of VF which belongs to any group
2579                 if (resource.getGroups() != null) {
2580                         resource.getGroups()
2581                                         .stream()
2582                                         .forEach(g -> {
2583                                                 if (g.getArtifacts() != null && !g.getArtifacts()
2584                                                                 .isEmpty()) {
2585                                                         artifactsToIgnore.addAll(g.getArtifacts());
2586                                                 }
2587                                         });
2588                 }
2589                 existingArtifacts = existingArtifacts.stream()
2590                                 // filter artifacts which belongs to any group
2591                                 .filter(a -> !artifactsToIgnore.contains(a.getUniqueId()))
2592                                 .collect(toList());
2593                 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, resource, user);
2594         }
2595
2596         private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
2597                 boolean result = true;
2598                 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
2599                         result = false;
2600                 }
2601                 return result;
2602         }
2603
2604         private boolean isValidArtifactType(ArtifactDefinition artifact) {
2605                 boolean result = true;
2606                 if (artifact.getArtifactType() == null
2607                                 || ArtifactTypeEnum.parse(artifact.getArtifactType()) == ArtifactTypeEnum.VENDOR_LICENSE
2608                                 || ArtifactTypeEnum.parse(artifact.getArtifactType()) == ArtifactTypeEnum.VF_LICENSE) {
2609                         result = false;
2610                 }
2611                 return result;
2612         }
2613
2614         private Resource createResourceInstancesRelations(User user, String yamlName, Resource resource, Resource oldResource,
2615                                                                                                           Map<String, UploadComponentInstanceInfo> uploadResInstancesMap, Map<String, Resource> existingNodeTypesByResourceNames) {
2616                 log.debug("#createResourceInstancesRelations - Going to create relations ");
2617                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.STARTED,"Start to create relations");
2618                 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
2619                 if (isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)  &&
2620                 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances {
2621                         log.debug(
2622                                         "#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
2623                                         resource.getUniqueId(), yamlName);
2624                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.ERROR,"No instances found in the resource: {}, is empty, yaml template file name: {}",resource.getName(),yamlName);
2625                         BeEcompErrorManager.getInstance()
2626                                 .logInternalDataError("createResourceInstancesRelations",
2627                                         "No instances found in a resource or nn yaml template. ", ErrorSeverity.ERROR);
2628                         throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2629                 }
2630                 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
2631                 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
2632                 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
2633                 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
2634                 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
2635         Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
2636                 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2637                 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
2638
2639                 log.debug("#createResourceInstancesRelations - Before get all datatypes. ");
2640                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
2641                 if (allDataTypes.isRight()) {
2642                         JanusGraphOperationStatus status = allDataTypes.right()
2643                                 .value();
2644                         BeEcompErrorManager.getInstance()
2645                                 .logInternalFlowError("UpdatePropertyValueOnComponentInstance",
2646                                                         "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR);
2647                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2648                                         StatusCode.ERROR,"ERROR while update property value on instance. Status is: "+status);
2649                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2650                                         DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)), yamlName);
2651
2652                 }
2653                 Resource finalResource = resource;
2654                 uploadResInstancesMap.values()
2655                                 .forEach(i -> processComponentInstance(yamlName, finalResource, componentInstancesList, allDataTypes,
2656                                                 instProperties, instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts,
2657                                                 instAttributes, existingNodeTypesByResourceNames, instInputs, i));
2658                 resource.getComponentInstances()
2659                                 .stream()
2660                                 .filter(i -> !i.isCreatedFromCsar())
2661                         .forEach(i -> processUiComponentInstance(oldResource, i, instCapabilities, instRequirements,
2662                                 instDeploymentArtifacts, instArtifacts, instProperties, instInputs, instAttributes));
2663
2664                 associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
2665                 associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
2666                 associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
2667                 associateArtifactsToInstances(yamlName, resource, instArtifacts);
2668                 associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
2669                 associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
2670                 addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
2671                 associateResourceInstances(yamlName, resource, relations);
2672                 handleSubstitutionMappings(resource, uploadResInstancesMap);
2673                 log.debug("************* in create relations, getResource start");
2674                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.COMPLETE,"create relations");
2675                 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2676                                 .getToscaFullElement(resource.getUniqueId());
2677                 log.debug("************* in create relations, getResource end");
2678                 if (eitherGetResource.isRight()) {
2679                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2680                                         StatusCode.ERROR,"ERROR while create relations");
2681                         throw new ByResponseFormatComponentException(componentsUtils
2682                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right()
2683                                                         .value()), resource));
2684                 }
2685                 return eitherGetResource.left()
2686                                 .value();
2687         }
2688
2689         private void processUiComponentInstance(Resource oldResource, ComponentInstance instance,
2690                                                                                         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities,
2691                                                                                         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
2692                                                                                         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
2693                                                                                         Map<String, Map<String, ArtifactDefinition>> instArtifacts, Map<String,
2694                                                                                         List<ComponentInstanceProperty>> instProperties, Map<String,
2695                                                                                         List<ComponentInstanceInput>> instInputs,
2696                                                                                         Map<String, List<AttributeDefinition>> instAttributes) {
2697                 Optional<ComponentInstance> foundInstance = findInstance(oldResource, instance);
2698                 if (foundInstance.isPresent()) {
2699                         if (MapUtils.isNotEmpty(foundInstance.get().getCapabilities())) {
2700                                 instCapabilities.put(instance, foundInstance.get().getCapabilities());
2701                         }
2702                         if (MapUtils.isNotEmpty(foundInstance.get().getRequirements())) {
2703                                 instRequirements.put(instance, foundInstance.get().getRequirements());
2704                         }
2705                         if (MapUtils.isNotEmpty(foundInstance.get().getDeploymentArtifacts())) {
2706                                 instDeploymentArtifacts.put(instance.getUniqueId(), foundInstance.get().getDeploymentArtifacts());
2707                         }
2708                         if(MapUtils.isNotEmpty(foundInstance.get().getArtifacts())){
2709                                 instArtifacts.put(instance.getUniqueId(), foundInstance.get().getArtifacts());
2710                         }
2711                         if (MapUtils.isNotEmpty(oldResource.getComponentInstancesProperties()) &&
2712                                 CollectionUtils
2713                                         .isNotEmpty(oldResource.getComponentInstancesProperties().get(foundInstance.get().getUniqueId()))) {
2714                                 instProperties.put(instance.getUniqueId(),
2715                                         oldResource.getComponentInstancesProperties().get(foundInstance.get().getUniqueId()));
2716                         }
2717                         if (MapUtils.isNotEmpty(oldResource.getComponentInstancesInputs()) &&
2718                                 CollectionUtils
2719                                         .isNotEmpty(oldResource.getComponentInstancesInputs().get(foundInstance.get().getUniqueId()))) {
2720                                 instInputs.put(instance.getUniqueId(),
2721                                         oldResource.getComponentInstancesInputs().get(foundInstance.get().getUniqueId()));
2722                         }
2723                         if(MapUtils.isNotEmpty(oldResource.getComponentInstancesAttributes()) &&
2724                                         CollectionUtils.isNotEmpty(oldResource.getComponentInstancesAttributes().get(foundInstance.get().getUniqueId()))){
2725                                 instAttributes.put(instance.getUniqueId(), oldResource.getComponentInstancesAttributes().get(foundInstance.get().getUniqueId()).stream().map(AttributeDefinition::new).collect(toList()));
2726                         }
2727                 }
2728         }
2729
2730         private Optional<ComponentInstance> findInstance(Resource oldResource, ComponentInstance instance) {
2731                 if(oldResource != null && CollectionUtils.isNotEmpty(oldResource.getComponentInstances())) {
2732                         return oldResource.getComponentInstances().stream().filter(i -> i.getName().equals(instance.getName())).findFirst();
2733                 }
2734                 return Optional.empty();
2735         }
2736
2737         private void associateResourceInstances(String yamlName, Resource resource,
2738                                                                                         List<RequirementCapabilityRelDef> relations) {
2739                 Either<List<RequirementCapabilityRelDef>, StorageOperationStatus> relationsEither = toscaOperationFacade.associateResourceInstances(resource, resource.getUniqueId(), relations);
2740
2741                 if (relationsEither.isRight() && relationsEither.right().value() != StorageOperationStatus.NOT_FOUND) {
2742                         StorageOperationStatus status = relationsEither.right().value();
2743                         log.debug("failed to associate instances of resource {} status is {}", resource.getUniqueId(),
2744                                         status);
2745                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status), yamlName);
2746                 } else {
2747                         setResourceInstanceRelationsOnComponent(resource, relationsEither.left().value());
2748                 }
2749         }
2750
2751         private void associateInstAttributeToComponentToInstances(String yamlName, Resource resource,
2752                                                                                                                           Map<String, List<AttributeDefinition>> instAttributes) {
2753                 StorageOperationStatus addArtToInst;
2754                 addArtToInst = toscaOperationFacade.associateInstAttributeToComponentToInstances(instAttributes,
2755                         resource);
2756                 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2757                         log.debug("failed to associate attributes of resource {} status is {}", resource.getUniqueId(),
2758                                 addArtToInst);
2759                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst),
2760                                 yamlName);
2761                 }
2762         }
2763
2764         private void associateOrAddCalculatedCapReq(String yamlName, Resource resource,
2765                                                                                                 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities,
2766                                                                                                 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements) {
2767                 StorageOperationStatus addArtToInst;
2768                 addArtToInst = toscaOperationFacade.associateOrAddCalculatedCapReq(instCapabilities, instRequirements,
2769                                 resource);
2770                 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2771                         log.debug("failed to associate cap and req of resource {} status is {}", resource.getUniqueId(),
2772                                         addArtToInst);
2773                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2774                 }
2775         }
2776
2777         private void associateArtifactsToInstances(String yamlName, Resource resource,
2778                                                                                            Map<String, Map<String, ArtifactDefinition>> instArtifacts) {
2779                 StorageOperationStatus addArtToInst;
2780
2781                 addArtToInst = toscaOperationFacade.associateArtifactsToInstances(instArtifacts, resource);
2782                 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2783                         log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst);
2784                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2785                 }
2786         }
2787
2788         private void associateDeploymentArtifactsToInstances(User user, String yamlName, Resource resource,
2789                                                                                                                  Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts) {
2790                 StorageOperationStatus addArtToInst = toscaOperationFacade
2791                                 .associateDeploymentArtifactsToInstances(instDeploymentArtifacts, resource, user);
2792                 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2793                         log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst);
2794                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2795                 }
2796         }
2797
2798         private void associateComponentInstanceInputsToComponent(String yamlName, Resource resource,
2799                                                                                                                          Map<String, List<ComponentInstanceInput>> instInputs) {
2800                 if (MapUtils.isNotEmpty(instInputs)) {
2801                         Either<Map<String, List<ComponentInstanceInput>>, StorageOperationStatus> addInputToInst = toscaOperationFacade
2802                                         .associateComponentInstanceInputsToComponent(instInputs, resource.getUniqueId());
2803                         if (addInputToInst.isRight()) {
2804
2805                                 StorageOperationStatus addInputToInstError = addInputToInst.right().value();
2806                                 log.debug("failed to associate inputs value of resource {} status is {}", resource.getUniqueId(),
2807                                                 addInputToInstError);
2808                                 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addInputToInstError), yamlName);
2809                         }
2810                         setComponentInstanceInputsOnComponent(resource, instInputs);
2811                 }
2812         }
2813
2814         private void setComponentInstanceInputsOnComponent(Resource resource, Map<String, List<ComponentInstanceInput>> instInputs) {
2815                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = resource.getComponentInstancesInputs();
2816                 if (componentInstancesInputs == null)
2817                         componentInstancesInputs = new HashMap<>();
2818                 componentInstancesInputs.putAll(instInputs);
2819                 resource.setComponentInstancesInputs(componentInstancesInputs);
2820         }
2821
2822         private void associateComponentInstancePropertiesToComponent(String yamlName, Resource resource,
2823                                                                                                                                  Map<String, List<ComponentInstanceProperty>> instProperties) {
2824                 Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> addPropToInst = toscaOperationFacade
2825                                 .associateComponentInstancePropertiesToComponent(instProperties, resource.getUniqueId());
2826                 if (addPropToInst.isRight()) {
2827                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2828                                         StatusCode.ERROR,"ERROR while  associate compnent insatnce properties of resource: {} status is: {}",resource.getName(),addPropToInst.right().value());
2829                         StorageOperationStatus storageOperationStatus = addPropToInst.right().value();
2830                         log.debug("failed to associate properties of resource {} status is {}", resource.getUniqueId(),
2831                                         storageOperationStatus);
2832                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageOperationStatus), yamlName);
2833                 }
2834                 setComponentInstancePropertiesOnComponent(resource, instProperties);
2835         }
2836
2837         private void setComponentInstancePropertiesOnComponent(Resource resource, Map<String, List<ComponentInstanceProperty>> instProperties) {
2838                 Map<String, List<ComponentInstanceProperty>> componentInstanceProps = resource.getComponentInstancesProperties();
2839                 if (componentInstanceProps == null )
2840                         componentInstanceProps = new HashMap<>();
2841                 componentInstanceProps.putAll(instProperties);
2842                 resource.setComponentInstancesProperties(componentInstanceProps);
2843         }
2844
2845         private void handleSubstitutionMappings(Resource resource,
2846                                                                                         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2847                 if (resource.getResourceType() == ResourceTypeEnum.CVFC) {
2848                         Either<Resource, StorageOperationStatus> getResourceRes =
2849                                         updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap);
2850                         if (getResourceRes.isRight()) {
2851                                 ResponseFormat responseFormat = componentsUtils
2852                                                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right()
2853                                                                 .value()), resource);
2854                                 throw new ByResponseFormatComponentException(responseFormat);
2855                         }
2856                 }
2857         }
2858
2859         private void addRelationsToRI(String yamlName, Resource resource,
2860                                                                   Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2861                                                                   List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2862                 for (Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2863                         UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2864                         ComponentInstance currentCompInstance = null;
2865                         for (ComponentInstance compInstance : componentInstancesList) {
2866
2867                                 if (compInstance.getName()
2868                                                 .equals(uploadComponentInstanceInfo.getName())) {
2869                                         currentCompInstance = compInstance;
2870                                         break;
2871                                 }
2872
2873                         }
2874                         if (currentCompInstance == null) {
2875                                 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(),
2876                                                 resource.getUniqueId());
2877                                 BeEcompErrorManager.getInstance()
2878                                                 .logInternalDataError(
2879                                                                 COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE,
2880                                                                 resource.getUniqueId(), ErrorSeverity.ERROR);
2881                                 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2882                         }
2883
2884                         ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, resource, entry.getValue(), relations);
2885                         if (addRelationToRiRes.getStatus() != 200) {
2886                                 throw new ByResponseFormatComponentException(addRelationToRiRes);
2887                         }
2888                 }
2889
2890         }
2891
2892         private void setResourceInstanceRelationsOnComponent(Resource resource, List<RequirementCapabilityRelDef> relations) {
2893                 if (resource.getComponentInstancesRelations() != null) {
2894                         resource.getComponentInstancesRelations().addAll(relations);
2895                 } else {
2896                         resource.setComponentInstancesRelations(relations);
2897                 }
2898         }
2899
2900         private void processComponentInstance(String yamlName, Resource resource,
2901                                                                                   List<ComponentInstance> componentInstancesList,
2902                                                                                   Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
2903                                                                                   Map<String, List<ComponentInstanceProperty>> instProperties,
2904                                                                                   Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2905                                                                                   Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
2906                                                                                   Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
2907                                                                                   Map<String, Map<String, ArtifactDefinition>> instArtifacts,
2908                                                                                   Map<String, List<AttributeDefinition>> instAttributes,
2909                                                                                   Map<String, Resource> originCompMap,
2910                                                                                   Map<String, List<ComponentInstanceInput>> instInputs,
2911                                                                                   UploadComponentInstanceInfo uploadComponentInstanceInfo) {
2912                 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
2913                                 .filter(i -> i.getName()
2914                                                 .equals(uploadComponentInstanceInfo.getName()))
2915                                 .findFirst();
2916                 if (!currentCompInstanceOpt.isPresent()) {
2917                         log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(),
2918                                         resource.getUniqueId());
2919                         BeEcompErrorManager.getInstance()
2920                                         .logInternalDataError(
2921                                                         COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE,
2922                                                         resource.getUniqueId(), ErrorSeverity.ERROR);
2923                         throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2924                 }
2925                 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
2926                 String resourceInstanceId = currentCompInstance.getUniqueId();
2927                 Resource originResource = getOriginResource(originCompMap, currentCompInstance);
2928                 if (isNotEmpty(originResource.getRequirements())) {
2929                         instRequirements.put(currentCompInstance, originResource.getRequirements());
2930                 }
2931                 if (isNotEmpty(originResource.getCapabilities())) {
2932                         processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
2933                                 currentCompInstance, originResource);
2934                 }
2935                 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts()
2936                         .isEmpty()) {
2937                         instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
2938                 }
2939                 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
2940                         instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
2941                 }
2942                 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
2943                         instAttributes.put(resourceInstanceId, originResource.getAttributes());
2944                 }
2945                 if (originResource.getResourceType() != ResourceTypeEnum.CVFC) {
2946                         ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, resource,
2947                                 originResource, currentCompInstance, instProperties, allDataTypes.left()
2948                                         .value());
2949                         if (addPropertiesValueToRiRes.getStatus() != 200) {
2950                                 throw new ByResponseFormatComponentException(addPropertiesValueToRiRes);
2951                         }
2952                 } else {
2953                         addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance, instInputs,
2954                                         allDataTypes.left()
2955                                                         .value());
2956                 }
2957         }
2958
2959         private Resource getOriginResource(Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2960                 Resource originResource;
2961                 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2962                         Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2963                                         .getToscaFullElement(currentCompInstance.getComponentUid());
2964                         if (getOriginResourceRes.isRight()) {
2965                                 log.debug("failed to fetch resource with uniqueId {} and tosca component name {} status is {}",
2966                                                 currentCompInstance.getComponentUid(), currentCompInstance.getToscaComponentName(),
2967                                                 getOriginResourceRes);
2968                                 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right()
2969                                                 .value()), currentCompInstance.getComponentUid());
2970                         }
2971                         originResource = getOriginResourceRes.left()
2972                                         .value();
2973                         originCompMap.put(originResource.getUniqueId(), originResource);
2974                 } else {
2975                         originResource = originCompMap.get(currentCompInstance.getComponentUid());
2976                 }
2977                 return originResource;
2978         }
2979
2980         private void processComponentInstanceCapabilities(
2981                         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
2982                         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2983                         UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance,
2984                         Resource originResource) {
2985                 Map<String, List<CapabilityDefinition>> originCapabilities;
2986                 if (isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2987                         originCapabilities = new HashMap<>();
2988                         Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2989                         originResource.getCapabilities()
2990                                         .forEach((k, v) -> addCapabilities(originCapabilities, k, v));
2991                         uploadComponentInstanceInfo.getCapabilities()
2992                                         .values()
2993                                         .forEach(l -> addCapabilitiesProperties(newPropertiesMap, l));
2994                         updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2995                 } else {
2996                         originCapabilities = originResource.getCapabilities();
2997                 }
2998                 instCapabilties.put(currentCompInstance, originCapabilities);
2999         }
3000
3001         private void updateCapabilityPropertiesValues(
3002                         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
3003                         Map<String, List<CapabilityDefinition>> originCapabilities,
3004                         Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
3005                 originCapabilities.values()
3006                                 .stream()
3007                                 .flatMap(Collection::stream)
3008                                 .filter(c -> newPropertiesMap.containsKey(c.getName()))
3009                                 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()),
3010                                                 allDataTypes.left()
3011                                                                 .value()));
3012         }
3013
3014         private void addCapabilitiesProperties(Map<String, Map<String, UploadPropInfo>> newPropertiesMap,
3015                                                                                    List<UploadCapInfo> capabilities) {
3016                 for (UploadCapInfo capability : capabilities) {
3017                         if (isNotEmpty(capability.getProperties())) {
3018                                 newPropertiesMap.put(capability.getName(), capability.getProperties()
3019                                                 .stream()
3020                                                 .collect(toMap(UploadInfo::getName, p -> p)));
3021                         }
3022                 }
3023         }
3024
3025         private void addCapabilities(Map<String, List<CapabilityDefinition>> originCapabilities, String type,
3026                                                                  List<CapabilityDefinition> capabilities) {
3027                 List<CapabilityDefinition> list = capabilities.stream()
3028                                 .map(CapabilityDefinition::new)
3029                                 .collect(toList());
3030                 originCapabilities.put(type, list);
3031         }
3032
3033         private void updatePropertyValues(List<ComponentInstanceProperty> properties,
3034                                                                           Map<String, UploadPropInfo> newProperties, Map<String, DataTypeDefinition> allDataTypes) {
3035                 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
3036         }
3037
3038         private String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
3039                                                                            Map<String, DataTypeDefinition> allDataTypes) {
3040                 String value = null;
3041                 List<GetInputValueDataDefinition> getInputs = null;
3042                 boolean isValidate = true;
3043                 if (null != propertyInfo && propertyInfo.getValue() != null) {
3044                         getInputs = propertyInfo.getGet_input();
3045                         isValidate = getInputs == null || getInputs.isEmpty();
3046                         if (isValidate) {
3047                                 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
3048                         } else {
3049                                 value = getPropertyJsonStringValue(propertyInfo.getValue(),
3050                                                 TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3051                         }
3052                 }
3053                 property.setValue(value);
3054         return validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3055         }
3056
3057         private Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
3058                                                                                                                                                                                                         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
3059                 Either<Resource, StorageOperationStatus> updateRes = null;
3060                 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
3061                 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
3062                 StorageOperationStatus status = toscaOperationFacade
3063                                 .deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
3064                 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
3065                         log.debug(
3066                                         "Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
3067                                         resource.getUniqueId(), status);
3068                         updateRes = Either.right(status);
3069                 }
3070                 if (updateRes == null) {
3071                         fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap,
3072                                         updatedInstCapabilities, updatedInstRequirements);
3073                         status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities,
3074                                         updatedInstRequirements, resource);
3075                         if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
3076                                 log.debug(
3077                                                 "Failed to associate capabilities and requirementss of resource {}, updated according to a substitution mapping. Status is {}",
3078                                                 resource.getUniqueId(), status);
3079                                 updateRes = Either.right(status);
3080                         }
3081                 }
3082                 if (updateRes == null) {
3083                         updateRes = Either.left(resource);
3084                 }
3085                 return updateRes;
3086         }
3087
3088         private void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
3089                                                                                                                  Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
3090                                                                                                                  Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
3091                                                                                                                  Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
3092
3093                 componentInstances.stream()
3094                                 .forEach(i -> {
3095                                         fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName())
3096                                                         .getCapabilitiesNamesToUpdate());
3097                                         fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName())
3098                                                         .getRequirementsNamesToUpdate());
3099                                 });
3100         }
3101
3102         private void fillUpdatedInstRequirements(
3103                         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
3104                         ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
3105                 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
3106                 Set<String> updatedReqNames = new HashSet<>();
3107                 if (isNotEmpty(requirementsNamesToUpdate)) {
3108                         for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements()
3109                                         .entrySet()) {
3110                                 updatedRequirements.put(requirements.getKey(), requirements.getValue()
3111                                                 .stream()
3112                                                 .filter(r -> requirementsNamesToUpdate.containsKey(r.getName())
3113                                                                 && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
3114                                                 .map(r -> {
3115                                                         r.setParentName(r.getName());
3116                                                         r.setName(requirementsNamesToUpdate.get(r.getName()));
3117                                                         updatedReqNames.add(r.getName());
3118                                                         return r;
3119                                                 })
3120                                                 .collect(toList()));
3121                         }
3122                 }
3123                 if (isNotEmpty(updatedRequirements)) {
3124                         updatedInstRequirements.put(instance, updatedRequirements);
3125                 }
3126         }
3127
3128         private void fillUpdatedInstCapabilities(
3129                         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
3130                         ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
3131                 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
3132                 Set<String> updatedCapNames = new HashSet<>();
3133                 if (isNotEmpty(capabilitiesNamesToUpdate)) {
3134                         for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities()
3135                                         .entrySet()) {
3136                                 updatedCapabilities.put(requirements.getKey(), requirements.getValue()
3137                                                 .stream()
3138                                                 .filter(c -> capabilitiesNamesToUpdate.containsKey(c.getName())
3139                                                                 && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
3140                                                 .map(c -> {
3141                                                         c.setParentName(c.getName());
3142                                                         c.setName(capabilitiesNamesToUpdate.get(c.getName()));
3143                                                         updatedCapNames.add(c.getName());
3144                                                         return c;
3145                                                 })
3146                                                 .collect(toList()));
3147                         }
3148                 }
3149                 if (isNotEmpty(updatedCapabilities)) {
3150                         updatedInstCapabilties.put(instance, updatedCapabilities);
3151                 }
3152         }
3153
3154         private ResponseFormat addRelationToRI(String yamlName, Resource resource,
3155                                                                                    UploadComponentInstanceInfo nodesInfoValue, List<RequirementCapabilityRelDef> relations) {
3156                 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
3157
3158                 ComponentInstance currentCompInstance = null;
3159
3160                 for (ComponentInstance compInstance : componentInstancesList) {
3161
3162                         if (compInstance.getName()
3163                                         .equals(nodesInfoValue.getName())) {
3164                                 currentCompInstance = compInstance;
3165                                 break;
3166                         }
3167
3168                 }
3169
3170                 if (currentCompInstance == null) {
3171                         log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), resource.getUniqueId());
3172                         BeEcompErrorManager.getInstance()
3173                                         .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE,
3174                                                         resource.getUniqueId(), ErrorSeverity.ERROR);
3175                         return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3176                 }
3177                 String resourceInstanceId = currentCompInstance.getUniqueId();
3178
3179                 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
3180
3181                 if (regMap != null) {
3182                         Iterator<Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet()
3183                                         .iterator();
3184
3185                         while (nodesRegValue.hasNext()) {
3186                                 Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
3187
3188                                 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
3189                                 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
3190                                         log.debug("Going to create  relation {}", uploadRegInfo.getName());
3191                                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.STARTED,"Started to create relations on instance: {}",uploadRegInfo.getName());
3192                                         String regName = uploadRegInfo.getName();
3193                                         RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
3194                                         regCapRelDef.setFromNode(resourceInstanceId);
3195                                         log.debug("try to find available requirement {} ", regName);
3196                                         Either<RequirementDefinition, ResponseFormat> eitherReqStatus = findAviableRequiremen(regName,
3197                                                         yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
3198                                         if (eitherReqStatus.isRight()) {
3199                                                 log.debug("failed to find available requirement {} status is {}", regName,
3200                                                                 eitherReqStatus.right()
3201                                                                                 .value());
3202                                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.ERROR,"ERROR while search available requirement {} status is: {}",regName,eitherReqStatus.right().value());
3203                                                 return eitherReqStatus.right()
3204                                                                 .value();
3205                                         }
3206
3207                                         RequirementDefinition validReq = eitherReqStatus.left()
3208                                                         .value();
3209                                         List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef
3210                                                         .getRelationships();
3211                                         if (reqAndRelationshipPairList == null) {
3212                                                 reqAndRelationshipPairList = new ArrayList<>();
3213                                         }
3214                                         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
3215                                         reqAndRelationshipPair.setRequirement(regName);
3216                                         reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
3217                                         reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
3218                                         RelationshipImpl relationship = new RelationshipImpl();
3219                                         relationship.setType(validReq.getCapability());
3220                                         reqAndRelationshipPair.setRelationships(relationship);
3221
3222                                         ComponentInstance currentCapCompInstance = null;
3223                                         for (ComponentInstance compInstance : componentInstancesList) {
3224                                                 if (compInstance.getName()
3225                                                                 .equals(uploadRegInfo.getNode())) {
3226                                                         currentCapCompInstance = compInstance;
3227                                                         break;
3228                                                 }
3229                                         }
3230
3231                                         if (currentCapCompInstance == null) {
3232                                                 log.debug("The component instance  with name {} not found on resource {} ",
3233                                                                 uploadRegInfo.getNode(), resource.getUniqueId());
3234                                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR component instance  with name: {} not found on resource: {}",uploadRegInfo.getNode(),resource.getUniqueId());
3235                                                 BeEcompErrorManager.getInstance()
3236                                                                 .logInternalDataError(
3237                                                                                 COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE,
3238                                                                                 resource.getUniqueId(), ErrorSeverity.ERROR);
3239                                                 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3240                                         }
3241                                         regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
3242                                         log.debug("try to find aviable Capability  req name is {} ", validReq.getName());
3243                                         CapabilityDefinition aviableCapForRel = findAvailableCapabilityByTypeOrName(validReq,
3244                                                         currentCapCompInstance, uploadRegInfo);
3245
3246                                         if (aviableCapForRel == null) {
3247                                                 log.debug("aviable capability was not found. req name is {} component instance is {}",
3248                                                                 validReq.getName(), currentCapCompInstance.getUniqueId());
3249                                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),     StatusCode.ERROR,"ERROR available capability was not found. req name is: {} component instance is: {}",validReq.getName(),currentCapCompInstance.getUniqueId());
3250                                                 BeEcompErrorManager.getInstance()
3251                                                                 .logInternalDataError(
3252                                                                                 "aviable capability was not found. req name is " + validReq.getName()
3253                                                                                                 + " component instance is " + currentCapCompInstance.getUniqueId(),
3254                                                                                 resource.getUniqueId(), ErrorSeverity.ERROR);
3255                                                 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3256                                         }
3257                                         reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
3258                                         reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
3259                                         reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
3260
3261                                         CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
3262                                         capReqRel.setRelation(reqAndRelationshipPair);
3263                                         reqAndRelationshipPairList.add(capReqRel);
3264                                         regCapRelDef.setRelationships(reqAndRelationshipPairList);
3265                                         relations.add(regCapRelDef);
3266                                 }
3267                         }
3268                 } else if (resource.getResourceType() != ResourceTypeEnum.CVFC) {
3269                         return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
3270                 }
3271                 return componentsUtils.getResponseFormat(ActionStatus.OK);
3272         }
3273
3274         private void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Resource resource,
3275                                                                          Resource originResource, ComponentInstance currentCompInstance,
3276                                                                          Map<String, List<ComponentInstanceInput>> instInputs, Map<String, DataTypeDefinition> allDataTypes) {
3277                 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
3278                 if (MapUtils.isNotEmpty(propMap)) {
3279                         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
3280                         List<ComponentInstanceInput> instPropList = new ArrayList<>();
3281
3282                         if (CollectionUtils.isEmpty(originResource.getInputs())) {
3283                                 log.debug("failed to find properties ");
3284                                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(),StatusCode.ERROR,"ERROR while try to find properties");
3285                                 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND);
3286                         }
3287                         originResource.getInputs()
3288                                         .forEach(p -> addInput(currPropertiesMap, p));
3289                         for (List<UploadPropInfo> propertyList : propMap.values()) {
3290                                 processProperty(resource, currentCompInstance, allDataTypes, currPropertiesMap, instPropList,
3291                                                 propertyList);
3292                         }
3293                         currPropertiesMap.values()
3294                                         .forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
3295                         instInputs.put(currentCompInstance.getUniqueId(), instPropList);
3296                 }
3297         }
3298
3299         private void processProperty(Resource resource, ComponentInstance currentCompInstance,
3300                                                                  Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
3301                                                                  List<ComponentInstanceInput> instPropList, List<UploadPropInfo> propertyList) {
3302                 UploadPropInfo propertyInfo = propertyList.get(0);
3303                 String propName = propertyInfo.getName();
3304                 if (!currPropertiesMap.containsKey(propName)) {
3305                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3306                                         StatusCode.ERROR,"ERROR failed to find property: {}",propName);
3307                         log.debug("failed to find property {} ", propName);
3308                         throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, propName);
3309                 }
3310                 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
3311                 ComponentInstanceInput property = null;
3312
3313                 String value = null;
3314                 List<GetInputValueDataDefinition> getInputs = null;
3315                 boolean isValidate = true;
3316                 if (propertyInfo.getValue() != null) {
3317                         getInputs = propertyInfo.getGet_input();
3318                         isValidate = getInputs == null || getInputs.isEmpty();
3319                         if (isValidate) {
3320                                 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
3321                         } else {
3322                                 value = getPropertyJsonStringValue(propertyInfo.getValue(),
3323                                                 TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3324                         }
3325                 }
3326                 property = new ComponentInstanceInput(curPropertyDef, value, null);
3327
3328         String validPropertyVAlue = validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3329
3330                 property.setValue(validPropertyVAlue);
3331
3332                 if (isNotEmpty(getInputs)) {
3333                         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
3334                         for (GetInputValueDataDefinition getInput : getInputs) {
3335                                 List<InputDefinition> inputs = resource.getInputs();
3336                                 if (CollectionUtils.isEmpty(inputs)) {
3337                                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3338                                                         StatusCode.ERROR,"ERROR Failed to add property: "+propName+" to resource instance: {}. Inputs list is empty ",currentCompInstance.getUniqueId());
3339                                         log.debug("Failed to add property {} to resource instance {}. Inputs list is empty ", property,
3340                                                         currentCompInstance.getUniqueId());
3341                                         throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3342                                 }
3343
3344                                 Optional<InputDefinition> optional = inputs.stream()
3345                                                 .filter(p -> p.getName()
3346                                                                 .equals(getInput.getInputName()))
3347                                                 .findAny();
3348                                 if (!optional.isPresent()) {
3349                                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3350                                                         StatusCode.ERROR,"ERROR Failed to find input: "+getInput.getInputName());
3351                                         log.debug("Failed to find input {} ", getInput.getInputName());
3352                                         // @@TODO error message
3353                                         throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3354                                 }
3355                                 InputDefinition input = optional.get();
3356                                 getInput.setInputId(input.getUniqueId());
3357                                 getInputValues.add(getInput);
3358
3359                                 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
3360                                 processGetInput(getInputValues, inputs, getInputIndex);
3361                         }
3362                         property.setGetInputValues(getInputValues);
3363                 }
3364                 instPropList.add(property);
3365                 // delete overriden property
3366                 currPropertiesMap.remove(property.getName());
3367         }
3368
3369         private void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
3370                                                                  GetInputValueDataDefinition getInputIndex) {
3371                 Optional<InputDefinition> optional;
3372                 if (getInputIndex != null) {
3373                         optional = inputs.stream()
3374                                         .filter(p -> p.getName()
3375                                                         .equals(getInputIndex.getInputName()))
3376                                         .findAny();
3377                         if (!optional.isPresent()) {
3378                                 log.debug("Failed to find input {} ", getInputIndex.getInputName());
3379                                 // @@TODO error message
3380                                 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3381                         }
3382                         InputDefinition inputIndex = optional.get();
3383                         getInputIndex.setInputId(inputIndex.getUniqueId());
3384                         getInputValues.add(getInputIndex);
3385                 }
3386         }
3387
3388         private void addInput(Map<String, InputDefinition> currPropertiesMap, InputDefinition prop) {
3389                 String propName = prop.getName();
3390                 if (!currPropertiesMap.containsKey(propName)) {
3391                         currPropertiesMap.put(propName, prop);
3392                 }
3393         }
3394
3395         private ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo,
3396                                                                                                  Resource resource, Resource originResource, ComponentInstance currentCompInstance,
3397                                                                                                  Map<String, List<ComponentInstanceProperty>> instProperties, Map<String, DataTypeDefinition> allDataTypes) {
3398
3399                 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
3400                 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
3401
3402                 List<PropertyDefinition> listFromMap = originResource.getProperties();
3403                 if ((propMap != null && !propMap.isEmpty()) && (listFromMap == null || listFromMap.isEmpty())) {
3404                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3405                                         StatusCode.ERROR,"ERROR Failed to find properties");
3406                         log.debug("failed to find properties");
3407                         return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
3408                 }
3409                 if (listFromMap == null || listFromMap.isEmpty()) {
3410                         return componentsUtils.getResponseFormat(ActionStatus.OK);
3411                 }
3412                 for (PropertyDefinition prop : listFromMap) {
3413                         String propName = prop.getName();
3414                         if (!currPropertiesMap.containsKey(propName)) {
3415                                 currPropertiesMap.put(propName, prop);
3416                         }
3417                 }
3418                 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
3419                 if (propMap != null && propMap.size() > 0) {
3420                         for (List<UploadPropInfo> propertyList : propMap.values()) {
3421
3422                                 UploadPropInfo propertyInfo = propertyList.get(0);
3423                                 String propName = propertyInfo.getName();
3424                                 if (!currPropertiesMap.containsKey(propName)) {
3425                                         log.debug("failed to find property {} ", propName);
3426                                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR Failed to find property: {}",propName);
3427                                         return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
3428                                 }
3429                                 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
3430                                 ComponentInstanceProperty property = null;
3431
3432                                 String value = null;
3433                                 List<GetInputValueDataDefinition> getInputs = null;
3434                                 boolean isValidate = true;
3435                                 if (propertyInfo.getValue() != null) {
3436                                     getInputs = propertyInfo.getGet_input();
3437                                     isValidate = getInputs == null || getInputs.isEmpty();
3438                                     if (isValidate) {
3439                                         value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
3440                                         } else {
3441                                             value = getPropertyJsonStringValue(propertyInfo.getValue(),
3442                                                             TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3443                                         }
3444                                     }
3445                                 property = new ComponentInstanceProperty(curPropertyDef, value, null);
3446
3447                 String validatePropValue = validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3448                 property.setValue(validatePropValue);
3449
3450                                 if (getInputs != null && !getInputs.isEmpty()) {
3451                                         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
3452                                         for (GetInputValueDataDefinition getInput : getInputs) {
3453                                                 List<InputDefinition> inputs = resource.getInputs();
3454                                                 if (inputs == null || inputs.isEmpty()) {
3455                                                         log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
3456                                                         loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"Failed to add property: {} to instance. Inputs list is empty",propName);
3457                                                         rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, property.getGetInputValues()
3458                                                                         .stream()
3459                                                                         .map(GetInputValueDataDefinition::getInputName)
3460                                                                         .collect(toList())
3461                                                                         .toString());
3462                                                 }
3463                                                 Either<InputDefinition, RuntimeException> inputEither = findInputByName(inputs, getInput);
3464                                                 if (inputEither.isRight()) {
3465                                                         throw inputEither.right().value();
3466                                                 } else {
3467                                                         InputDefinition input = inputEither.left().value();
3468                                                         getInput.setInputId(input.getUniqueId());
3469                                                         getInputValues.add(getInput);
3470
3471                                                         GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
3472                                                         if (getInputIndex != null) {
3473                                                                 Either<InputDefinition, RuntimeException> newInputEither = findInputByName(inputs,
3474                                                                         getInputIndex);
3475                                                                 if (inputEither.isRight()) {
3476                                                                         throw newInputEither.right().value();
3477                                                                 } else {
3478                                                                         InputDefinition newInput = newInputEither.left().value();
3479                                                                         getInputIndex.setInputId(newInput.getUniqueId());
3480                                                                 }
3481                                                                 getInputValues.add(getInputIndex);
3482
3483                                                         }
3484                                                 }
3485                                         }
3486                                         property.setGetInputValues(getInputValues);
3487                                 }
3488                                 instPropList.add(property);
3489                                 // delete overriden property
3490                                 currPropertiesMap.remove(property.getName());
3491                         }
3492                 }
3493                 // add rest of properties
3494                 if (!currPropertiesMap.isEmpty()) {
3495                         for (PropertyDefinition value : currPropertiesMap.values()) {
3496                                 instPropList.add(new ComponentInstanceProperty(value));
3497                         }
3498                 }
3499                 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
3500                 return componentsUtils.getResponseFormat(ActionStatus.OK);
3501         }
3502
3503         // US740820 Relate RIs according to capability name
3504         private CapabilityDefinition findAvailableCapabilityByTypeOrName(RequirementDefinition validReq,
3505                                                                                                                                          ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) {
3506                 if (null == uploadReqInfo.getCapabilityName() || validReq.getCapability()
3507                                 .equals(uploadReqInfo.getCapabilityName())) {// get
3508                         // by
3509                         // capability
3510                         // type
3511                         return findAvailableCapability(validReq, currentCapCompInstance);
3512                 }
3513                 return findAvailableCapability(validReq, currentCapCompInstance, uploadReqInfo);
3514         }
3515
3516         private CapabilityDefinition findAvailableCapability(RequirementDefinition validReq,
3517                                                                                                                  ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) {
3518                 CapabilityDefinition cap = null;
3519                 Map<String, List<CapabilityDefinition>> capMap = currentCapCompInstance.getCapabilities();
3520                 if (!capMap.containsKey(validReq.getCapability())) {
3521                         return null;
3522                 }
3523                 Optional<CapabilityDefinition> capByName = capMap.get(validReq.getCapability())
3524                                 .stream()
3525                                 .filter(p -> p.getName()
3526                                                 .equals(uploadReqInfo.getCapabilityName()))
3527                                 .findAny();
3528                 if (!capByName.isPresent()) {
3529                         return null;
3530                 }
3531                 cap = capByName.get();
3532
3533                 if (isBoundedByOccurrences(cap)) {
3534                         String leftOccurrences = cap.getLeftOccurrences();
3535                         int left = Integer.parseInt(leftOccurrences);
3536                         if (left > 0) {
3537                                 --left;
3538                                 cap.setLeftOccurrences(String.valueOf(left));
3539
3540                         }
3541
3542                 }
3543                 return cap;
3544         }
3545
3546         private CapabilityDefinition findAvailableCapability(RequirementDefinition validReq, ComponentInstance instance) {
3547                 Map<String, List<CapabilityDefinition>> capMap = instance.getCapabilities();
3548                 if (capMap.containsKey(validReq.getCapability())) {
3549                         List<CapabilityDefinition> capList = capMap.get(validReq.getCapability());
3550
3551                         for (CapabilityDefinition cap : capList) {
3552                                 if (isBoundedByOccurrences(cap)) {
3553                                         String leftOccurrences = cap.getLeftOccurrences() != null ? cap.getLeftOccurrences()
3554                                                         : cap.getMaxOccurrences();
3555                                         int left = Integer.parseInt(leftOccurrences);
3556                                         if (left > 0) {
3557                                                 --left;
3558                                                 cap.setLeftOccurrences(String.valueOf(left));
3559                                                 return cap;
3560                                         }
3561                                 } else {
3562                                         return cap;
3563                                 }
3564                         }
3565                 }
3566                 return null;
3567         }
3568
3569         private boolean isBoundedByOccurrences(CapabilityDefinition cap) {
3570                 return cap.getMaxOccurrences() != null && !cap.getMaxOccurrences()
3571                                 .equals(CapabilityDataDefinition.MAX_OCCURRENCES);
3572         }
3573
3574         private Either<RequirementDefinition, ResponseFormat> findAviableRequiremen(String regName, String yamlName,
3575                                                                                                                                                                 UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance,
3576                                                                                                                                                                 String capName) {
3577                 Map<String, List<RequirementDefinition>> comInstRegDefMap = currentCompInstance.getRequirements();
3578                 List<RequirementDefinition> list = comInstRegDefMap.get(capName);
3579                 RequirementDefinition validRegDef = null;
3580                 if (list == null) {
3581                         for (Entry<String, List<RequirementDefinition>> entry : comInstRegDefMap.entrySet()) {
3582                                 for (RequirementDefinition reqDef : entry.getValue()) {
3583                                         if (reqDef.getName()
3584                                                         .equals(regName)) {
3585                                                 if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences()
3586                                                                 .equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
3587                                                         String leftOccurrences = reqDef.getLeftOccurrences();
3588                                                         if (leftOccurrences == null) {
3589                                                                 leftOccurrences = reqDef.getMaxOccurrences();
3590                                                         }
3591                                                         int left = Integer.parseInt(leftOccurrences);
3592                                                         if (left > 0) {
3593                                                                 --left;
3594                                                                 reqDef.setLeftOccurrences(String.valueOf(left));
3595                                                                 validRegDef = reqDef;
3596                                                                 break;
3597                                                         } else {
3598                                                                 continue;
3599                                                         }
3600                                                 } else {
3601                                                         validRegDef = reqDef;
3602                                                         break;
3603                                                 }
3604
3605                                         }
3606                                 }
3607                                 if (validRegDef != null) {
3608                                         break;
3609                                 }
3610                         }
3611                 } else {
3612                         for (RequirementDefinition reqDef : list) {
3613                                 if (reqDef.getName()
3614                                                 .equals(regName)) {
3615                                         if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences()
3616                                                         .equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
3617                                                 String leftOccurrences = reqDef.getLeftOccurrences();
3618                                                 if (leftOccurrences == null) {
3619                                                         leftOccurrences = reqDef.getMaxOccurrences();
3620                                                 }
3621                                                 int left = Integer.parseInt(leftOccurrences);
3622                                                 if (left > 0) {
3623                                                         --left;
3624                                                         reqDef.setLeftOccurrences(String.valueOf(left));
3625                                                         validRegDef = reqDef;
3626                                                         break;
3627                                                 } else {
3628                                                         continue;
3629                                                 }
3630                                         } else {
3631                                                 validRegDef = reqDef;
3632                                                 break;
3633                                         }
3634                                 }
3635                         }
3636                 }
3637                 if (validRegDef == null) {
3638                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE,
3639                                         yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3640                         return Either.right(responseFormat);
3641                 }
3642                 return Either.left(validRegDef);
3643         }
3644
3645         private Resource createResourceInstances(String yamlName, Resource resource, Resource oldResource,
3646                                                                                          Map<String, UploadComponentInstanceInfo> uploadResInstancesMap, Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingNodeTypesByResourceNames) {
3647
3648                 Either<Resource, ResponseFormat> eitherResource;
3649                 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
3650         if (isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
3651             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
3652             throw new ByResponseFormatComponentException(responseFormat);
3653                 }
3654                 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
3655                         nodeNamespaceMap.forEach((k, v) -> existingNodeTypesByResourceNames.put(v.getToscaResourceName(), v));
3656                 }
3657                 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
3658                 uploadResInstancesMap.values()
3659                                 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap,
3660                                                 existingNodeTypesByResourceNames, resourcesInstancesMap));
3661                 if (oldResource != null && oldResource.getResourceType() != ResourceTypeEnum.CVFC && oldResource.getComponentInstances() != null) {
3662                         Map<String, Resource> existingNodeTypesByUids = existingNodeTypesByResourceNames.values()
3663                                         .stream()
3664                                         .collect(toMap(Resource::getUniqueId, r -> r));
3665                         oldResource.getComponentInstances()
3666                                         .stream()
3667                                         .filter(i -> !i.isCreatedFromCsar())
3668                                         .forEach(uiInst -> resourcesInstancesMap.put(uiInst,
3669                                                         getOriginResource(existingNodeTypesByUids, uiInst)));
3670                 }
3671
3672                 if (isNotEmpty(resourcesInstancesMap)) {
3673                         try {
3674                                 toscaOperationFacade.associateComponentInstancesToComponent(resource,
3675                                                 resourcesInstancesMap, false, oldResource != null);
3676                         } catch (StorageException exp) {
3677                                 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
3678                                         log.debug("Failed to add component instances to container component {}", resource.getName());
3679                                         ResponseFormat responseFormat = componentsUtils
3680                                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
3681                                         eitherResource = Either.right(responseFormat);
3682                                         throw new ByResponseFormatComponentException(eitherResource.right().value());
3683                                 }
3684                         }
3685                 }
3686         if (CollectionUtils.isEmpty(resource.getComponentInstances()) &&
3687                 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
3688                         log.debug("Error when create resource instance from csar. ComponentInstances list empty");
3689                         BeEcompErrorManager.getInstance()
3690                                         .logBeDaoSystemError(
3691                                                         "Error when create resource instance from csar. ComponentInstances list empty");
3692                         throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
3693                 }
3694                 return resource;
3695         }
3696
3697         private void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName,
3698                                                                                           Resource resource, Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
3699                                                                                           Map<ComponentInstance, Resource> resourcesInstancesMap) {
3700                 Either<Resource, ResponseFormat> eitherResource;
3701                 log.debug("*************Going to create  resource instances {}", yamlName);
3702                 // updating type if the type is node type name - we need to take the
3703                 // updated name
3704                 log.debug("*************Going to create  resource instances {}", uploadComponentInstanceInfo.getName());
3705                 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
3706                         uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType())
3707                                         .getToscaResourceName());
3708                 }
3709                 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo,
3710                                 existingnodeTypeMap, resource);
3711
3712                 ComponentInstance componentInstance = new ComponentInstance();
3713                 componentInstance.setComponentUid(refResource.getUniqueId());
3714         Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
3715         if(directives != null && !directives.isEmpty()) {
3716             componentInstance.setDirectives(new ArrayList<>(directives));
3717         }
3718         UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
3719         if (uploadNodeFilterInfo != null){
3720             componentInstance.setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo,
3721                     componentInstance.getUniqueId()));
3722         }
3723         ComponentTypeEnum containerComponentType = resource.getComponentType();
3724                 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
3725                 if (containerNodeType == NodeTypeEnum.Resource && isNotEmpty(uploadComponentInstanceInfo.getCapabilities())
3726                                 && isNotEmpty(refResource.getCapabilities())) {
3727                         setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
3728                         Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = getValidComponentInstanceCapabilities(
3729                                         refResource.getUniqueId(), refResource.getCapabilities(),
3730                                         uploadComponentInstanceInfo.getCapabilities());
3731                         componentInstance.setCapabilities(validComponentInstanceCapabilities);
3732                 }
3733
3734         if (isNotEmpty(uploadComponentInstanceInfo.getArtifacts())) {
3735             Map<String, Map<String, UploadArtifactInfo>> artifacts = uploadComponentInstanceInfo.getArtifacts();
3736             Map<String, ToscaArtifactDataDefinition> toscaArtifacts = new HashMap<>();
3737             Map<String, Map<String, UploadArtifactInfo>> arts = artifacts.entrySet().stream()
3738                                         .filter(e -> e.getKey().contains(TypeUtils.ToscaTagNamesEnum.ARTIFACTS.getElementName()))
3739                                         .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
3740             Map<String, UploadArtifactInfo> artifact = arts.get(TypeUtils.ToscaTagNamesEnum.ARTIFACTS.getElementName());
3741             for (Map.Entry<String, UploadArtifactInfo> entry : artifact.entrySet()) {
3742                 ToscaArtifactDataDefinition to = new ToscaArtifactDataDefinition();
3743                 to.setFile(entry.getValue().getFile());
3744                 to.setType(entry.getValue().getType());
3745                 toscaArtifacts.put(entry.getKey(), to);
3746             }
3747             componentInstance.setToscaArtifacts(toscaArtifacts);
3748         }
3749
3750                 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
3751                         log.debug("createResourceInstances - not found lates version for resource instance with name {} and type ",
3752                                         uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3753                         throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE,
3754                                         yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3755                 }
3756                 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
3757                 componentInstance.setName(uploadComponentInstanceInfo.getName());
3758                 componentInstance.setIcon(origResource.getIcon());
3759                 componentInstance.setCreatedFrom(CreatedFrom.CSAR);
3760                 resourcesInstancesMap.put(componentInstance, origResource);
3761         }
3762
3763         private ComponentParametersView getComponentWithInstancesFilter() {
3764                 ComponentParametersView parametersView = new ComponentParametersView();
3765                 parametersView.disableAll();
3766                 parametersView.setIgnoreComponentInstances(false);
3767                 parametersView.setIgnoreInputs(false);
3768                 // inputs are read when creating
3769                 // property values on instances
3770                 parametersView.setIgnoreUsers(false);
3771                 return parametersView;
3772         }
3773
3774         private void setCapabilityNamesTypes(Map<String, List<CapabilityDefinition>> originCapabilities,
3775                                                                                  Map<String, List<UploadCapInfo>> uploadedCapabilities) {
3776                 for (Entry<String, List<UploadCapInfo>> currEntry : uploadedCapabilities.entrySet()) {
3777                         if (originCapabilities.containsKey(currEntry.getKey())) {
3778                                 currEntry.getValue()
3779                                                 .stream()
3780                                                 .forEach(cap -> cap.setType(currEntry.getKey()));
3781                         }
3782                 }
3783                 for (Map.Entry<String, List<CapabilityDefinition>> capabilities : originCapabilities.entrySet()) {
3784                         capabilities.getValue()
3785                                         .stream()
3786                                         .forEach(cap -> {
3787                                                 if (uploadedCapabilities.containsKey(cap.getName())) {
3788                                                         uploadedCapabilities.get(cap.getName())
3789                                                                         .stream()
3790                                                                         .forEach(c -> {
3791                                                                                 c.setName(cap.getName());
3792                                                                                 c.setType(cap.getType());
3793                                                                         });
3794                                                 }
3795                                         });
3796                 }
3797         }
3798
3799         private Resource validateResourceInstanceBeforeCreate(String yamlName,
3800                         UploadComponentInstanceInfo uploadComponentInstanceInfo, Map<String, Resource> nodeNamespaceMap, Resource resource) {
3801
3802                 log.debug(
3803                                 "validateResourceInstanceBeforeCreate - going to validate resource instance with name {} and type {} before create",
3804                                 uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3805                 Resource refResource;
3806                 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
3807                         refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
3808                 } else {
3809                         Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
3810                                         .getByToscaResourceNameMatchingVendorRelease(uploadComponentInstanceInfo.getType(),
3811                                                 ((ResourceMetadataDataDefinition)resource.getComponentMetadataDefinition().getMetadataDataDefinition()).getVendorRelease());
3812                         if (findResourceEither.isRight()) {
3813                                 log.debug(
3814                                                 "validateResourceInstanceBeforeCreate - not found latest version for resource instance with name {} and type {}",
3815                                                 uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3816                                 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
3817                         }
3818                         refResource = findResourceEither.left().value();
3819                         nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
3820                 }
3821                 String componentState = refResource.getComponentMetadataDefinition()
3822                                 .getMetadataDataDefinition()
3823                                 .getState();
3824                 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
3825                         log.debug(
3826                                         "validateResourceInstanceBeforeCreate - component instance of component {} can not be created because the component is in an illegal state {}.",
3827                                         refResource.getName(), componentState);
3828                         throw new ByActionStatusComponentException(ActionStatus.ILLEGAL_COMPONENT_STATE,
3829                                         refResource.getComponentType().getValue(),refResource.getName(), componentState);
3830                 }
3831
3832                 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.CVFC) {
3833                         log.debug("validateResourceInstanceBeforeCreate -  ref resource type is  ", refResource.getResourceType());
3834                         throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE,
3835                                         yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3836                 }
3837                 return refResource;
3838         }
3839
3840         public Resource propagateStateToCertified(User user, Resource resource,
3841                                                                                           LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock,
3842                                                                                           boolean forceCertificationAllowed) {
3843
3844                 boolean failed = false;
3845                 try {
3846                         if (resource.getLifecycleState() != LifecycleStateEnum.CERTIFIED && forceCertificationAllowed
3847                                         && lifecycleBusinessLogic.isFirstCertification(resource.getVersion())) {
3848                                 nodeForceCertification(resource, user, lifecycleChangeInfo, inTransaction, needLock);
3849                         }
3850                         if (resource.getLifecycleState() == LifecycleStateEnum.CERTIFIED) {
3851                                 Either<ArtifactDefinition, Operation> eitherPopulated = populateToscaArtifacts(
3852                                                 resource, user, false, inTransaction, needLock, false);
3853                                 return resource;
3854                         }
3855                         return nodeFullCertification(resource.getUniqueId(), user, lifecycleChangeInfo, inTransaction, needLock);
3856                 } catch (ComponentException e) {
3857                         failed = true;
3858                         log.debug("The exception has occurred upon certification of resource {}. ", resource.getName(), e);
3859                         throw e;
3860                 } finally {
3861                         if (failed) {
3862                                 BeEcompErrorManager.getInstance()
3863                                                 .logBeSystemError("Change LifecycleState - Certify");
3864                                 if (!inTransaction) {
3865                     janusGraphDao.rollback();
3866                                 }
3867                         } else if (!inTransaction) {
3868                 janusGraphDao.commit();
3869                         }
3870                 }
3871         }
3872
3873         private Resource nodeFullCertification(String uniqueId, User user,
3874                                                                                    LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) {
3875                 Either<Resource, ResponseFormat> resourceResponse = lifecycleBusinessLogic.changeState(uniqueId, user, LifeCycleTransitionEnum.CERTIFY, lifecycleChangeInfo,
3876                                 inTransaction, needLock);
3877                 if(resourceResponse.isRight()){
3878                         throw new ByResponseFormatComponentException(resourceResponse.right().value());
3879                 }
3880                 return resourceResponse.left().value();
3881         }
3882
3883         private Resource nodeForceCertification(Resource resource, User user,
3884                                                                                         LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) {
3885                 return lifecycleBusinessLogic.forceResourceCertification(resource, user, lifecycleChangeInfo, inTransaction,
3886                                 needLock);
3887         }
3888
3889         public ImmutablePair<Resource, ActionStatus> createOrUpdateResourceByImport(final Resource resource,
3890                                                                                                                                                                 final User user,
3891                                                                                                                                                                 final boolean isNormative,
3892                                                                                                                                                                 final boolean isInTransaction,
3893                                                                                                                                                                 final boolean needLock,
3894                                                                                                                                                                 final CsarInfo csarInfo,
3895                                                                                                                                                                 final String nodeName,
3896                                                                                                                                                                 final boolean isNested) {
3897
3898                 ImmutablePair<Resource, ActionStatus> result = null;
3899                 // check if resource already exists (search by tosca name = type)
3900                 final boolean isNestedResource = isNestedResourceUpdate(csarInfo, nodeName);
3901                 final Either<Resource, StorageOperationStatus> latestByToscaName = toscaOperationFacade
3902                         .getLatestByToscaResourceName(resource.getToscaResourceName());
3903
3904                 if (latestByToscaName.isLeft()) {
3905                         Resource foundResource = latestByToscaName.left().value();
3906                         // we don't allow updating names of top level types
3907                         if (!isNestedResource && !StringUtils.equals(resource.getName(), foundResource.getName())) {
3908                                 BeEcompErrorManager.getInstance().logBeComponentMissingError("Create / Update resource by import",
3909                                         ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
3910                                 log.debug("resource already exist new name={} old name={} same type={}", resource.getName(),
3911                                         foundResource.getName(), resource.getToscaResourceName());
3912                                 final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_ALREADY_EXISTS);
3913                                 componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
3914                                 throwComponentException(responseFormat);
3915                         }
3916                         result = updateExistingResourceByImport(resource, foundResource, user, isNormative, needLock, isNested);
3917                 } else if (isNotFound(latestByToscaName)) {
3918                         if (isNestedResource) {
3919                                 result = createOrUpdateNestedResource(resource, user, isNormative, isInTransaction, needLock, csarInfo,
3920                                         isNested, nodeName);
3921                         } else {
3922                                 result = createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3923                         }
3924                 } else {
3925                         StorageOperationStatus status = latestByToscaName.right().value();
3926                         log.debug("failed to get latest version of resource {}. status={}", resource.getName(), status);
3927                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(componentsUtils
3928                                 .convertFromStorageResponse(latestByToscaName.right().value()), resource);
3929                         componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
3930                         throwComponentException(responseFormat);
3931                 }
3932                 return result;
3933         }
3934
3935         private boolean isNestedResourceUpdate(CsarInfo csarInfo, String nodeName) {
3936                 return csarInfo != null && csarInfo.isUpdate() && nodeName != null;
3937         }
3938
3939         private ImmutablePair<Resource, ActionStatus> createOrUpdateNestedResource(final Resource resource,
3940                                                                                                                                                            final User user,
3941                                                                                                                                                            final boolean isNormative,
3942                                                                                                                                                            final boolean isInTransaction,
3943                                                                                                                                                            final boolean needLock,
3944                                                                                                                                                            final CsarInfo csarInfo,
3945                                                                                                                                                            final boolean isNested,
3946                                                                                                                                                            final String nodeName) {
3947                 final Either<Component, StorageOperationStatus> latestByToscaName = toscaOperationFacade
3948                         .getLatestByToscaResourceName(buildNestedToscaResourceName(resource.getResourceType()
3949                                 .name(), csarInfo.getVfResourceName(), nodeName).getRight());
3950                 if (latestByToscaName.isLeft()) {
3951                         final Resource nestedResource = (Resource) latestByToscaName.left().value();
3952                         log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
3953                         final Either<Boolean, ResponseFormat> eitherValidation = validateNestedDerivedFromDuringUpdate(nestedResource,
3954                                 resource, ValidationUtils.hasBeenCertified(nestedResource.getVersion()));
3955                         if (eitherValidation.isRight()) {
3956                                 return createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3957                         }
3958                         return updateExistingResourceByImport(resource, nestedResource, user, isNormative, needLock, isNested);
3959                 } else {
3960                         return createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3961                 }
3962         }
3963
3964         private boolean isNotFound(Either<Resource, StorageOperationStatus> getResourceEither) {
3965                 return getResourceEither.isRight() && getResourceEither.right()
3966                                 .value() == StorageOperationStatus.NOT_FOUND;
3967         }
3968
3969         private ImmutablePair<Resource, ActionStatus> createResourceByImport(Resource resource, User user,
3970                                                                                                                                                  boolean isNormative, boolean isInTransaction, CsarInfo csarInfo) {
3971                 log.debug("resource with name {} does not exist. create new resource", resource.getName());
3972                 validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isInTransaction, csarInfo);
3973                 final Resource createResourceByDao = createResourceByDao(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isNormative,
3974                                 isInTransaction);
3975                 Resource createdResource  = updateCatalog(createResourceByDao, ChangeTypeEnum.LIFECYCLE).left().map(r -> (Resource)r).left().value();
3976                 ImmutablePair<Resource, ActionStatus> resourcePair = new ImmutablePair<>(createdResource, ActionStatus.CREATED);
3977                 ASDCKpiApi.countImportResourcesKPI();
3978                 return resourcePair;
3979         }
3980
3981         public boolean isResourceExist(String resourceName) {
3982                 Either<Resource, StorageOperationStatus> latestByName = toscaOperationFacade.getLatestByName(resourceName);
3983                 return latestByName.isLeft();
3984         }
3985
3986         private ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource,
3987                                                                                                                                                                  Resource oldResource, User user, boolean inTransaction, boolean needLock, boolean isNested) {
3988                 String lockedResourceId = oldResource.getUniqueId();
3989                 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId,
3990                                 oldResource.getVersion(), oldResource.getLifecycleState());
3991                 ImmutablePair<Resource, ActionStatus> resourcePair = null;
3992                 try {
3993                         lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
3994                         oldResource = prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
3995                         mergeOldResourceMetadataWithNew(oldResource, newResource);
3996
3997                         validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
3998                         validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), newResource, AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
3999                         // contact info normalization
4000                         newResource.setContactId(newResource.getContactId().toLowerCase());
4001                         PropertyConstraintsUtils.validatePropertiesConstraints(newResource, oldResource);
4002                         // non-updatable fields
4003                         newResource.setCreatorUserId(user.getUserId());
4004                         newResource.setCreatorFullName(user.getFullName());
4005                         newResource.setLastUpdaterUserId(user.getUserId());
4006                         newResource.setLastUpdaterFullName(user.getFullName());
4007                         newResource.setUniqueId(oldResource.getUniqueId());
4008                         newResource.setVersion(oldResource.getVersion());
4009                         newResource.setInvariantUUID(oldResource.getInvariantUUID());
4010                         newResource.setLifecycleState(oldResource.getLifecycleState());
4011                         newResource.setUUID(oldResource.getUUID());
4012                         newResource.setNormalizedName(oldResource.getNormalizedName());
4013                         newResource.setSystemName(oldResource.getSystemName());
4014                         if (oldResource.getCsarUUID() != null) {
4015                                 newResource.setCsarUUID(oldResource.getCsarUUID());
4016                         }
4017                         if (oldResource.getImportedToscaChecksum() != null) {
4018                                 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
4019                         }
4020                         newResource.setAbstract(oldResource.isAbstract());
4021
4022                         if (CollectionUtils.isEmpty(newResource.getDerivedFrom())){
4023                                 newResource.setDerivedFrom(oldResource.getDerivedFrom());
4024                         }
4025                         if (CollectionUtils.isEmpty(newResource.getDataTypes())){
4026                                 newResource.setDataTypes(oldResource.getDataTypes());
4027                         }
4028                         if (StringUtils.isEmpty(newResource.getDerivedFromGenericType())){
4029                                 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
4030                         }
4031                         if (StringUtils.isEmpty(newResource.getDerivedFromGenericVersion())){
4032                                 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
4033                         }
4034                         // add for new)
4035                         // created without tosca artifacts - add the placeholders
4036                         if (MapUtils.isEmpty(newResource.getToscaArtifacts())){
4037                                 setToscaArtifactsPlaceHolders(newResource, user);
4038                         }
4039
4040                         if (MapUtils.isEmpty(newResource.getInterfaces())){
4041                                 newResource.setInterfaces(oldResource.getInterfaces());
4042                         }
4043                         if (CollectionUtils.isEmpty(newResource.getAttributes())) {
4044                                 newResource.setAttributes(oldResource.getAttributes());
4045                         }
4046
4047                         if (CollectionUtils.isEmpty(newResource.getProperties())) {
4048                                 newResource.setProperties(oldResource.getProperties());
4049                         }
4050
4051                         Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
4052
4053                         if (overrideResource.isRight()) {
4054                                 ResponseFormat responseFormat = componentsUtils
4055                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(overrideResource.right()
4056                                                 .value()), newResource);
4057                                 componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE);
4058
4059                                 throwComponentException(responseFormat);
4060                         }
4061                         updateCatalog(overrideResource.left()
4062                                 .value(), ChangeTypeEnum.LIFECYCLE);
4063
4064                         log.debug("Resource updated successfully!!!");
4065                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4066                         componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4067                                 ResourceVersionInfo.newBuilder()
4068                                         .state(oldResource.getLifecycleState()
4069                                                 .name())
4070                                         .version(oldResource.getVersion())
4071                                         .build());
4072
4073                         resourcePair = new ImmutablePair<>(overrideResource.left()
4074                                 .value(), ActionStatus.OK);
4075                         return resourcePair;
4076                 } finally {
4077                         if (resourcePair == null) {
4078                                 BeEcompErrorManager.getInstance()
4079                                                 .logBeSystemError("Change LifecycleState - Certify");
4080                                 janusGraphDao.rollback();
4081                         } else if (!inTransaction) {
4082                 janusGraphDao.commit();
4083                         }
4084                         if (needLock) {
4085                                 log.debug("unlock resource {}", lockedResourceId);
4086                                 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
4087                         }
4088                 }
4089
4090         }
4091
4092         /**
4093          * Merge old resource with new. Keep old category and vendor name without
4094          * change
4095          *
4096          * @param oldResource
4097          * @param newResource
4098          */
4099         private void mergeOldResourceMetadataWithNew(Resource oldResource, Resource newResource) {
4100
4101                 // keep old category and vendor name without change
4102                 // merge the rest of the resource metadata
4103                 if (newResource.getTags() == null || newResource.getTags().isEmpty()) {
4104                         newResource.setTags(oldResource.getTags());
4105                 }
4106
4107                 if (newResource.getDescription() == null) {
4108                         newResource.setDescription(oldResource.getDescription());
4109                 }
4110
4111                 if (newResource.getVendorRelease() == null) {
4112                         newResource.setVendorRelease(oldResource.getVendorRelease());
4113                 }
4114
4115                 if (newResource.getResourceVendorModelNumber() == null) {
4116                         newResource.setResourceVendorModelNumber(oldResource.getResourceVendorModelNumber());
4117                 }
4118
4119                 if (newResource.getContactId() == null) {
4120                         newResource.setContactId(oldResource.getContactId());
4121                 }
4122
4123                 newResource.setCategories(oldResource.getCategories());
4124                 if (newResource.getVendorName() == null) {
4125                         newResource.setVendorName(oldResource.getVendorName());
4126                 }
4127                 List<GroupDefinition>oldForUpdate = oldResource.getGroups();
4128                 if(CollectionUtils.isNotEmpty(oldForUpdate)){
4129                         List<GroupDefinition>groupForUpdate = oldForUpdate.stream().map(group -> new GroupDefinition(group)).collect(Collectors.toList());
4130
4131                         groupForUpdate.stream().filter(group -> group.isVspOriginated())
4132                                         .forEach(group -> group.setName(group.getInvariantName()));
4133
4134                         newResource.setGroups(groupForUpdate);
4135                 }
4136
4137
4138                 if(newResource.getResourceType().isAtomicType() && !newResource.getName().equals("Root")&& newResource.getResourceType() != ResourceTypeEnum.CVFC) {
4139                         ResourceTypeEnum updatedResourceType = newResource.getResourceType();
4140                         Component derivedFromResource = getParentComponent(newResource);
4141                         if (derivedFromResource.getComponentType() == ComponentTypeEnum.RESOURCE) {
4142                                 Resource parentResource = (Resource) derivedFromResource;
4143                                 if (!(parentResource.isAbstract() && (ResourceTypeEnum.VFC == parentResource.getResourceType() || ResourceTypeEnum.ABSTRACT == parentResource.getResourceType())) &&
4144                                                 parentResource.getResourceType() != updatedResourceType && oldResource.getResourceType() != updatedResourceType) {
4145                                         BeEcompErrorManager.getInstance()
4146                                                         .logInternalDataError("mergeOldResourceMetadataWithNew", "resource type of the resource does not match to derived from resource type",
4147                                                                         ErrorSeverity.ERROR);
4148                                         log.debug("#mergeOldResourceMetadataWithNew - resource type {} of the resource {} does not match to derived from resource type {}",
4149                                                         newResource.getResourceType(), newResource.getToscaResourceName(), parentResource.getResourceType());
4150                                         throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_TYPE);
4151                                 }
4152                         }
4153                 }
4154
4155         }
4156
4157         private Component getParentComponent(Resource newResource) {
4158                 String toscaResourceNameDerivedFrom = newResource.getDerivedFrom().get(0);
4159                 Either<Component, StorageOperationStatus> latestByToscaResourceName = toscaOperationFacade.getLatestByToscaResourceName(toscaResourceNameDerivedFrom);
4160                 if(latestByToscaResourceName.isRight()){
4161                         BeEcompErrorManager.getInstance()
4162                                         .logInternalDataError("mergeOldResourceMetadataWithNew", "derived from resource not found", ErrorSeverity.ERROR);
4163                         log.debug("#mergeOldResourceMetadataWithNew - derived from resource {} not found", toscaResourceNameDerivedFrom);
4164                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, toscaResourceNameDerivedFrom);
4165                 }
4166                 return latestByToscaResourceName.left().value();
4167         }
4168
4169         private Resource prepareResourceForUpdate(Resource oldResource, Resource newResource, User user,
4170                                                                                           boolean inTransaction, boolean needLock) {
4171
4172                 if (!ComponentValidationUtils.canWorkOnResource(oldResource, user.getUserId())) {
4173                         // checkout
4174                         return lifecycleBusinessLogic.changeState(oldResource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
4175                                         new LifecycleChangeInfoWithAction("update by import"), inTransaction, needLock)
4176                                         .left()
4177                                         .on(response -> failOnChangeState(response, user, oldResource, newResource));
4178                 }
4179                 return oldResource;
4180         }
4181
4182         private Resource failOnChangeState(ResponseFormat response, User user, Resource oldResource, Resource newResource) {
4183                 log.info("resource {} cannot be updated. reason={}", oldResource.getUniqueId(), response.getFormattedMessage());
4184                 componentsUtils.auditResource(response, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4185                                 ResourceVersionInfo.newBuilder()
4186                                                 .state(oldResource.getLifecycleState()
4187                                                                 .name())
4188                                                 .version(oldResource.getVersion())
4189                                                 .build());
4190                 throw new ByResponseFormatComponentException(response);
4191         }
4192
4193         public Resource validateResourceBeforeCreate(Resource resource, User user, AuditingActionEnum actionEnum,
4194                                                                                                  boolean inTransaction, CsarInfo csarInfo) {
4195
4196                 validateResourceFieldsBeforeCreate(user, resource, actionEnum, inTransaction);
4197                 validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), resource, actionEnum, inTransaction);
4198                 validateLifecycleTypesCreate(user, resource, actionEnum);
4199                 validateResourceType(user, resource, actionEnum);
4200                 resource.setCreatorUserId(user.getUserId());
4201                 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
4202                 resource.setContactId(resource.getContactId()
4203                                 .toLowerCase());
4204                 if (StringUtils.isEmpty(resource.getToscaResourceName()) && !ModelConverter.isAtomicComponent(resource)) {
4205                         String resourceSystemName;
4206                         if (csarInfo != null && StringUtils.isNotEmpty(csarInfo.getVfResourceName())) {
4207                                 resourceSystemName = ValidationUtils.convertToSystemName(csarInfo.getVfResourceName());
4208                         } else {
4209                                 resourceSystemName = resource.getSystemName();
4210                         }
4211                         resource.setToscaResourceName(CommonBeUtils
4212                                 .generateToscaResourceName(resource.getResourceType().name().toLowerCase(), resourceSystemName));
4213                 }
4214
4215                 // Generate invariant UUID - must be here and not in operation since it
4216                 // should stay constant during clone
4217                 // TODO
4218                 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
4219                 resource.setInvariantUUID(invariantUUID);
4220
4221                 return resource;
4222         }
4223
4224         private Either<Boolean, ResponseFormat> validateResourceType(User user, Resource resource,
4225                                                                                                                                  AuditingActionEnum actionEnum) {
4226                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4227                 if (resource.getResourceType() == null) {
4228                         log.debug("Invalid resource type for resource");
4229                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
4230                         eitherResult = Either.right(errorResponse);
4231                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4232                 }
4233                 return eitherResult;
4234         }
4235
4236         private Either<Boolean, ResponseFormat> validateLifecycleTypesCreate(User user, Resource resource,
4237                                                                                                                                                  AuditingActionEnum actionEnum) {
4238                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4239                 if (resource.getInterfaces() != null && resource.getInterfaces()
4240                                 .size() > 0) {
4241                         log.debug("validate interface lifecycle Types Exist");
4242                         Iterator<InterfaceDefinition> intItr = resource.getInterfaces()
4243                                         .values()
4244                                         .iterator();
4245                         while (intItr.hasNext() && eitherResult.isLeft()) {
4246                                 InterfaceDefinition interfaceDefinition = intItr.next();
4247                                 String intType = interfaceDefinition.getUniqueId();
4248                                 Either<InterfaceDefinition, StorageOperationStatus> eitherCapTypeFound = interfaceTypeOperation
4249                                                 .getInterface(intType);
4250                                 if (eitherCapTypeFound.isRight()) {
4251                                         if (eitherCapTypeFound.right()
4252                                                         .value() == StorageOperationStatus.NOT_FOUND) {
4253                                                 BeEcompErrorManager.getInstance()
4254                                                                 .logBeGraphObjectMissingError("Create Resource - validateLifecycleTypesCreate",
4255                                                                                 "Interface", intType);
4256                                                 log.debug("Lifecycle Type: {} is required by resource: {} but does not exist in the DB",
4257                                                                 intType, resource.getName());
4258                                                 BeEcompErrorManager.getInstance()
4259                                                                 .logBeDaoSystemError("Create Resource - validateLifecycleTypesCreate");
4260                                                 log.debug("request to data model failed with error: {}", eitherCapTypeFound.right()
4261                                                                 .value()
4262                                                                 .name());
4263                                         }
4264
4265                                         ResponseFormat errorResponse = componentsUtils
4266                                                         .getResponseFormat(ActionStatus.MISSING_LIFECYCLE_TYPE, intType);
4267                                         eitherResult = Either.right(errorResponse);
4268                                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4269                                 }
4270
4271                         }
4272                 }
4273                 return eitherResult;
4274         }
4275
4276         private Either<Boolean, ResponseFormat> validateCapabilityTypesCreate(User user,
4277                                                                                                                                                   ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4278                                                                                                                                                   boolean inTransaction) {
4279
4280                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4281                 if (resource.getCapabilities() != null && resource.getCapabilities()
4282                                 .size() > 0) {
4283                         log.debug("validate capability Types Exist - capabilities section");
4284
4285                         for (Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities()
4286                                         .entrySet()) {
4287
4288                                 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource, actionEnum,
4289                                                 eitherResult, typeEntry, inTransaction);
4290                                 if (eitherResult.isRight()) {
4291                                         return Either.right(eitherResult.right()
4292                                                         .value());
4293                                 }
4294                         }
4295                 }
4296
4297                 if (resource.getRequirements() != null && resource.getRequirements()
4298                                 .size() > 0) {
4299                         log.debug("validate capability Types Exist - requirements section");
4300                         for (String type : resource.getRequirements()
4301                                         .keySet()) {
4302                                 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource,
4303                                                 resource.getRequirements()
4304                                                                 .get(type),
4305                                                 actionEnum, eitherResult, type, inTransaction);
4306                                 if (eitherResult.isRight()) {
4307                                         return Either.right(eitherResult.right()
4308                                                         .value());
4309                                 }
4310                         }
4311                 }
4312
4313                 return eitherResult;
4314         }
4315
4316         // @param typeObject- the object to which the validation is done
4317         private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4318                                                                                                                                                  ICapabilityTypeOperation capabilityTypeOperation, Resource resource, List<?> validationObjects,
4319                                                                                                                                                  AuditingActionEnum actionEnum, Either<Boolean, ResponseFormat> eitherResult, String type,
4320                                                                                                                                                  boolean inTransaction) {
4321                 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4322                                 .getCapabilityType(type, inTransaction);
4323                 if (eitherCapTypeFound.isRight()) {
4324                         if (eitherCapTypeFound.right()
4325                                         .value() == StorageOperationStatus.NOT_FOUND) {
4326                                 BeEcompErrorManager.getInstance()
4327                                                 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4328                                                                 type);
4329                                 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB", type,
4330                                                 resource.getName());
4331                                 BeEcompErrorManager.getInstance()
4332                                                 .logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4333                         }
4334                         log.debug("Trying to get capability type {} failed with error: {}", type, eitherCapTypeFound.right()
4335                                         .value()
4336                                         .name());
4337                         ResponseFormat errorResponse = null;
4338                         if (type != null) {
4339                                 errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, type);
4340                         } else {
4341                                 errorResponse = componentsUtils.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE,
4342                                                 validationObjects);
4343                         }
4344                         eitherResult = Either.right(errorResponse);
4345                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4346                 }
4347                 return eitherResult;
4348         }
4349
4350         private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4351                                                                                                                                                  ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4352                                                                                                                                                  Either<Boolean, ResponseFormat> eitherResult, Entry<String, List<CapabilityDefinition>> typeEntry,
4353                                                                                                                                                  boolean inTransaction) {
4354                 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4355                                 .getCapabilityType(typeEntry.getKey(), inTransaction);
4356                 if (eitherCapTypeFound.isRight()) {
4357                         if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) {
4358                                 BeEcompErrorManager.getInstance()
4359                                                 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4360                                                                 typeEntry.getKey());
4361                                 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB",
4362                                                 typeEntry.getKey(), resource.getName());
4363                                 BeEcompErrorManager.getInstance().logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4364                         }
4365                         log.debug("Trying to get capability type {} failed with error: {}", typeEntry.getKey(),
4366                                         eitherCapTypeFound.right().value().name());
4367                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE,
4368                                         typeEntry.getKey());
4369                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4370                         return Either.right(errorResponse);
4371                 }
4372                 CapabilityTypeDefinition capabilityTypeDefinition = eitherCapTypeFound.left().value();
4373                 if (capabilityTypeDefinition.getProperties() != null) {
4374                         for (CapabilityDefinition capDef : typeEntry.getValue()) {
4375                                 List<ComponentInstanceProperty> properties = capDef.getProperties();
4376                                 List<ComponentInstanceProperty> changedProperties = new ArrayList<>();
4377                                 if (properties == null || properties.isEmpty()) {
4378                                         for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4379                                                 ComponentInstanceProperty newProp = new ComponentInstanceProperty(prop.getValue());
4380                                                 changedProperties.add(newProp);
4381                                         }
4382                                 } else {
4383                                         List<ComponentInstanceProperty> propsToAdd = new ArrayList<>();
4384                                         for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4385                                                 PropertyDefinition propFromDef = prop.getValue();
4386                                                 boolean propFound = false;
4387                                                 for (ComponentInstanceProperty cip : properties) {
4388                                                         if (propFromDef.getName().equals(cip.getName())) {
4389                                                                 //merge property value and property description only, ignore other fields
4390                                                                 if(cip.getDescription() != null && !cip.getDescription().equals(propFromDef.getDescription())){
4391                                                                         propFromDef.setDescription(cip.getDescription());
4392                                                                 }
4393                                                                 propertyDataValueMergeBusinessLogic.mergePropertyValue(propFromDef, cip, new ArrayList<>());
4394                                                                 if(cip.getValue() != null){
4395                                                                         propFromDef.setValue(cip.getValue());
4396                                                                 }
4397                                                                 propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4398                                                                 propFound = true;
4399                                                                 properties.remove(cip);
4400                                                                 break;
4401                                                         }
4402                                                 }
4403                                                 if(!propFound) {
4404                                                         propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4405                                                 }
4406                                         }
4407                                         if (!propsToAdd.isEmpty()) {
4408                                                 changedProperties.addAll(propsToAdd);
4409                                         }
4410                                 }
4411                                 capDef.setProperties(changedProperties);
4412                         }
4413                 }
4414                 return eitherResult;
4415         }
4416
4417         public Resource createResourceByDao(Resource resource, User user, AuditingActionEnum actionEnum,
4418                                                                                 boolean isNormative, boolean inTransaction) {
4419                 // create resource
4420
4421                 // lock new resource name in order to avoid creation resource with same
4422                 // name
4423                 Resource createdResource = null;
4424                 if (!inTransaction) {
4425                         Either<Boolean, ResponseFormat> lockResult = lockComponentByName(resource.getSystemName(), resource,
4426                                         CREATE_RESOURCE);
4427                         if (lockResult.isRight()) {
4428                                 ResponseFormat responseFormat = lockResult.right().value();
4429                                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4430                                 throw new ByResponseFormatComponentException(responseFormat);
4431                         }
4432
4433                         log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
4434                 }
4435                 try {
4436                         if (resource.deriveFromGeneric()) {
4437                                 handleResourceGenericType(resource);
4438                         }
4439                         createdResource = createResourceTransaction(resource, user, isNormative);
4440                         componentsUtils.auditResource(componentsUtils.getResponseFormat(ActionStatus.CREATED), user,
4441                                         createdResource, actionEnum);
4442                         ASDCKpiApi.countCreatedResourcesKPI();
4443                 } catch (ComponentException e) {
4444                         ResponseFormat responseFormat = e.getResponseFormat() == null
4445                                         ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
4446                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4447                         throw e;
4448                 } catch (StorageException e) {
4449                         ResponseFormat responseFormat = componentsUtils
4450                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
4451                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4452                         throw e;
4453                 } finally {
4454             if (!inTransaction) {
4455                                 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(),
4456                                                 NodeTypeEnum.Resource);
4457                         }
4458                 }
4459                 return createdResource;
4460         }
4461
4462         private Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
4463                 // validate resource name uniqueness
4464                 log.debug("validate resource name");
4465                 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade.validateComponentNameExists(
4466                                 resource.getName(), resource.getResourceType(), resource.getComponentType());
4467                 if (eitherValidation.isRight()) {
4468                         loggerSupportability.log(LoggerSupportabilityActions.VALIDATE_NAME,resource.getComponentMetadataForSupportLog(),
4469                                         StatusCode.ERROR,"ERROR while validate component name {} Status is: {}",resource.getName(),eitherValidation.right().value());
4470                         log.debug("Failed to validate component name {}. Status is {}. ", resource.getName(),
4471                                         eitherValidation.right()
4472                                                         .value());
4473                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(eitherValidation.right()
4474                                         .value()));
4475                 }
4476                 if (eitherValidation.left()
4477                                 .value()) {
4478                         log.debug("resource with name: {}, already exists", resource.getName());
4479                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
4480                                         StatusCode.ERROR,"resource with name: {} already exists",resource.getName());
4481                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
4482                                         ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
4483                 }
4484
4485                 log.debug("send resource {} to dao for create", resource.getName());
4486
4487                 createArtifactsPlaceHolderData(resource, user);
4488                 // enrich object
4489                 if (!isNormative) {
4490                         log.debug("enrich resource with creator, version and state");
4491                         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
4492                         resource.setVersion(INITIAL_VERSION);
4493                         resource.setHighestVersion(true);
4494                         if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4495                                 resource.setAbstract(false);
4496                         }
4497                 }
4498                 return toscaOperationFacade.createToscaComponent(resource)
4499                                 .left()
4500                                 .on(r -> throwComponentExceptionByResource(r, resource));
4501         }
4502
4503         private Resource throwComponentExceptionByResource(StorageOperationStatus status, Resource resource) {
4504                 ResponseFormat responseFormat = componentsUtils
4505                                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(status), resource);
4506                 throw new ByResponseFormatComponentException(responseFormat);
4507         }
4508
4509         private void createArtifactsPlaceHolderData(Resource resource, User user) {
4510                 // create mandatory artifacts
4511
4512                 // TODO it must be removed after that artifact uniqueId creation will be
4513                 // moved to ArtifactOperation
4514
4515                 setInformationalArtifactsPlaceHolder(resource, user);
4516                 setDeploymentArtifactsPlaceHolder(resource, user);
4517                 setToscaArtifactsPlaceHolders(resource, user);
4518         }
4519
4520         @SuppressWarnings("unchecked")
4521         @Override
4522         public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
4523                 Resource resource = (Resource) component;
4524                 Map<String, ArtifactDefinition> artifactMap = resource.getDeploymentArtifacts();
4525                 if (artifactMap == null) {
4526                         artifactMap = new HashMap<>();
4527                 }
4528                 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
4529                                 .getConfiguration()
4530                                 .getDeploymentResourceArtifacts();
4531                 if (deploymentResourceArtifacts != null) {
4532                         Map<String, ArtifactDefinition> finalArtifactMap = artifactMap;
4533                         deploymentResourceArtifacts
4534                                         .forEach((k, v) -> processDeploymentResourceArtifacts(user, resource, finalArtifactMap, k, v));
4535                 }
4536                 resource.setDeploymentArtifacts(artifactMap);
4537         }
4538
4539         private void processDeploymentResourceArtifacts(User user, Resource resource,
4540                                                                                                         Map<String, ArtifactDefinition> artifactMap, String k, Object v) {
4541                 Map<String, Object> artifactDetails = (Map<String, Object>) v;
4542                 Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES);
4543                 if (object != null) {
4544                         List<String> artifactTypes = (List<String>) object;
4545                         if (!artifactTypes.contains(resource.getResourceType()
4546                                         .name())) {
4547                                 return;
4548                         }
4549                 } else {
4550                         log.info("resource types for artifact placeholder {} were not defined. default is all resources", k);
4551                 }
4552                 if (artifactsBusinessLogic != null) {
4553                         ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4554                                         resource.getUniqueId(), k, (Map<String, Object>) v, user, ArtifactGroupTypeEnum.DEPLOYMENT);
4555                         if (artifactDefinition != null && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) {
4556                                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4557                         }
4558                 }
4559         }
4560
4561         @SuppressWarnings("unchecked")
4562         private void setInformationalArtifactsPlaceHolder(Resource resource, User user) {
4563                 Map<String, ArtifactDefinition> artifactMap = resource.getArtifacts();
4564                 if (artifactMap == null) {
4565                         artifactMap = new HashMap<>();
4566                 }
4567                 String resourceUniqueId = resource.getUniqueId();
4568                 List<String> exludeResourceCategory = ConfigurationManager.getConfigurationManager()
4569                                 .getConfiguration()
4570                                 .getExcludeResourceCategory();
4571                 List<String> exludeResourceType = ConfigurationManager.getConfigurationManager()
4572                                 .getConfiguration()
4573                                 .getExcludeResourceType();
4574                 Map<String, Object> informationalResourceArtifacts = ConfigurationManager.getConfigurationManager()
4575                                 .getConfiguration()
4576                                 .getInformationalResourceArtifacts();
4577                 List<CategoryDefinition> categories = resource.getCategories();
4578                 boolean isCreateArtifact = true;
4579                 if (exludeResourceCategory != null) {
4580                         String category = categories.get(0)
4581                                         .getName();
4582                         isCreateArtifact = exludeResourceCategory.stream()
4583                                         .noneMatch(e -> e.equalsIgnoreCase(category));
4584                 }
4585                 if (isCreateArtifact && exludeResourceType != null) {
4586                         String resourceType = resource.getResourceType()
4587                                         .name();
4588                         isCreateArtifact = exludeResourceType.stream()
4589                                         .noneMatch(e -> e.equalsIgnoreCase(resourceType));
4590                 }
4591                 if (informationalResourceArtifacts != null && isCreateArtifact) {
4592                         Set<String> keys = informationalResourceArtifacts.keySet();
4593                         for (String informationalResourceArtifactName : keys) {
4594                                 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalResourceArtifacts
4595                                                 .get(informationalResourceArtifactName);
4596                                 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4597                                                 resourceUniqueId, informationalResourceArtifactName, artifactInfoMap, user,
4598                                                 ArtifactGroupTypeEnum.INFORMATIONAL);
4599                                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4600
4601                         }
4602                 }
4603                 resource.setArtifacts(artifactMap);
4604         }
4605
4606         /**
4607          * deleteResource
4608          *
4609          * @param resourceId
4610          * @param user
4611          * @return
4612          */
4613         public ResponseFormat deleteResource(String resourceId, User user) {
4614                 ResponseFormat responseFormat;
4615                 validateUserExists(user);
4616
4617                 Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade.getToscaElement(resourceId);
4618                 if (resourceStatus.isRight()) {
4619                         log.debug("failed to get resource {}", resourceId);
4620                         return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4621                                         .value()), "");
4622                 }
4623
4624                 Resource resource = resourceStatus.left()
4625                                 .value();
4626
4627                 StorageOperationStatus result = StorageOperationStatus.OK;
4628                 lockComponent(resourceId, resource, "Mark resource to delete");
4629                 try {
4630
4631                         result = markComponentToDelete(resource);
4632                         if (result == StorageOperationStatus.OK) {
4633                                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4634                         } else {
4635                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4636                                 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4637                         }
4638                         return responseFormat;
4639
4640                 } finally {
4641                         if (result == null || result != StorageOperationStatus.OK) {
4642                                 janusGraphDao.rollback();
4643                         } else {
4644                 janusGraphDao.commit();
4645                         }
4646                         graphLockOperation.unlockComponent(resourceId, NodeTypeEnum.Resource);
4647                 }
4648
4649         }
4650
4651         public ResponseFormat deleteResourceByNameAndVersion(String resourceName, String version, User user) {
4652                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4653                 validateUserExists(user);
4654                 Resource resource = null;
4655                 StorageOperationStatus result = StorageOperationStatus.OK;
4656                 boolean failed = false;
4657                 try {
4658
4659                         Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade
4660                                         .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, version);
4661                         if (resourceStatus.isRight()) {
4662                                 log.debug("failed to get resource {} version {}", resourceName, version);
4663                                 return componentsUtils
4664                                                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4665                                                                 .value()), resourceName);
4666                         }
4667
4668                         resource = resourceStatus.left()
4669                                         .value();
4670
4671                 } finally {
4672                         janusGraphDao.commit();
4673                 }
4674                 if (resource != null) {
4675                         lockComponent(resource.getUniqueId(), resource, DELETE_RESOURCE);
4676                         try {
4677                                 result = markComponentToDelete(resource);
4678                                 if (result != StorageOperationStatus.OK) {
4679                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4680                                         responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4681                                         return responseFormat;
4682                                 }
4683                         }catch (ComponentException e){
4684                                 failed = true;
4685                                 throw e;
4686                         }finally {
4687                                 if (failed || result == null || result != StorageOperationStatus.OK) {
4688                                         janusGraphDao.rollback();
4689                                 } else {
4690                     janusGraphDao.commit();
4691                                 }
4692                                 graphLockOperation.unlockComponent(resource.getUniqueId(), NodeTypeEnum.Resource);
4693                         }
4694                 }
4695                 return responseFormat;
4696         }
4697
4698         public Either<Resource, ResponseFormat> getResource(String resourceId, User user) {
4699
4700                 if (user != null) {
4701                         validateUserExists(user);
4702                 }
4703
4704                 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(resourceId);
4705                 if (storageStatus.isRight()) {
4706                         log.debug("failed to get resource by id {}", resourceId);
4707                         return Either.right(componentsUtils
4708                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus.right()
4709                                                         .value()), resourceId));
4710                 }
4711                 if (!(storageStatus.left()
4712                                 .value() instanceof Resource)) {
4713                         return Either.right(componentsUtils.getResponseFormatByResource(
4714                                         componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), resourceId));
4715                 }
4716                 return Either.left(storageStatus.left()
4717                                 .value());
4718
4719         }
4720
4721         public Either<Resource, ResponseFormat> getResourceByNameAndVersion(String resourceName, String resourceVersion,
4722                                                                                                                                                 String userId) {
4723
4724                 validateUserExists(userId);
4725
4726                 Either<Resource, StorageOperationStatus> getResource = toscaOperationFacade
4727                                 .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion);
4728                 if (getResource.isRight()) {
4729                         log.debug("failed to get resource by name {} and version {}", resourceName, resourceVersion);
4730                         return Either.right(componentsUtils
4731                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResource.right()
4732                                                         .value()), resourceName));
4733                 }
4734                 return Either.left(getResource.left()
4735                                 .value());
4736         }
4737
4738         /**
4739          * updateResourceMetadata
4740          *
4741          * @param user
4742          *            - modifier data (userId)
4743          * @param inTransaction
4744          *            TODO
4745          * @param resourceIdToUpdate
4746          *            - the resource identifier
4747          * @param newResource
4748          * @return Either<Resource , responseFormat>
4749          */
4750         public Resource updateResourceMetadata(String resourceIdToUpdate, Resource newResource, Resource currentResource,
4751                                                                                    User user, boolean inTransaction) {
4752
4753                 validateUserExists(user.getUserId());
4754
4755                 log.debug("Get resource with id {}", resourceIdToUpdate);
4756                 boolean needToUnlock = false;
4757
4758                 try {
4759                         if (currentResource == null) {
4760                                 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade
4761                                                 .getToscaElement(resourceIdToUpdate);
4762                                 if (storageStatus.isRight()) {
4763                                         throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatByResource(
4764                                                         componentsUtils.convertFromStorageResponse(storageStatus.right()
4765                                                                         .value()),
4766                                                         ""));
4767                                 }
4768
4769                                 currentResource = storageStatus.left()
4770                                                 .value();
4771                         }
4772                         // verify that resource is checked-out and the user is the last
4773                         // updater
4774                         if (!ComponentValidationUtils.canWorkOnResource(currentResource, user.getUserId())) {
4775                                 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
4776                         }
4777
4778                         // lock resource
4779                         StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceIdToUpdate,
4780                                         NodeTypeEnum.Resource);
4781                         if (lockResult != StorageOperationStatus.OK) {
4782                                 BeEcompErrorManager.getInstance()
4783                                                 .logBeFailedLockObjectError("Upload Artifact - lock ", NodeTypeEnum.Resource.getName(),
4784                                                                 resourceIdToUpdate);
4785                                 log.debug("Failed to lock resource: {}, error - {}", resourceIdToUpdate, lockResult);
4786                                 ResponseFormat responseFormat = componentsUtils
4787                                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(lockResult));
4788                                 throw new ByResponseFormatComponentException(responseFormat);
4789                         }
4790
4791                         needToUnlock = true;
4792
4793                         // critical section starts here
4794                         // convert json to object
4795
4796                         // Update and updated resource must have a non-empty "derivedFrom"
4797                         // list
4798                         // This code is not called from import resources, because of root
4799                         // VF "derivedFrom" should be null (or ignored)
4800                         if (ModelConverter.isAtomicComponent(currentResource)) {
4801                                 validateDerivedFromNotEmpty(null, newResource, null);
4802                                 validateDerivedFromNotEmpty(null, currentResource, null);
4803                         } else {
4804                                 newResource.setDerivedFrom(null);
4805                         }
4806
4807             Either<Resource, ResponseFormat> dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource,
4808                     user, currentResource, false, true);
4809             if (dataModelResponse.isRight()) {
4810                 log.debug("failed to update resource metadata!!!");
4811                 throw new ByResponseFormatComponentException(dataModelResponse.right().value());
4812             }
4813
4814                         log.debug("Resource metadata updated successfully!!!");
4815                         return dataModelResponse.left()
4816                                         .value();
4817
4818                 } catch (ComponentException | StorageException e) {
4819                         rollback(inTransaction, newResource, null, null);
4820                         throw e;
4821                 } finally {
4822                         if (!inTransaction) {
4823                 janusGraphDao.commit();
4824                         }
4825                         if (needToUnlock) {
4826                                 graphLockOperation.unlockComponent(resourceIdToUpdate, NodeTypeEnum.Resource);
4827                         }
4828                 }
4829         }
4830
4831         private Either<Resource, ResponseFormat> updateResourceMetadata(String resourceIdToUpdate, Resource newResource,
4832                                                                                                                                         User user, Resource currentResource, boolean shouldLock, boolean inTransaction) {
4833                 updateVfModuleGroupsNames(currentResource, newResource);
4834                 validateResourceFieldsBeforeUpdate(currentResource, newResource, inTransaction, false);
4835                 // Setting last updater and uniqueId
4836                 newResource.setContactId(newResource.getContactId()
4837                                 .toLowerCase());
4838                 newResource.setLastUpdaterUserId(user.getUserId());
4839                 newResource.setUniqueId(resourceIdToUpdate);
4840                 // Cannot set highest version through UI
4841                 newResource.setHighestVersion(currentResource.isHighestVersion());
4842                 newResource.setCreationDate(currentResource.getCreationDate());
4843
4844                 Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom = processUpdateOfDerivedFrom(currentResource,
4845                                 newResource, user.getUserId(), inTransaction);
4846
4847                 if (processUpdateOfDerivedFrom.isRight()) {
4848                         log.debug("Couldn't update derived from for resource {}", resourceIdToUpdate);
4849                         return Either.right(processUpdateOfDerivedFrom.right()
4850                                         .value());
4851                 }
4852
4853                 log.debug("send resource {} to dao for update", newResource.getUniqueId());
4854                 if (isNotEmpty(newResource.getGroups())) {
4855                         for (GroupDefinition group : newResource.getGroups()) {
4856                                 if (DEFAULT_GROUP_VF_MODULE.equals(group.getType())) {
4857                                         groupBusinessLogic.validateAndUpdateGroupMetadata(newResource.getComponentMetadataDefinition()
4858                                                         .getMetadataDataDefinition()
4859                                                         .getUniqueId(), user, newResource.getComponentType(), group, true, false);
4860                                 }
4861                         }
4862                 }
4863                 Either<Resource, StorageOperationStatus> dataModelResponse = toscaOperationFacade
4864                                 .updateToscaElement(newResource);
4865
4866                 if (dataModelResponse.isRight()) {
4867                         ResponseFormat responseFormat = componentsUtils
4868                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
4869                                                         .value()), newResource);
4870                         return Either.right(responseFormat);
4871                 } else if (dataModelResponse.left()
4872                                 .value() == null) {
4873                         log.debug("No response from updateResource");
4874                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
4875                 }
4876                 return Either.left(dataModelResponse.left()
4877                                 .value());
4878         }
4879
4880         private void updateVfModuleGroupsNames(Resource currentResource, Resource newResource) {
4881                 if (currentResource.getGroups() != null && !currentResource.getName()
4882                                 .equals(newResource.getName())) {
4883                         List<GroupDefinition> updatedGroups = currentResource.getGroups()
4884                                         .stream()
4885                                         .map(group -> getUpdatedGroup(group, currentResource.getName(), newResource.getName()))
4886                                         .collect(toList());
4887                         newResource.setGroups(updatedGroups);
4888                 }
4889         }
4890
4891         private GroupDefinition getUpdatedGroup(GroupDefinition currGroup, String replacePattern, String with) {
4892                 GroupDefinition updatedGroup = new GroupDefinition(currGroup);
4893                 if (updatedGroup.isSamePrefix(replacePattern) && updatedGroup.getType()
4894                                 .equals(DEFAULT_GROUP_VF_MODULE)) {
4895                         String prefix = updatedGroup.getName()
4896                                         .substring(0, replacePattern.length());
4897                         String newGroupName = updatedGroup.getName()
4898                                         .replaceFirst(prefix, with);
4899                         updatedGroup.setName(newGroupName);
4900                 }
4901                 return updatedGroup;
4902         }
4903
4904         /**
4905          * validateResourceFieldsBeforeCreate
4906          *
4907          * @param user
4908          *            - modifier data (userId)
4909          */
4910         private void validateResourceFieldsBeforeCreate(User user, Resource resource,
4911                                                                                                         AuditingActionEnum actionEnum, boolean inTransaction) {
4912                 componentValidator.validate(user, resource, actionEnum);
4913                 // validate category
4914                 log.debug("validate category");
4915                 validateCategory(user, resource, actionEnum, inTransaction);
4916                 // validate vendor name & release & model number
4917                 log.debug("validate vendor name");
4918                 validateVendorName(user, resource, actionEnum);
4919                 log.debug("validate vendor release");
4920                 validateVendorReleaseName(user, resource, actionEnum);
4921                 log.debug("validate resource vendor model number");
4922                 validateResourceVendorModelNumber(user, resource, actionEnum);
4923                 // validate cost
4924                 log.debug("validate cost");
4925                 validateCost(resource);
4926                 // validate licenseType
4927                 log.debug("validate licenseType");
4928                 validateLicenseType(user, resource, actionEnum);
4929                 // validate template (derived from)
4930                 log.debug("validate derived from");
4931                 if (!ModelConverter.isAtomicComponent(resource) && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4932                         resource.setDerivedFrom(null);
4933                 }
4934                 validateDerivedFromExist(user, resource, actionEnum);
4935                 // warn about non-updatable fields
4936                 checkComponentFieldsForOverrideAttempt(resource);
4937                 String currentCreatorFullName = resource.getCreatorFullName();
4938                 if (currentCreatorFullName != null) {
4939                         log.debug("Resource Creator fullname is automatically set and cannot be updated");
4940                 }
4941
4942                 String currentLastUpdaterFullName = resource.getLastUpdaterFullName();
4943                 if (currentLastUpdaterFullName != null) {
4944                         log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
4945                 }
4946
4947                 Long currentLastUpdateDate = resource.getLastUpdateDate();
4948                 if (currentLastUpdateDate != null) {
4949                         log.debug("Resource last update date is automatically set and cannot be updated");
4950                 }
4951
4952                 Boolean currentAbstract = resource.isAbstract();
4953                 if (currentAbstract != null) {
4954                         log.debug("Resource abstract is automatically set and cannot be updated");
4955                 }
4956         }
4957
4958         /**
4959          * validateResourceFieldsBeforeUpdate
4960          *
4961          * @param currentResource
4962          *            - Resource object to validate
4963          * @param isNested
4964          */
4965         private void validateResourceFieldsBeforeUpdate(Resource currentResource, Resource updateInfoResource,
4966                                                                                                         boolean inTransaction, boolean isNested) {
4967                 validateFields(currentResource, updateInfoResource, inTransaction, isNested);
4968                 warnNonEditableFields(currentResource, updateInfoResource);
4969         }
4970
4971         private void warnNonEditableFields(Resource currentResource, Resource updateInfoResource) {
4972                 String currentResourceVersion = currentResource.getVersion();
4973                 String updatedResourceVersion = updateInfoResource.getVersion();
4974
4975                 if ((updatedResourceVersion != null) && (!updatedResourceVersion.equals(currentResourceVersion))) {
4976                         log.debug("Resource version is automatically set and cannot be updated");
4977                 }
4978
4979                 String currentCreatorUserId = currentResource.getCreatorUserId();
4980                 String updatedCreatorUserId = updateInfoResource.getCreatorUserId();
4981
4982                 if ((updatedCreatorUserId != null) && (!updatedCreatorUserId.equals(currentCreatorUserId))) {
4983                         log.debug("Resource Creator UserId is automatically set and cannot be updated");
4984                 }
4985
4986                 String currentCreatorFullName = currentResource.getCreatorFullName();
4987                 String updatedCreatorFullName = updateInfoResource.getCreatorFullName();
4988
4989                 if ((updatedCreatorFullName != null) && (!updatedCreatorFullName.equals(currentCreatorFullName))) {
4990                         log.debug("Resource Creator fullname is automatically set and cannot be updated");
4991                 }
4992
4993                 String currentLastUpdaterUserId = currentResource.getLastUpdaterUserId();
4994                 String updatedLastUpdaterUserId = updateInfoResource.getLastUpdaterUserId();
4995
4996                 if ((updatedLastUpdaterUserId != null) && (!updatedLastUpdaterUserId.equals(currentLastUpdaterUserId))) {
4997                         log.debug("Resource LastUpdater userId is automatically set and cannot be updated");
4998                 }
4999
5000                 String currentLastUpdaterFullName = currentResource.getLastUpdaterFullName();
5001                 String updatedLastUpdaterFullName = updateInfoResource.getLastUpdaterFullName();
5002
5003                 if ((updatedLastUpdaterFullName != null) && (!updatedLastUpdaterFullName.equals(currentLastUpdaterFullName))) {
5004                         log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
5005                 }
5006                 Long currentCreationDate = currentResource.getCreationDate();
5007                 Long updatedCreationDate = updateInfoResource.getCreationDate();
5008
5009                 if ((updatedCreationDate != null) && (!updatedCreationDate.equals(currentCreationDate))) {
5010                         log.debug("Resource Creation date is automatically set and cannot be updated");
5011                 }
5012
5013                 Long currentLastUpdateDate = currentResource.getLastUpdateDate();
5014                 Long updatedLastUpdateDate = updateInfoResource.getLastUpdateDate();
5015
5016                 if ((updatedLastUpdateDate != null) && (!updatedLastUpdateDate.equals(currentLastUpdateDate))) {
5017                         log.debug("Resource last update date is automatically set and cannot be updated");
5018                 }
5019
5020                 LifecycleStateEnum currentLifecycleState = currentResource.getLifecycleState();
5021                 LifecycleStateEnum updatedLifecycleState = updateInfoResource.getLifecycleState();
5022
5023                 if ((updatedLifecycleState != null) && (!updatedLifecycleState.equals(currentLifecycleState))) {
5024                         log.debug("Resource lifecycle state date is automatically set and cannot be updated");
5025                 }
5026
5027                 Boolean currentAbstract = currentResource.isAbstract();
5028                 Boolean updatedAbstract = updateInfoResource.isAbstract();
5029
5030                 if ((updatedAbstract != null) && (!updatedAbstract.equals(currentAbstract))) {
5031                         log.debug("Resource abstract is automatically set and cannot be updated");
5032                 }
5033
5034                 Boolean currentHighestVersion = currentResource.isHighestVersion();
5035                 Boolean updatedHighestVersion = updateInfoResource.isHighestVersion();
5036
5037                 if ((updatedHighestVersion != null) && (!updatedHighestVersion.equals(currentHighestVersion))) {
5038                         log.debug("Resource highest version is automatically set and cannot be updated");
5039                 }
5040
5041                 String currentUuid = currentResource.getUUID();
5042                 String updatedUuid = updateInfoResource.getUUID();
5043
5044                 if ((updatedUuid != null) && (!updatedUuid.equals(currentUuid))) {
5045                         log.debug("Resource UUID is automatically set and cannot be updated");
5046                 }
5047
5048                 log.debug("Resource Type  cannot be updated");
5049                 String currentInvariantUuid = currentResource.getInvariantUUID();
5050                 String updatedInvariantUuid = updateInfoResource.getInvariantUUID();
5051
5052                 if ((updatedInvariantUuid != null) && (!updatedInvariantUuid.equals(currentInvariantUuid))) {
5053                         log.debug("Resource invariant UUID is automatically set and cannot be updated");
5054                         updateInfoResource.setInvariantUUID(currentInvariantUuid);
5055                 }
5056         }
5057
5058         private void validateFields(Resource currentResource, Resource updateInfoResource, boolean inTransaction,
5059                                                                 boolean isNested) {
5060                 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentResource.getVersion());
5061                 log.debug("validate resource name before update");
5062                 validateResourceName(currentResource, updateInfoResource, hasBeenCertified, isNested);
5063                 log.debug("validate description before update");
5064                 componentDescriptionValidator.validateAndCorrectField(null, updateInfoResource, null);
5065                 log.debug("validate icon before update");
5066                 validateIcon(currentResource, updateInfoResource, hasBeenCertified);
5067                 log.debug("validate tags before update");
5068                 componentTagsValidator.validateAndCorrectField(null, updateInfoResource, null);
5069                 log.debug("validate vendor name before update");
5070                 validateVendorName(null, updateInfoResource, null);
5071                 log.debug("validate resource vendor model number before update");
5072                 validateResourceVendorModelNumber(currentResource, updateInfoResource);
5073                 log.debug("validate vendor release before update");
5074                 validateVendorReleaseName(null, updateInfoResource, null);
5075                 log.debug("validate contact info before update");
5076                 componentContactIdValidator.validateAndCorrectField(null, updateInfoResource, null);
5077                 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
5078                 validateDerivedFromDuringUpdate(currentResource, updateInfoResource, hasBeenCertified);
5079                 log.debug("validate category before update");
5080                 validateCategory(currentResource, updateInfoResource, hasBeenCertified, inTransaction);
5081         }
5082
5083         private boolean isResourceNameEquals(Resource currentResource, Resource updateInfoResource) {
5084                 String resourceNameUpdated = updateInfoResource.getName();
5085                 String resourceNameCurrent = currentResource.getName();
5086                 if (resourceNameCurrent.equals(resourceNameUpdated)) {
5087                         return true;
5088                 }
5089                 // In case of CVFC type we should support the case of old VF with CVFC
5090                 // instances that were created without the "Cvfc" suffix
5091                 return currentResource.getResourceType() == ResourceTypeEnum.CVFC
5092                                 && resourceNameUpdated.equals(addCvfcSuffixToResourceName(resourceNameCurrent));
5093         }
5094
5095         private String addCvfcSuffixToResourceName(String resourceName) {
5096                 return resourceName + "Cvfc";
5097         }
5098
5099         private void validateResourceName(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified,
5100                                                                           boolean isNested) {
5101                 String resourceNameUpdated = updateInfoResource.getName();
5102                 if (!isResourceNameEquals(currentResource, updateInfoResource)) {
5103                         if (isNested || !hasBeenCertified) {
5104                                 componentNameValidator.validateAndCorrectField(null, updateInfoResource, null);
5105                                 validateResourceNameUniqueness(updateInfoResource);
5106                                 currentResource.setName(resourceNameUpdated);
5107                                 currentResource.setNormalizedName(ValidationUtils.normaliseComponentName(resourceNameUpdated));
5108                                 currentResource.setSystemName(ValidationUtils.convertToSystemName(resourceNameUpdated));
5109
5110                         } else {
5111                                 log.info("Resource name: {}, cannot be updated once the resource has been certified once.",
5112                                                 resourceNameUpdated);
5113                                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
5114                         }
5115                 }
5116         }
5117
5118         private void validateIcon(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) {
5119                 String iconUpdated = updateInfoResource.getIcon();
5120                 String iconCurrent = currentResource.getIcon();
5121                 if (!iconCurrent.equals(iconUpdated)) {
5122                         if (!hasBeenCertified) {
5123                                 componentIconValidator.validateAndCorrectField(null, updateInfoResource, null);
5124                         } else {
5125                                 log.info("Icon {} cannot be updated once the resource has been certified once.", iconUpdated);
5126                                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
5127                         }
5128                 }
5129         }
5130
5131         private void validateResourceVendorModelNumber(Resource currentResource, Resource updateInfoResource) {
5132                 String updatedResourceVendorModelNumber = updateInfoResource.getResourceVendorModelNumber();
5133                 String currentResourceVendorModelNumber = currentResource.getResourceVendorModelNumber();
5134                 if (!currentResourceVendorModelNumber.equals(updatedResourceVendorModelNumber)) {
5135                         validateResourceVendorModelNumber(null, updateInfoResource, null);
5136                 }
5137         }
5138
5139         private Either<Boolean, ResponseFormat> validateCategory(Resource currentResource, Resource updateInfoResource,
5140                                                                                                                          boolean hasBeenCertified, boolean inTransaction) {
5141                 validateCategory(null, updateInfoResource, null, inTransaction);
5142                 if (hasBeenCertified) {
5143                         CategoryDefinition currentCategory = currentResource.getCategories()
5144                                         .get(0);
5145                         SubCategoryDefinition currentSubCategory = currentCategory.getSubcategories()
5146                                         .get(0);
5147                         CategoryDefinition updateCategory = updateInfoResource.getCategories()
5148                                         .get(0);
5149                         SubCategoryDefinition updtaeSubCategory = updateCategory.getSubcategories()
5150                                         .get(0);
5151                         if (!currentCategory.getName()
5152                                         .equals(updateCategory.getName())
5153                                         || !currentSubCategory.getName()
5154                                         .equals(updtaeSubCategory.getName())) {
5155                                 log.info("Category {} cannot be updated once the resource has been certified once.",
5156                                                 currentResource.getCategories());
5157                                 ResponseFormat errorResponse = componentsUtils
5158                                                 .getResponseFormat(ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
5159                                 return Either.right(errorResponse);
5160                         }
5161                 }
5162                 return Either.left(true);
5163         }
5164
5165         private Either<Boolean, ResponseFormat> validateDerivedFromDuringUpdate(Resource currentResource,
5166                                                                                                                                                         Resource updateInfoResource, boolean hasBeenCertified) {
5167
5168                 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5169                 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5170                 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5171                                 || updatedDerivedFrom.isEmpty()) {
5172                         log.trace("Update normative types");
5173                         return Either.left(true);
5174                 }
5175
5176                 String derivedFromCurrent = currentDerivedFrom.get(0);
5177                 String derivedFromUpdated = updatedDerivedFrom.get(0);
5178
5179                 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5180                         if (!hasBeenCertified) {
5181                                 validateDerivedFromExist(null, updateInfoResource, null);
5182                         } else {
5183                                 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5184                                                 currentResource, updateInfoResource, null);
5185
5186                                 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5187                                                 .value()) {
5188                                         log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5189                                         return validateDerivedFromExtending;
5190                                 }
5191                         }
5192                 } else {
5193                         // For derived from, we must know whether it was actually changed,
5194                         // otherwise we must do no action.
5195                         // Due to changes it inflicts on data model (remove artifacts,
5196                         // properties...), it's not like a flat field which can be
5197                         // overwritten if not changed.
5198                         // So we must indicate that derived from is not changed
5199                         updateInfoResource.setDerivedFrom(null);
5200                 }
5201                 return Either.left(true);
5202         }
5203
5204         private Either<Boolean, ResponseFormat> validateNestedDerivedFromDuringUpdate(Resource currentResource,
5205                                                                                                                                                                   Resource updateInfoResource, boolean hasBeenCertified) {
5206
5207                 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5208                 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5209                 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5210                                 || updatedDerivedFrom.isEmpty()) {
5211                         log.trace("Update normative types");
5212                         return Either.left(true);
5213                 }
5214
5215                 String derivedFromCurrent = currentDerivedFrom.get(0);
5216                 String derivedFromUpdated = updatedDerivedFrom.get(0);
5217
5218                 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5219                         if (!hasBeenCertified) {
5220                                 validateDerivedFromExist(null, updateInfoResource, null);
5221                         } else {
5222                                 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5223                                                 currentResource, updateInfoResource, null);
5224
5225                                 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5226                                                 .value()) {
5227                                         log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5228                                         return validateDerivedFromExtending;
5229                                 }
5230                         }
5231                 }
5232                 return Either.left(true);
5233         }
5234
5235         private void validateDerivedFromExist(User user, Resource resource, AuditingActionEnum actionEnum) {
5236                 if (resource.getDerivedFrom() == null || resource.getDerivedFrom()
5237                                 .isEmpty()) {
5238                         return;
5239                 }
5240                 String templateName = resource.getDerivedFrom()
5241                                 .get(0);
5242                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5243                                 .validateToscaResourceNameExists(templateName);
5244                 if (dataModelResponse.isRight()) {
5245                         StorageOperationStatus storageStatus = dataModelResponse.right()
5246                                         .value();
5247                         BeEcompErrorManager.getInstance()
5248                                         .logBeDaoSystemError("Create Resource - validateDerivedFromExist");
5249                         log.debug("request to data model failed with error: {}", storageStatus);
5250                         ResponseFormat responseFormat = componentsUtils
5251                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus), resource);
5252                         log.trace("audit before sending response");
5253                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5254                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus));
5255                 } else if (!dataModelResponse.left()
5256                                 .value()) {
5257                         log.info("resource template with name: {}, does not exists", templateName);
5258                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5259                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5260                         throw new ByActionStatusComponentException(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5261                 }
5262         }
5263
5264         // Tal G for extending inheritance US815447
5265         private Either<Boolean, ResponseFormat> validateDerivedFromExtending(User user, Resource currentResource,
5266                                                                                                                                                  Resource updateInfoResource, AuditingActionEnum actionEnum) {
5267                 String currentTemplateName = currentResource.getDerivedFrom()
5268                                 .get(0);
5269                 String updatedTemplateName = updateInfoResource.getDerivedFrom()
5270                                 .get(0);
5271
5272                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5273                                 .validateToscaResourceNameExtends(currentTemplateName, updatedTemplateName);
5274                 if (dataModelResponse.isRight()) {
5275                         StorageOperationStatus storageStatus = dataModelResponse.right()
5276                                         .value();
5277                         BeEcompErrorManager.getInstance()
5278                                         .logBeDaoSystemError("Create/Update Resource - validateDerivingFromExtendingType");
5279                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
5280                                         componentsUtils.convertFromStorageResponse(storageStatus), currentResource);
5281                         log.trace("audit before sending response");
5282                         componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5283                         return Either.right(responseFormat);
5284                 }
5285
5286                 if (!dataModelResponse.left()
5287                                 .value()) {
5288                         log.info("resource template with name {} does not inherit as original {}", updatedTemplateName,
5289                                         currentTemplateName);
5290                         ResponseFormat responseFormat = componentsUtils
5291                                         .getResponseFormat(ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
5292                         componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5293
5294                         return Either.right(responseFormat);
5295
5296                 }
5297                 return Either.left(true);
5298         }
5299
5300         public void validateDerivedFromNotEmpty(User user, Resource resource, AuditingActionEnum actionEnum) {
5301                 log.debug("validate resource derivedFrom field");
5302                 if ((resource.getDerivedFrom() == null) || (resource.getDerivedFrom()
5303                                 .isEmpty())
5304                                 || (resource.getDerivedFrom()
5305                                 .get(0)) == null
5306                                 || (resource.getDerivedFrom()
5307                                 .get(0)
5308                                 .trim()
5309                                 .isEmpty())) {
5310                         log.info("derived from (template) field is missing for the resource");
5311                         ResponseFormat responseFormat = componentsUtils
5312                                         .getResponseFormat(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5313                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5314
5315                         throw new ByActionStatusComponentException(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5316                 }
5317         }
5318
5319         private void validateResourceNameUniqueness(Resource resource) {
5320
5321                 Either<Boolean, StorageOperationStatus> resourceOperationResponse = toscaOperationFacade
5322                                 .validateComponentNameExists(resource.getName(), resource.getResourceType(),
5323                                                 resource.getComponentType());
5324                 if (resourceOperationResponse.isLeft() && resourceOperationResponse.left()
5325                                 .value()) {
5326                         log.debug("resource with name: {}, already exists", resource.getName());
5327                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
5328                                         ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
5329                 } else if (resourceOperationResponse.isRight()) {
5330                         log.debug("error while validateResourceNameExists for resource: {}", resource.getName());
5331                         throw new StorageException(resourceOperationResponse.right()
5332                                         .value());
5333                 }
5334         }
5335
5336         private void validateCategory(User user, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5337
5338                 List<CategoryDefinition> categories = resource.getCategories();
5339                 if (CollectionUtils.isEmpty(categories)) {
5340                         log.debug(CATEGORY_IS_EMPTY);
5341                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5342                                         ComponentTypeEnum.RESOURCE.getValue());
5343                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5344                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5345                                         ComponentTypeEnum.RESOURCE.getValue());
5346                 }
5347                 if (categories.size() > 1) {
5348                         log.debug("Must be only one category for resource");
5349                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_TOO_MUCH_CATEGORIES,
5350                                         ComponentTypeEnum.RESOURCE.getValue());
5351                 }
5352                 CategoryDefinition category = categories.get(0);
5353                 List<SubCategoryDefinition> subcategories = category.getSubcategories();
5354                 if (CollectionUtils.isEmpty(subcategories)) {
5355                         log.debug("Missinig subcategory for resource");
5356                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY);
5357                 }
5358                 if (subcategories.size() > 1) {
5359                         log.debug("Must be only one sub category for resource");
5360                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_TOO_MUCH_SUBCATEGORIES);
5361                 }
5362
5363                 SubCategoryDefinition subcategory = subcategories.get(0);
5364
5365                 if (!ValidationUtils.validateStringNotEmpty(category.getName())) {
5366                         log.debug(CATEGORY_IS_EMPTY);
5367                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5368                                         ComponentTypeEnum.RESOURCE.getValue());
5369                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5370                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5371                                         ComponentTypeEnum.RESOURCE.getValue());
5372                 }
5373                 if (!ValidationUtils.validateStringNotEmpty(subcategory.getName())) {
5374                         log.debug(CATEGORY_IS_EMPTY);
5375                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(
5376                                         ActionStatus.COMPONENT_MISSING_SUBCATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5377                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5378                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY,
5379                                         ComponentTypeEnum.RESOURCE.getValue());
5380                 }
5381
5382                 validateCategoryListed(category, subcategory, user, resource, actionEnum, inTransaction);
5383         }
5384
5385         private void validateCategoryListed(CategoryDefinition category, SubCategoryDefinition subcategory, User user,
5386                                                                                 Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5387                 ResponseFormat responseFormat;
5388                 if (category != null && subcategory != null) {
5389                         log.debug("validating resource category {} against valid categories list", category);
5390                         Either<List<CategoryDefinition>, ActionStatus> categories = elementDao
5391                                         .getAllCategories(NodeTypeEnum.ResourceNewCategory, inTransaction);
5392                         if (categories.isRight()) {
5393                                 log.debug("failed to retrieve resource categories from JanusGraph");
5394                                 responseFormat = componentsUtils.getResponseFormat(categories.right()
5395                                                 .value());
5396                                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5397                                 throw new ByActionStatusComponentException(categories.right()
5398                                                 .value());
5399                         }
5400                         List<CategoryDefinition> categoryList = categories.left()
5401                                         .value();
5402                         Optional<CategoryDefinition> foundCategory = categoryList.stream()
5403                                         .filter(cat -> cat.getName()
5404                                                         .equals(category.getName()))
5405                                         .findFirst();
5406                         if (!foundCategory.isPresent()) {
5407                                 log.debug("Category {} is not part of resource category group. Resource category valid values are {}",
5408                                                 category, categoryList);
5409                                 failOnInvalidCategory(user, resource, actionEnum);
5410                         }
5411                         Optional<SubCategoryDefinition> foundSubcategory = foundCategory.get()
5412                                         .getSubcategories()
5413                                         .stream()
5414                                         .filter(subcat -> subcat.getName()
5415                                                         .equals(subcategory.getName()))
5416                                         .findFirst();
5417                         if (!foundSubcategory.isPresent()) {
5418                                 log.debug(
5419                                                 "SubCategory {} is not part of resource category group. Resource subcategory valid values are {}",
5420                                                 subcategory, foundCategory.get()
5421                                                                 .getSubcategories());
5422                                 failOnInvalidCategory(user, resource, actionEnum);
5423                         }
5424                 }
5425         }
5426
5427         private void failOnInvalidCategory(User user, Resource resource, AuditingActionEnum actionEnum) {
5428                 ResponseFormat responseFormat;
5429                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY,
5430                                 ComponentTypeEnum.RESOURCE.getValue());
5431                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5432                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5433         }
5434
5435         public void validateVendorReleaseName(User user, Resource resource, AuditingActionEnum actionEnum) {
5436                 String vendorRelease = resource.getVendorRelease();
5437                 log.debug("validate vendor relese name");
5438                 if (!ValidationUtils.validateStringNotEmpty(vendorRelease)) {
5439                         log.info("vendor relese name is missing.");
5440                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_RELEASE);
5441                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5442                         throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_RELEASE);
5443                 }
5444
5445                 validateVendorReleaseName(vendorRelease, user, resource, actionEnum);
5446         }
5447
5448         public void validateVendorReleaseName(String vendorRelease, User user, Resource resource,
5449                                                                                   AuditingActionEnum actionEnum) {
5450                 if (vendorRelease != null) {
5451                         if (!ValidationUtils.validateVendorReleaseLength(vendorRelease)) {
5452                                 log.info("vendor release exceds limit.");
5453                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5454                                                 ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5455                                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5456                                 throw new ByActionStatusComponentException(ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT,
5457                                                 "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5458                         }
5459
5460                         if (!ValidationUtils.validateVendorRelease(vendorRelease)) {
5461                                 log.info("vendor release  is not valid.");
5462                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_RELEASE);
5463                                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5464                 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_RELEASE, vendorRelease);
5465             }
5466         }
5467     }
5468
5469     private void validateVendorName(User user, Resource resource,
5470                                     AuditingActionEnum actionEnum) {
5471         String vendorName = resource.getVendorName();
5472         if (!ValidationUtils.validateStringNotEmpty(vendorName)) {
5473             log.info("vendor name is missing.");
5474             ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_NAME);
5475             componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5476             throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_NAME);
5477         }
5478         validateVendorName(vendorName, user, resource, actionEnum);
5479     }
5480
5481     private void validateVendorName(String vendorName, User user, Resource resource,
5482                                     AuditingActionEnum actionEnum) {
5483         if (vendorName != null) {
5484             if (!ValidationUtils.validateVendorNameLength(vendorName)) {
5485                 log.info("vendor name exceds limit.");
5486                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5487                         "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5488                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5489                 throw new ByActionStatusComponentException(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5490                         "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5491             }
5492
5493             if (!ValidationUtils.validateVendorName(vendorName)) {
5494                 log.info("vendor name  is not valid.");
5495                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_NAME);
5496                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5497                 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_NAME, vendorName);
5498             }
5499         }
5500     }
5501
5502     private void validateResourceVendorModelNumber(User user, Resource resource, AuditingActionEnum actionEnum) {
5503         String resourceVendorModelNumber = resource.getResourceVendorModelNumber();
5504         if (StringUtils.isNotEmpty(resourceVendorModelNumber)) {
5505             if (!ValidationUtils.validateResourceVendorModelNumberLength(resourceVendorModelNumber)) {
5506                 log.info("resource vendor model number exceeds limit.");
5507                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5508                         ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5509                         "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5510                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5511                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5512                         "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5513             }
5514             // resource vendor model number is currently validated as vendor
5515             // name
5516             if (!ValidationUtils.validateVendorName(resourceVendorModelNumber)) {
5517                 log.info("resource vendor model number  is not valid.");
5518                 ResponseFormat errorResponse = componentsUtils
5519                         .getResponseFormat(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5520                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5521                 throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5522             }
5523         }
5524     }
5525
5526
5527     private void validateCost(Resource resource) {
5528         String cost = resource.getCost();
5529         if (cost != null) {
5530             if (!ValidationUtils.validateCost(cost)) {
5531                 log.debug("resource cost is invalid.");
5532                 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5533             }
5534         }
5535     }
5536
5537     private void validateLicenseType(User user, Resource resource,
5538                                      AuditingActionEnum actionEnum) {
5539         log.debug("validate licenseType");
5540         String licenseType = resource.getLicenseType();
5541         if (licenseType != null) {
5542             List<String> licenseTypes = ConfigurationManager.getConfigurationManager().getConfiguration()
5543                     .getLicenseTypes();
5544             if (!licenseTypes.contains(licenseType)) {
5545                 log.debug("License type {} isn't configured", licenseType);
5546                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
5547                 if (actionEnum != null) {
5548                     // In update case, no audit is required
5549                     componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5550                 }
5551                 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5552             }
5553         }
5554     }
5555
5556         private Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom(Resource currentResource,
5557                                                                                                                                            Resource updatedResource, String userId, boolean inTransaction) {
5558                 if (updatedResource.getDerivedFrom() != null) {
5559                         log.debug("Starting derived from update for resource {}", updatedResource.getUniqueId());
5560                         log.debug("1. Removing interface artifacts from graph");
5561                         // Remove all interface artifacts of resource
5562                         String resourceId = updatedResource.getUniqueId();
5563                         Map<String, InterfaceDefinition> interfaces = currentResource.getInterfaces();
5564
5565                         if (interfaces != null) {
5566                                 Collection<InterfaceDefinition> values = interfaces.values();
5567                                 for (InterfaceDefinition interfaceDefinition : values) {
5568                                         String interfaceType = interfaceTypeOperation.getShortInterfaceName(interfaceDefinition);
5569
5570                                         log.trace("Starting interface artifacts removal for interface type {}", interfaceType);
5571                                         Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
5572                                         if (operations != null) {
5573                                                 for (Entry<String, Operation> operationEntry : operations.entrySet()) {
5574                                                         Operation operation = operationEntry.getValue();
5575                                                         ArtifactDefinition implementation = operation.getImplementationArtifact();
5576                                                         if (implementation != null) {
5577                                                                 String uniqueId = implementation.getUniqueId();
5578                                                                 log.debug("Removing interface artifact definition {}, operation {}, interfaceType {}",
5579                                                                                 uniqueId, operationEntry.getKey(), interfaceType);
5580                                                                 // only thing that transacts and locks here
5581                                                                 Either<ArtifactDefinition, ResponseFormat> deleteArtifactByInterface =
5582                                                                         artifactsBusinessLogic.deleteArtifactByInterface(resourceId, userId, uniqueId, true);
5583                                                                 if (deleteArtifactByInterface.isRight()) {
5584                                                                         log.debug("Couldn't remove artifact definition with id {}", uniqueId);
5585                                                                         if (!inTransaction) {
5586                                                                                 janusGraphDao.rollback();
5587                                                                         }
5588                                                                         return Either.right(deleteArtifactByInterface.right()
5589                                                                                         .value());
5590                                                                 }
5591                                                         } else {
5592                                                                 log.trace("No implementation found for operation {} - nothing to delete",
5593                                                                                 operationEntry.getKey());
5594                                                         }
5595                                                 }
5596                                         } else {
5597                                                 log.trace("No operations found for interface type {}", interfaceType);
5598                                         }
5599                                 }
5600                         }
5601                         log.debug("2. Removing properties");
5602                         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = propertyOperation
5603                                         .deleteAllPropertiesAssociatedToNode(NodeTypeEnum.Resource, resourceId);
5604
5605                         if (findPropertiesOfNode.isRight() && findPropertiesOfNode.right().value() != StorageOperationStatus.OK) {
5606                                 log.debug("Failed to remove all properties of resource");
5607                                 if (!inTransaction) {
5608                     janusGraphDao.rollback();
5609                                 }
5610                                 return Either.right(componentsUtils
5611                                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(findPropertiesOfNode.right()
5612                                                                 .value())));
5613                         }
5614
5615                 } else {
5616                         log.debug("Derived from wasn't changed during update");
5617                 }
5618
5619                 if (inTransaction) {
5620                         return Either.left(true);
5621                 }
5622         janusGraphDao.commit();
5623                 return Either.left(true);
5624
5625         }
5626
5627         /**** Auditing *******************/
5628
5629         protected static IElementOperation getElementDao(Class<IElementOperation> class1, ServletContext context) {
5630                 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
5631                                 .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
5632
5633                 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
5634
5635                 return webApplicationContext.getBean(class1);
5636         }
5637
5638         public ICapabilityTypeOperation getCapabilityTypeOperation() {
5639                 return capabilityTypeOperation;
5640         }
5641
5642         @Autowired
5643         public void setCapabilityTypeOperation(ICapabilityTypeOperation capabilityTypeOperation) {
5644                 this.capabilityTypeOperation = capabilityTypeOperation;
5645         }
5646
5647         public Boolean validatePropertiesDefaultValues(Resource resource) {
5648                 log.debug("validate resource properties default values");
5649                 List<PropertyDefinition> properties = resource.getProperties();
5650                 if (properties != null) {
5651                         iterateOverProperties(properties);
5652                 }
5653                 return true;
5654         }
5655
5656         public void iterateOverProperties(List<PropertyDefinition> properties) {
5657                 String type = null;
5658                 String innerType = null;
5659                 for (PropertyDefinition property : properties) {
5660                         if (!propertyOperation.isPropertyTypeValid(property)) {
5661                                 log.info("Invalid type for property {}", property);
5662                                 throw new ByActionStatusComponentException(ActionStatus.INVALID_PROPERTY_TYPE,
5663                                                 property.getType(), property.getName());
5664                         }
5665
5666                         Map<String, DataTypeDefinition> allDataTypes = getAllDataTypes(applicationDataTypeCache);
5667                         type = property.getType();
5668
5669                         if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5670                                 ResponseFormat responseFormat = validateMapOrListPropertyType(property, innerType, allDataTypes);
5671                                 if (responseFormat != null) {
5672                                         break;
5673                                 }
5674                         }
5675                         validateDefaultPropertyValue(property, allDataTypes, type, innerType);
5676                 }
5677         }
5678
5679         private void validateDefaultPropertyValue(PropertyDefinition property,
5680                                                                                           Map<String, DataTypeDefinition> allDataTypes, String type, String innerType) {
5681                 if (!propertyOperation.isPropertyDefaultValueValid(property, allDataTypes)) {
5682                         log.info("Invalid default value for property {}", property);
5683                         ResponseFormat responseFormat;
5684                         if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5685                                 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE,
5686                                                 property.getName(), type, innerType, property.getDefaultValue());
5687                         }
5688                         throw new ByActionStatusComponentException(ActionStatus.INVALID_DEFAULT_VALUE,
5689                                         property.getName(), type, property.getDefaultValue());
5690                 }
5691         }
5692
5693         private ResponseFormat validateMapOrListPropertyType(PropertyDefinition property, String innerType,
5694                                                                                                                  Map<String, DataTypeDefinition> allDataTypes) {
5695                 ResponseFormat responseFormat = null;
5696                 ImmutablePair<String, Boolean> propertyInnerTypeValid = propertyOperation.isPropertyInnerTypeValid(property,
5697                                 allDataTypes);
5698                 innerType = propertyInnerTypeValid.getLeft();
5699                 if (!propertyInnerTypeValid.getRight()
5700                                 .booleanValue()) {
5701                         log.info("Invalid inner type for property {}", property);
5702                         responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_PROPERTY_INNER_TYPE, innerType,
5703                                         property.getName());
5704                 }
5705                 return responseFormat;
5706         }
5707
5708         @Override
5709         public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
5710                 return deleteMarkedComponents(ComponentTypeEnum.RESOURCE);
5711         }
5712
5713         @Override
5714         public ComponentInstanceBusinessLogic getComponentInstanceBL() {
5715                 return componentInstanceBusinessLogic;
5716         }
5717
5718         private String getComponentTypeForResponse(Component component) {
5719                 String componentTypeForResponse = "SERVICE";
5720                 if (component instanceof Resource) {
5721                         componentTypeForResponse = ((Resource) component).getResourceType()
5722                                         .name();
5723                 }
5724                 return componentTypeForResponse;
5725         }
5726
5727         public Either<Resource, ResponseFormat> getLatestResourceFromCsarUuid(String csarUuid, User user) {
5728                 // validate user
5729                 if (user != null) {
5730                         validateUserExists(user);
5731                 }
5732                 // get resource from csar uuid
5733                 Either<Resource, StorageOperationStatus> either = toscaOperationFacade
5734                                 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUuid, "");
5735                 if (either.isRight()) {
5736                         ResponseFormat resp = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND,
5737                                         csarUuid);
5738                         return Either.right(resp);
5739                 }
5740
5741                 return Either.left(either.left()
5742                                 .value());
5743         }
5744
5745         @Override
5746         public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(
5747                         String componentId, String userId) {
5748                 return null;
5749         }
5750
5751         private Map<String, List<CapabilityDefinition>> getValidComponentInstanceCapabilities(String resourceId,
5752                                                                                                                                                                                   Map<String, List<CapabilityDefinition>> defaultCapabilities,
5753                                                                                                                                                                                   Map<String, List<UploadCapInfo>> uploadedCapabilities) {
5754
5755                 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
5756                 uploadedCapabilities.forEach((k, v) -> addValidComponentInstanceCapabilities(k, v, resourceId,
5757                                 defaultCapabilities, validCapabilitiesMap));
5758                 return validCapabilitiesMap;
5759         }
5760
5761         private void addValidComponentInstanceCapabilities(String key, List<UploadCapInfo> capabilities, String resourceId,
5762                                                                                                            Map<String, List<CapabilityDefinition>> defaultCapabilities,
5763                                                                                                            Map<String, List<CapabilityDefinition>> validCapabilitiesMap) {
5764                 String capabilityType = capabilities.get(0)
5765                                 .getType();
5766                 if (defaultCapabilities.containsKey(capabilityType)) {
5767                         CapabilityDefinition defaultCapability = getCapability(resourceId, defaultCapabilities, capabilityType);
5768                         validateCapabilityProperties(capabilities, resourceId, defaultCapability);
5769                         List<CapabilityDefinition> validCapabilityList = new ArrayList<>();
5770                         validCapabilityList.add(defaultCapability);
5771                         validCapabilitiesMap.put(key, validCapabilityList);
5772                 } else {
5773                         throw new ByActionStatusComponentException(ActionStatus.MISSING_CAPABILITY_TYPE, capabilityType);
5774                 }
5775         }
5776
5777         private void validateCapabilityProperties(List<UploadCapInfo> capabilities, String resourceId,
5778                                                                                           CapabilityDefinition defaultCapability) {
5779                 if (CollectionUtils.isEmpty(defaultCapability.getProperties()) && isNotEmpty(capabilities.get(0)
5780                                 .getProperties())) {
5781                         log.debug("Failed to validate capability {} of component {}. Property list is empty. ",
5782                                         defaultCapability.getName(), resourceId);
5783                         log.debug("Failed to update capability property values. Property list of fetched capability {} is empty. ",
5784                                         defaultCapability.getName());
5785                         throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, resourceId);
5786                 } else if (isNotEmpty(capabilities.get(0)
5787                                 .getProperties())) {
5788                         validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, capabilities.get(0));
5789                 }
5790         }
5791
5792         private CapabilityDefinition getCapability(String resourceId,
5793                                                                                            Map<String, List<CapabilityDefinition>> defaultCapabilities, String capabilityType) {
5794                 CapabilityDefinition defaultCapability;
5795                 if (isNotEmpty(defaultCapabilities.get(capabilityType)
5796                                 .get(0)
5797                                 .getProperties())) {
5798                         defaultCapability = defaultCapabilities.get(capabilityType)
5799                                         .get(0);
5800                 } else {
5801                         Either<Component, StorageOperationStatus> getFullComponentRes = toscaOperationFacade
5802                                         .getToscaFullElement(resourceId);
5803                         if (getFullComponentRes.isRight()) {
5804                                 log.debug("Failed to get full component {}. Status is {}. ", resourceId, getFullComponentRes.right()
5805                                                 .value());
5806                                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NOT_FOUND, resourceId);
5807                         }
5808                         defaultCapability = getFullComponentRes.left()
5809                                         .value()
5810                                         .getCapabilities()
5811                                         .get(capabilityType)
5812                                         .get(0);
5813                 }
5814                 return defaultCapability;
5815         }
5816
5817         private void validateUniquenessUpdateUploadedComponentInstanceCapability(CapabilityDefinition defaultCapability,
5818                                                                                                                                                          UploadCapInfo uploadedCapability) {
5819                 List<ComponentInstanceProperty> validProperties = new ArrayList<>();
5820                 Map<String, PropertyDefinition> defaultProperties = defaultCapability.getProperties()
5821                                 .stream()
5822                                 .collect(toMap(PropertyDefinition::getName, Function.identity()));
5823                 List<UploadPropInfo> uploadedProperties = uploadedCapability.getProperties();
5824                 for (UploadPropInfo property : uploadedProperties) {
5825                         String propertyName = property.getName()
5826                                         .toLowerCase();
5827                         String propertyType = property.getType();
5828                         ComponentInstanceProperty validProperty;
5829                         if (defaultProperties.containsKey(propertyName)
5830                                         && propertTypeEqualsTo(defaultProperties, propertyName, propertyType)) {
5831                                 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS, propertyName);
5832                         }
5833                         validProperty = new ComponentInstanceProperty();
5834                         validProperty.setName(propertyName);
5835                         if (property.getValue() != null) {
5836                                 validProperty.setValue(property.getValue()
5837                                                 .toString());
5838                         }
5839                         validProperty.setDescription(property.getDescription());
5840                         validProperty.setPassword(property.isPassword());
5841                         validProperties.add(validProperty);
5842                 }
5843                 defaultCapability.setProperties(validProperties);
5844         }
5845
5846         private boolean propertTypeEqualsTo(Map<String, PropertyDefinition> defaultProperties, String propertyName,
5847                                                                                 String propertyType) {
5848                 return propertyType != null && !defaultProperties.get(propertyName)
5849                                 .getType()
5850                                 .equals(propertyType);
5851         }
5852
5853         private Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
5854                         List<NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle,
5855                         Resource resource, User user) {
5856
5857                 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
5858                                 ArtifactOperationEnum.class);
5859                 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
5860                 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
5861                                 .left(nodeTypeArtifactsToHandle);
5862                 try {
5863                         // add all found Csar artifacts to list to upload
5864                         List<NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
5865                         List<NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
5866                         List<NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
5867                         for (NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
5868                                 ArtifactDefinition foundArtifact;
5869
5870                                 if (!existingArtifactsToHandle.isEmpty()) {
5871                                         foundArtifact = existingArtifactsToHandle.stream()
5872                                                         .filter(a -> a.getArtifactName()
5873                                                                         .equals(currNewArtifact.getArtifactName()))
5874                                                         .findFirst()
5875                                                         .orElse(null);
5876                                         if (foundArtifact != null) {
5877                                                 if (foundArtifact.getArtifactType().equals(currNewArtifact.getArtifactType())) {
5878                                                         if (!foundArtifact.getArtifactChecksum()
5879                                                                         .equals(currNewArtifact.getArtifactChecksum())) {
5880                                                                 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
5881                                                                 // if current artifact already exists, but has
5882                                                                 // different content, add him to the list to
5883                                                                 // update
5884                                                                 artifactsToUpdate.add(currNewArtifact);
5885                                                         }
5886                                                         // remove found artifact from the list of existing
5887                                                         // artifacts to handle, because it was already
5888                                                         // handled
5889                                                         existingArtifactsToHandle.remove(foundArtifact);
5890                                                         // and remove found artifact from the list to
5891                                                         // upload, because it should either be updated or be
5892                                                         // ignored
5893                                                         artifactsToUpload.remove(currNewArtifact);
5894                                                 } else {
5895                                                         log.debug("Can't upload two artifact with the same name {}.",
5896                                                                         currNewArtifact.getArtifactName());
5897                                                         ResponseFormat responseFormat = ResponseFormatManager.getInstance()
5898                                                                         .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR,
5899                                                                                         currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(),
5900                                                                                         foundArtifact.getArtifactType());
5901                                                         AuditingActionEnum auditingAction = artifactsBusinessLogic
5902                                                                         .detectAuditingType(new ArtifactOperationInfo(false, false,
5903                                                                                         ArtifactOperationEnum.CREATE), foundArtifact.getArtifactChecksum());
5904                                                         artifactsBusinessLogic.handleAuditing(auditingAction, resource, resource.getUniqueId(),
5905                                                                         user, null, null, foundArtifact.getUniqueId(), responseFormat,
5906                                                                         resource.getComponentType(), null);
5907                                                         responseWrapper.setInnerElement(responseFormat);
5908                                                         break;
5909                                                 }
5910                                         }
5911                                 }
5912                         }
5913                         if (responseWrapper.isEmpty()) {
5914                                 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
5915                                         if (currArtifact.getIsFromCsar()) {
5916                                                 artifactsToDelete.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5917                                                         currArtifact.getArtifactType(),
5918                                                         currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5919                                                         currArtifact.getIsFromCsar()));
5920                                         } else {
5921                                                 artifactsToUpdate.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5922                                                         currArtifact.getArtifactType(),
5923                                                         currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5924                                                         currArtifact.getIsFromCsar()));
5925
5926                                         }
5927                                 }
5928                         }
5929                         if (responseWrapper.isEmpty()) {
5930                                 if (!artifactsToUpload.isEmpty()) {
5931                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload);
5932                                 }
5933                                 if (!artifactsToUpdate.isEmpty()) {
5934                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate);
5935                                 }
5936                                 if (!artifactsToDelete.isEmpty()) {
5937                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
5938                                 }
5939                         }
5940                         if (!responseWrapper.isEmpty()) {
5941                                 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
5942                         }
5943                 } catch (Exception e) {
5944                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
5945                         responseWrapper.setInnerElement(responseFormat);
5946                         log.debug("Exception occurred when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
5947                 }
5948                 return nodeTypeArtifactsToHandleRes;
5949         }
5950
5951         ImmutablePair<String, String> buildNestedToscaResourceName(final String nodeResourceType,
5952                                                                                                                            final String vfResourceName,
5953                                                                                                                            final String nodeTypeFullName) {
5954                 String actualType;
5955                 String actualVfName;
5956                 if (ResourceTypeEnum.CVFC.name()
5957                         .equals(nodeResourceType)) {
5958                         actualVfName = vfResourceName + ResourceTypeEnum.CVFC.name();
5959                         actualType = ResourceTypeEnum.VFC.name();
5960                 } else {
5961                         actualVfName = vfResourceName;
5962                         actualType = nodeResourceType;
5963                 }
5964                 String nameWithouNamespacePrefix;
5965                 try {
5966                         final String nodeTypeNamePrefix = getNodeTypeNamePrefix(nodeTypeFullName);
5967                         log.debug("####### buildNestedToscaResourceName nodeResourceType {}, vfResourceName {}, "
5968                                         + "nodeTypeFullName {}, actualType {}, vfResourceName {} ",     nodeResourceType, vfResourceName,
5969                                 nodeTypeFullName, actualType, vfResourceName);
5970                         final StringBuilder toscaResourceName = new StringBuilder(nodeTypeNamePrefix);
5971
5972                         if (!nodeTypeFullName.contains(nodeTypeNamePrefix)) {
5973                                 nameWithouNamespacePrefix = nodeTypeFullName;
5974                         } else {
5975                                 nameWithouNamespacePrefix = nodeTypeFullName.substring(nodeTypeNamePrefix.length());
5976                         }
5977                         final String[] findTypes = nameWithouNamespacePrefix.split("\\.");
5978                         String actualName;
5979                         if (nodeResourceType.equalsIgnoreCase(findTypes[0])){
5980                                 actualName = nameWithouNamespacePrefix.substring(nodeResourceType.length());
5981                         } else {
5982                                 actualName = "." + nameWithouNamespacePrefix;
5983                         }
5984
5985                         if (actualName.startsWith(Constants.ABSTRACT)) {
5986                                 toscaResourceName.append(nodeResourceType.toLowerCase()).append('.')
5987                                         .append(ValidationUtils.convertToSystemName(actualVfName));
5988                         } else {
5989                                 toscaResourceName.append(actualType.toLowerCase()).append('.')
5990                                         .append(ValidationUtils.convertToSystemName(actualVfName)).append('.').append(Constants.ABSTRACT);
5991                         }
5992                         final StringBuilder previousToscaResourceName = new StringBuilder(toscaResourceName);
5993                         final String[] actualNames = actualName.split("\\.");
5994                         if (actualNames.length < 3) {
5995                                 return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5996                                         previousToscaResourceName.append(actualName).toString());
5997                         }
5998                         return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5999                                 previousToscaResourceName.append(actualName.substring(actualNames[1].length() + 1)
6000                                         .toLowerCase()).toString());
6001                 } catch (final Exception e) {
6002                         log.debug("Exception occured when buildNestedToscaResourceName, error is:{}", e.getMessage(), e);
6003                         throw new ByActionStatusComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE, vfResourceName);
6004                 }
6005         }
6006
6007         /**
6008          * Extracts a Node Type Name prefix from the given Node Type Name.
6009          *
6010          * @param fullName Node Type Name
6011          * @return Node Type Name Prefix
6012          */
6013         private String getNodeTypeNamePrefix(final String fullName) {
6014                 String tempPrefix = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
6015                 final List<String> definedNodeTypeNamespaceList = getDefinedNodeTypeNamespaceList();
6016                 log.debug("************* getPrefiX fullName {} FROM {}", fullName, definedNodeTypeNamespaceList);
6017                 final Optional<String> validNameSpace = validateNodeTypeNamePrefix(fullName, definedNodeTypeNamespaceList);
6018                 if (validNameSpace.isPresent()) {
6019                         tempPrefix = validNameSpace.get();
6020                 }
6021                 log.debug("************* getNodeTypeNamePrefix return fullName {} ", tempPrefix);
6022                 return tempPrefix;
6023         }
6024
6025         @Override
6026         public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String resourceId,
6027                                                                                                                                                                                                    List<String> dataParamsToReturn) {
6028
6029                 ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
6030                 Either<Resource, StorageOperationStatus> resourceResultEither =
6031                                 toscaOperationFacade.getToscaElement(resourceId,
6032                                 paramsToRetuen);
6033
6034                 if (resourceResultEither.isRight()) {
6035                         if (resourceResultEither.right().value() == StorageOperationStatus.NOT_FOUND) {
6036                                 log.debug("Failed to found resource with id {} ", resourceId);
6037                                 Either
6038                                                 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
6039                         }
6040
6041                         log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn);
6042                         return Either.right(componentsUtils
6043                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceResultEither.right()
6044                                                         .value()), ""));
6045                 }
6046
6047                 Resource resource = resourceResultEither.left().value();
6048                 if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
6049                         ListUtils.emptyIfNull(resource.getInputs())
6050                                         .forEach(input -> input.setConstraints(setInputConstraint(input)));
6051                 }
6052
6053                 UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resource,
6054                                 dataParamsToReturn);
6055                 return Either.left(dataTransfer);
6056         }
6057
6058         @Override
6059         public Either<Component, ActionStatus> shouldUpgradeToLatestDerived(Component clonedComponent) {
6060                 Resource resource = (Resource) clonedComponent;
6061                 if (ModelConverter.isAtomicComponent(resource.getResourceType())) {
6062                         Either<Component, StorageOperationStatus> shouldUpgradeToLatestDerived = toscaOperationFacade
6063                                         .shouldUpgradeToLatestDerived(resource);
6064                         if (shouldUpgradeToLatestDerived.isRight()) {
6065                                 return Either.right(componentsUtils.convertFromStorageResponse(shouldUpgradeToLatestDerived.right()
6066                                                 .value()));
6067                         }
6068                         return Either.left(shouldUpgradeToLatestDerived.left()
6069                                         .value());
6070                 } else {
6071                         return super.shouldUpgradeToLatestDerived(clonedComponent);
6072                 }
6073         }
6074 }