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