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         private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(ResourceBusinessLogic.class.getName());
 210
 211
 212         private IInterfaceLifecycleOperation interfaceTypeOperation;
 213         private LifecycleBusinessLogic lifecycleBusinessLogic;
 214
 215         private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 216         private final ResourceImportManager resourceImportManager;
 217         private final InputsBusinessLogic inputsBusinessLogic;
 218         private final CompositionBusinessLogic compositionBusinessLogic;
 219         private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
 220     private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
 221     private final MergeInstanceUtils mergeInstanceUtils;
 222     private final UiComponentDataConverter uiComponentDataConverter;
 223     private final CsarBusinessLogic csarBusinessLogic;
 224     private final PropertyBusinessLogic propertyBusinessLogic;
 225         private final PolicyBusinessLogic policyBusinessLogic;
 226
 227         @Autowired
 228     public ResourceBusinessLogic(IElementOperation elementDao,
 229         IGroupOperation groupOperation,
 230         IGroupInstanceOperation groupInstanceOperation,
 231         IGroupTypeOperation groupTypeOperation,
 232         GroupBusinessLogic groupBusinessLogic,
 233         InterfaceOperation interfaceOperation,
 234         InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
 235         ArtifactsBusinessLogic artifactsBusinessLogic,
 236         ComponentInstanceBusinessLogic componentInstanceBusinessLogic, @Lazy ResourceImportManager resourceImportManager,
 237         InputsBusinessLogic inputsBusinessLogic, CompositionBusinessLogic compositionBusinessLogic,
 238         ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
 239         CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic, MergeInstanceUtils mergeInstanceUtils,
 240         UiComponentDataConverter uiComponentDataConverter, CsarBusinessLogic csarBusinessLogic,
 241         ArtifactsOperations artifactToscaOperation, PropertyBusinessLogic propertyBusinessLogic,
 242                 ComponentContactIdValidator componentContactIdValidator,
 243                 ComponentNameValidator componentNameValidator, ComponentTagsValidator componentTagsValidator,
 244                 ComponentValidator componentValidator,
 245                 ComponentIconValidator componentIconValidator,
 246                 ComponentProjectCodeValidator componentProjectCodeValidator,
 247                 ComponentDescriptionValidator componentDescriptionValidator, PolicyBusinessLogic policyBusinessLogic) {
 248         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
 249             interfaceOperation, interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation,
 250                                 componentContactIdValidator, componentNameValidator, componentTagsValidator, componentValidator,
 251                                 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
 252         this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
 253         this.resourceImportManager = resourceImportManager;
 254         this.inputsBusinessLogic = inputsBusinessLogic;
 255         this.compositionBusinessLogic = compositionBusinessLogic;
 256         this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
 257         this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
 258         this.mergeInstanceUtils = mergeInstanceUtils;
 259         this.uiComponentDataConverter = uiComponentDataConverter;
 260         this.csarBusinessLogic = csarBusinessLogic;
 261         this.propertyBusinessLogic = propertyBusinessLogic;
 262                 this.policyBusinessLogic = policyBusinessLogic;
 263     }
 264
 265         @Autowired
 266         private ICapabilityTypeOperation capabilityTypeOperation;
 267
 268         @Autowired
 269         private TopologyComparator topologyComparator;
 270
 271         @Autowired
 272         private ComponentValidator componentValidator;
 273
 274         @Autowired
 275         private PropertyDataValueMergeBusinessLogic propertyDataValueMergeBusinessLogic;
 276
 277         @Autowired
 278         private SoftwareInformationBusinessLogic softwareInformationBusinessLogic;
 279
 280         public LifecycleBusinessLogic getLifecycleBusinessLogic() {
 281                 return lifecycleBusinessLogic;
 282         }
 283
 284     @Autowired
 285     public void setLifecycleManager(LifecycleBusinessLogic lifecycleBusinessLogic) {
 286         this.lifecycleBusinessLogic = lifecycleBusinessLogic;
 287     }
 288
 289         @VisibleForTesting
 290         protected void setComponentValidator(ComponentValidator componentValidator) {
 291                 this.componentValidator = componentValidator;
 292         }
 293
 294         public IElementOperation getElementDao() {
 295                 return elementDao;
 296         }
 297
 298         public void setElementDao(IElementOperation elementDao) {
 299                 this.elementDao = elementDao;
 300         }
 301
 302         public UserBusinessLogic getUserAdmin() {
 303                 return this.userAdmin;
 304         }
 305
 306         @Autowired
 307         public void setUserAdmin(UserBusinessLogic userAdmin) {
 308                 this.userAdmin = userAdmin;
 309         }
 310
 311         public ComponentsUtils getComponentsUtils() {
 312                 return this.componentsUtils;
 313         }
 314
 315         @Autowired
 316         public void setComponentsUtils(ComponentsUtils componentsUtils) {
 317                 this.componentsUtils = componentsUtils;
 318         }
 319
 320         public ArtifactsBusinessLogic getArtifactsManager() {
 321                 return artifactsBusinessLogic;
 322         }
 323
 324         public void setArtifactsManager(ArtifactsBusinessLogic artifactsManager) {
 325                 this.artifactsBusinessLogic = artifactsManager;
 326         }
 327
 328         public ApplicationDataTypeCache getApplicationDataTypeCache() {
 329                 return applicationDataTypeCache;
 330         }
 331
 332     @Autowired
 333     public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
 334         this.applicationDataTypeCache = applicationDataTypeCache;
 335     }
 336
 337     @Autowired
 338     public void setInterfaceTypeOperation(IInterfaceLifecycleOperation interfaceTypeOperation) {
 339         this.interfaceTypeOperation = interfaceTypeOperation;
 340     }
 341
 342         /**
 343          * the method returns a list of all the resources that are certified, the
 344          * returned resources are only abstract or only none abstract according to
 345          * the given param
 346          *
 347          * @param getAbstract
 348          * @param userId
 349          *            TODO
 350          * @return
 351          */
 352         public List<Resource> getAllCertifiedResources(boolean getAbstract, HighestFilterEnum highestFilter,
 353                                                                                                    String userId) {
 354                 User user = validateUserExists(userId);
 355                 Boolean isHighest = null;
 356                 switch (highestFilter) {
 357                         case ALL:
 358                                 break;
 359                         case HIGHEST_ONLY:
 360                                 isHighest = true;
 361                                 break;
 362                         case NON_HIGHEST_ONLY:
 363                                 isHighest = false;
 364                                 break;
 365                         default:
 366                                 break;
 367                 }
 368                 Either<List<Resource>, StorageOperationStatus> getResponse = toscaOperationFacade
 369                                 .getAllCertifiedResources(getAbstract, isHighest);
 370
 371                 if (getResponse.isRight()) {
 372                         throw new StorageException(getResponse.right()
 373                                         .value());
 374                 }
 375
 376                 return getResponse.left()
 377                                 .value();
 378         }
 379
 380         public Either<Map<String, Boolean>, ResponseFormat> validateResourceNameExists(String resourceName,
 381                                                                                                                                                                    ResourceTypeEnum resourceTypeEnum, String userId) {
 382
 383                 validateUserExists(userId);
 384
 385                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
 386                                 .validateComponentNameUniqueness(resourceName, resourceTypeEnum, ComponentTypeEnum.RESOURCE);
 387                 // DE242223
 388         janusGraphDao.commit();
 389
 390                 if (dataModelResponse.isLeft()) {
 391                         Map<String, Boolean> result = new HashMap<>();
 392                         result.put("isValid", dataModelResponse.left()
 393                                         .value());
 394                         log.debug("validation was successfully performed.");
 395                         return Either.left(result);
 396                 }
 397
 398                 ResponseFormat responseFormat = componentsUtils
 399                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
 400                                                 .value()));
 401
 402                 return Either.right(responseFormat);
 403         }
 404
 405         public Resource createResource(Resource resource, AuditingActionEnum auditingAction, User user,
 406                                                                    Map<String, byte[]> csarUIPayload, String payloadName) {
 407                 validateResourceBeforeCreate(resource, user, false);
 408                 String csarUUID = payloadName == null ? resource.getCsarUUID() : payloadName;
 409                 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Starting to create resource from CSAR by user {} ", user.getUserId());
 410                 if (StringUtils.isNotEmpty(csarUUID)) {
 411                         csarBusinessLogic.validateCsarBeforeCreate(resource, auditingAction, user, csarUUID);
 412                         log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
 413
 414                         Resource createResourceFromCsar = createResourceFromCsar(resource, user, csarUIPayload, csarUUID);
 415                         return updateCatalog(createResourceFromCsar, ChangeTypeEnum.LIFECYCLE).left()
 416                                         .map(r -> (Resource) r)
 417                                         .left()
 418                                         .value();
 419                 }
 420
 421                 final Resource createResourceByDao = createResourceByDao(resource, user, auditingAction, false, false);
 422                 return updateCatalog(createResourceByDao, ChangeTypeEnum.LIFECYCLE).left()
 423                                 .map(r -> (Resource) r)
 424                                 .left()
 425                                 .value();
 426         }
 427
 428         public Resource validateAndUpdateResourceFromCsar(Resource resource, User user, Map<String, byte[]> csarUIPayload,
 429                                                                                                           String payloadName, String resourceUniqueId) {
 430                 String csarUUID = payloadName;
 431                 String csarVersion = null;
 432                 Resource updatedResource = null;
 433                 if (payloadName == null) {
 434                         csarUUID = resource.getCsarUUID();
 435                         csarVersion = resource.getCsarVersion();
 436                 }
 437                 if (csarUUID != null && !csarUUID.isEmpty()) {
 438                         Resource oldResource = getResourceByUniqueId(resourceUniqueId);
 439                         validateCsarUuidMatching(oldResource, resource, csarUUID, resourceUniqueId, user);
 440                         validateCsarIsNotAlreadyUsed(oldResource, resource, csarUUID, user);
 441                         if (oldResource != null && ValidationUtils.hasBeenCertified(oldResource.getVersion())) {
 442                                 overrideImmutableMetadata(oldResource, resource);
 443                         }
 444                         validateResourceBeforeCreate(resource, user, false);
 445                         String oldCsarVersion = oldResource != null ? oldResource.getCsarVersion() : null;
 446                         log.debug("CsarUUID is {} - going to update resource with UniqueId {} from CSAR", csarUUID,
 447                                         resourceUniqueId);
 448                         // (on boarding flow): If the update includes same csarUUID and
 449                         // same csarVersion as already in the VF - no need to import the
 450                         // csar (do only metadata changes if there are).
 451                         if (csarVersion != null && oldCsarVersion != null && oldCsarVersion.equals(csarVersion)) {
 452                                 updatedResource = updateResourceMetadata(resourceUniqueId, resource, oldResource, user, false);
 453                         } else {
 454                                 updatedResource = updateResourceFromCsar(oldResource, resource, user,
 455                                                 AuditingActionEnum.UPDATE_RESOURCE_METADATA, false, csarUIPayload, csarUUID);
 456                         }
 457                 } else {
 458                         log.debug("Failed to update resource {}, csarUUID or payload name is missing", resource.getSystemName());
 459                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CSAR_UUID,
 460                                         resource.getName());
 461                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.CREATE_RESOURCE);
 462                         throw new ByActionStatusComponentException(ActionStatus.MISSING_CSAR_UUID, resource.getName());
 463                 }
 464                 return updatedResource;
 465         }
 466
 467         private void validateCsarIsNotAlreadyUsed(Resource oldResource, Resource resource, String csarUUID, User user) {
 468                 // (on boarding flow): If the update includes a csarUUID: verify this
 469                 // csarUUID is not in use by another VF, If it is - use same error as
 470                 // above:
 471                 // "Error: The VSP with UUID %1 was already imported for VF %2. Please
 472                 // select another or update the existing VF." %1 - csarUUID, %2 - VF
 473                 // name
 474                 Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = toscaOperationFacade
 475                                 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUUID, resource.getSystemName());
 476                 if (resourceLinkedToCsarRes.isRight()) {
 477                         if (StorageOperationStatus.NOT_FOUND != resourceLinkedToCsarRes.right().value()) {
 478                                 log.debug("Failed to find previous resource by CSAR {} and system name {}", csarUUID,
 479                                                 resource.getSystemName());
 480                                 throw new StorageException(resourceLinkedToCsarRes.right()
 481                                                 .value());
 482                         }
 483                 } else if (!resourceLinkedToCsarRes.left()
 484                                 .value()
 485                                 .getUniqueId()
 486                                 .equals(oldResource.getUniqueId())
 487                                 && !resourceLinkedToCsarRes.left()
 488                                 .value()
 489                                 .getName()
 490                                 .equals(oldResource.getName())) {
 491                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VSP_ALREADY_EXISTS, csarUUID,
 492                                         resourceLinkedToCsarRes.left()
 493                                                         .value()
 494                                                         .getName());
 495                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
 496                         throw new ByActionStatusComponentException(ActionStatus.VSP_ALREADY_EXISTS, csarUUID, resourceLinkedToCsarRes.left()
 497                                         .value()
 498                                         .getName());
 499                 }
 500         }
 501
 502         private void validateCsarUuidMatching(Resource resource, Resource oldResource, String csarUUID,
 503                                                                                   String resourceUniqueId, User user) {
 504                 // (on boarding flow): If the update includes csarUUID which is
 505                 // different from the csarUUID of the VF - fail with
 506                 // error: "Error: Resource %1 cannot be updated using since it is linked
 507                 // to a different VSP" %1 - VF name
 508                 String oldCsarUUID = oldResource.getCsarUUID();
 509                 if (oldCsarUUID != null && !oldCsarUUID.isEmpty() && !csarUUID.equals(oldCsarUUID)) {
 510                         log.debug(
 511                                         "Failed to update resource with UniqueId {} using Csar {}, since the resource is linked to a different VSP {}",
 512                                         resourceUniqueId, csarUUID, oldCsarUUID);
 513                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(
 514                                         ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID, oldCsarUUID);
 515                         componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
 516                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID,
 517                                         oldCsarUUID);
 518                 }
 519         }
 520
 521         private Resource getResourceByUniqueId(String resourceUniqueId) {
 522                 Either<Resource, StorageOperationStatus> oldResourceRes = toscaOperationFacade
 523                                 .getToscaFullElement(resourceUniqueId);
 524                 if (oldResourceRes.isRight()) {
 525                         log.debug("Failed to find previous resource by UniqueId {}, status: {}", resourceUniqueId,
 526                                         oldResourceRes.right()
 527                                                         .value());
 528                         throw new StorageException(oldResourceRes.right()
 529                                         .value());
 530                 }
 531                 return oldResourceRes.left()
 532                                 .value();
 533         }
 534
 535         private void overrideImmutableMetadata(Resource oldResource, Resource resource) {
 536                 resource.setName(oldResource.getName());
 537                 resource.setIcon(oldResource.getIcon());
 538                 resource.setTags(oldResource.getTags());
 539                 resource.setCategories(oldResource.getCategories());
 540                 resource.setDerivedFrom(oldResource.getDerivedFrom());
 541         }
 542
 543         private Resource updateResourceFromCsar(Resource oldResource, Resource newResource, User user,
 544                                                                                         AuditingActionEnum updateResource, boolean inTransaction, Map<String, byte[]> csarUIPayload,
 545                                                                                         String csarUUID) {
 546                 Resource updatedResource = null;
 547                 validateLifecycleState(oldResource, user);
 548                 String lockedResourceId = oldResource.getUniqueId();
 549                 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 550                 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(newResource, oldResource, user, csarUIPayload, csarUUID);
 551                 lockComponent(lockedResourceId, oldResource, "update Resource From Csar");
 552
 553                 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
 554
 555                 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
 556                                 nodeTypesInfo, csarInfo, oldResource);
 557                 if (findNodeTypesArtifactsToHandleRes.isRight()) {
 558                         log.debug("failed to find node types for update with artifacts during import csar {}. ",
 559                                         csarInfo.getCsarUUID());
 560                         throw new ByResponseFormatComponentException(findNodeTypesArtifactsToHandleRes.right()
 561                                         .value());
 562                 }
 563                 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = findNodeTypesArtifactsToHandleRes
 564                                 .left()
 565                                 .value();
 566                 try {
 567                         updatedResource = updateResourceFromYaml(oldResource, newResource, updateResource, createdArtifacts,
 568                                         csarInfo.getMainTemplateName(), csarInfo.getMainTemplateContent(), csarInfo, nodeTypesInfo,
 569                                         nodeTypesArtifactsToHandle, null, false);
 570
 571                 } catch (ComponentException | StorageException e) {
 572                         rollback(inTransaction, newResource, createdArtifacts, null);
 573                         throw e;
 574         }
 575         finally {
 576             janusGraphDao.commit();
 577                         log.debug("unlock resource {}", lockedResourceId);
 578                         graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
 579                 }
 580                 return updatedResource;
 581
 582         }
 583
 584         private void validateLifecycleState(Resource oldResource, User user) {
 585                 if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT == oldResource.getLifecycleState()
 586                                 && !oldResource.getLastUpdaterUserId()
 587                                 .equals(user.getUserId())) {
 588                         log.debug(
 589                                         "#validateLifecycleState - Current user is not last updater, last updater userId: {}, current user userId: {}",
 590                                         oldResource.getLastUpdaterUserId(), user.getUserId());
 591                         throw new ByActionStatusComponentException(ActionStatus.RESTRICTED_OPERATION);
 592                 }
 593         }
 594
 595         private Resource updateResourceFromYaml(Resource oldResource, Resource newResource, AuditingActionEnum actionEnum,
 596                                                                                         List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent, CsarInfo csarInfo,
 597                                                                                         Map<String, NodeTypeInfo> nodeTypesInfo,
 598                                                                                         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
 599                                                                                         String nodeName, boolean isNested) {
 600                 boolean inTransaction = true;
 601                 boolean shouldLock = false;
 602                 Resource preparedResource = null;
 603                 ParsedToscaYamlInfo uploadComponentInstanceInfoMap;
 604                 try {
 605                         uploadComponentInstanceInfoMap = csarBusinessLogic.getParsedToscaYamlInfo(yamlFileContent, yamlFileName,
 606                                         nodeTypesInfo, csarInfo, nodeName);
 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 (CollectionUtils.isEmpty(newResource.getDataTypes())){
4022                                 newResource.setDataTypes(oldResource.getDataTypes());
4023                         }
4024                         if (StringUtils.isEmpty(newResource.getDerivedFromGenericType())){
4025                                 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
4026                         }
4027                         if (StringUtils.isEmpty(newResource.getDerivedFromGenericVersion())){
4028                                 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
4029                         }
4030                         // add for new)
4031                         // created without tosca artifacts - add the placeholders
4032                         if (MapUtils.isEmpty(newResource.getToscaArtifacts())){
4033                                 setToscaArtifactsPlaceHolders(newResource, user);
4034                         }
4035
4036                         if (MapUtils.isEmpty(newResource.getInterfaces())){
4037                                 newResource.setInterfaces(oldResource.getInterfaces());
4038                         }
4039                         if (CollectionUtils.isEmpty(newResource.getAttributes())) {
4040                                 newResource.setAttributes(oldResource.getAttributes());
4041                         }
4042
4043                         if (CollectionUtils.isEmpty(newResource.getProperties())) {
4044                                 newResource.setProperties(oldResource.getProperties());
4045                         }
4046
4047                         Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
4048
4049                         if (overrideResource.isRight()) {
4050                                 ResponseFormat responseFormat = componentsUtils
4051                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(overrideResource.right()
4052                                                 .value()), newResource);
4053                                 componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE);
4054
4055                                 throwComponentException(responseFormat);
4056                         }
4057                         updateCatalog(overrideResource.left()
4058                                 .value(), ChangeTypeEnum.LIFECYCLE);
4059
4060                         log.debug("Resource updated successfully!!!");
4061                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4062                         componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4063                                 ResourceVersionInfo.newBuilder()
4064                                         .state(oldResource.getLifecycleState()
4065                                                 .name())
4066                                         .version(oldResource.getVersion())
4067                                         .build());
4068
4069                         resourcePair = new ImmutablePair<>(overrideResource.left()
4070                                 .value(), ActionStatus.OK);
4071                         return resourcePair;
4072                 } finally {
4073                         if (resourcePair == null) {
4074                                 BeEcompErrorManager.getInstance()
4075                                                 .logBeSystemError("Change LifecycleState - Certify");
4076                                 janusGraphDao.rollback();
4077                         } else if (!inTransaction) {
4078                 janusGraphDao.commit();
4079                         }
4080                         if (needLock) {
4081                                 log.debug("unlock resource {}", lockedResourceId);
4082                                 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
4083                         }
4084                 }
4085
4086         }
4087
4088         /**
4089          * Merge old resource with new. Keep old category and vendor name without
4090          * change
4091          *
4092          * @param oldResource
4093          * @param newResource
4094          */
4095         private void mergeOldResourceMetadataWithNew(Resource oldResource, Resource newResource) {
4096
4097                 // keep old category and vendor name without change
4098                 // merge the rest of the resource metadata
4099                 if (newResource.getTags() == null || newResource.getTags().isEmpty()) {
4100                         newResource.setTags(oldResource.getTags());
4101                 }
4102
4103                 if (newResource.getDescription() == null) {
4104                         newResource.setDescription(oldResource.getDescription());
4105                 }
4106
4107                 if (newResource.getVendorRelease() == null) {
4108                         newResource.setVendorRelease(oldResource.getVendorRelease());
4109                 }
4110
4111                 if (newResource.getResourceVendorModelNumber() == null) {
4112                         newResource.setResourceVendorModelNumber(oldResource.getResourceVendorModelNumber());
4113                 }
4114
4115                 if (newResource.getContactId() == null) {
4116                         newResource.setContactId(oldResource.getContactId());
4117                 }
4118
4119                 newResource.setCategories(oldResource.getCategories());
4120                 if (newResource.getVendorName() == null) {
4121                         newResource.setVendorName(oldResource.getVendorName());
4122                 }
4123                 List<GroupDefinition>oldForUpdate = oldResource.getGroups();
4124                 if(CollectionUtils.isNotEmpty(oldForUpdate)){
4125                         List<GroupDefinition>groupForUpdate = oldForUpdate.stream().map(group -> new GroupDefinition(group)).collect(Collectors.toList());
4126
4127                         groupForUpdate.stream().filter(group -> group.isVspOriginated())
4128                                         .forEach(group -> group.setName(group.getInvariantName()));
4129
4130                         newResource.setGroups(groupForUpdate);
4131                 }
4132
4133
4134                 if(newResource.getResourceType().isAtomicType() && !newResource.getName().equals("Root")&& newResource.getResourceType() != ResourceTypeEnum.CVFC) {
4135                         ResourceTypeEnum updatedResourceType = newResource.getResourceType();
4136                         Component derivedFromResource = getParentComponent(newResource);
4137                         if (derivedFromResource.getComponentType() == ComponentTypeEnum.RESOURCE) {
4138                                 Resource parentResource = (Resource) derivedFromResource;
4139                                 if (!(parentResource.isAbstract() && (ResourceTypeEnum.VFC == parentResource.getResourceType() || ResourceTypeEnum.ABSTRACT == parentResource.getResourceType())) &&
4140                                                 parentResource.getResourceType() != updatedResourceType) {
4141                                         BeEcompErrorManager.getInstance()
4142                                                         .logInternalDataError("mergeOldResourceMetadataWithNew", "resource type of the resource does not match to derived from resource type",
4143                                                                         ErrorSeverity.ERROR);
4144                                         log.debug("#mergeOldResourceMetadataWithNew - resource type {} of the resource {} does not match to derived from resource type {}",
4145                                                         newResource.getResourceType(), newResource.getToscaResourceName(), parentResource.getResourceType());
4146                                         throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_TYPE);
4147                                 }
4148                         }
4149                 }
4150
4151         }
4152
4153         private Component getParentComponent(Resource newResource) {
4154                 String toscaResourceNameDerivedFrom = newResource.getDerivedFrom().get(0);
4155                 Either<Component, StorageOperationStatus> latestByToscaResourceName = toscaOperationFacade.getLatestByToscaResourceName(toscaResourceNameDerivedFrom);
4156                 if(latestByToscaResourceName.isRight()){
4157                         BeEcompErrorManager.getInstance()
4158                                         .logInternalDataError("mergeOldResourceMetadataWithNew", "derived from resource not found", ErrorSeverity.ERROR);
4159                         log.debug("#mergeOldResourceMetadataWithNew - derived from resource {} not found", toscaResourceNameDerivedFrom);
4160                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, toscaResourceNameDerivedFrom);
4161                 }
4162                 return latestByToscaResourceName.left().value();
4163         }
4164
4165         private Resource prepareResourceForUpdate(Resource oldResource, Resource newResource, User user,
4166                                                                                           boolean inTransaction, boolean needLock) {
4167
4168                 if (!ComponentValidationUtils.canWorkOnResource(oldResource, user.getUserId())) {
4169                         // checkout
4170                         return lifecycleBusinessLogic.changeState(oldResource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
4171                                         new LifecycleChangeInfoWithAction("update by import"), inTransaction, needLock)
4172                                         .left()
4173                                         .on(response -> failOnChangeState(response, user, oldResource, newResource));
4174                 }
4175                 return oldResource;
4176         }
4177
4178         private Resource failOnChangeState(ResponseFormat response, User user, Resource oldResource, Resource newResource) {
4179                 log.info("resource {} cannot be updated. reason={}", oldResource.getUniqueId(), response.getFormattedMessage());
4180                 componentsUtils.auditResource(response, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4181                                 ResourceVersionInfo.newBuilder()
4182                                                 .state(oldResource.getLifecycleState()
4183                                                                 .name())
4184                                                 .version(oldResource.getVersion())
4185                                                 .build());
4186                 throw new ByResponseFormatComponentException(response);
4187         }
4188
4189         public Resource validateResourceBeforeCreate(Resource resource, User user, AuditingActionEnum actionEnum,
4190                                                                                                  boolean inTransaction, CsarInfo csarInfo) {
4191
4192                 validateResourceFieldsBeforeCreate(user, resource, actionEnum, inTransaction);
4193                 validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), resource, actionEnum, inTransaction);
4194                 validateLifecycleTypesCreate(user, resource, actionEnum);
4195                 validateResourceType(user, resource, actionEnum);
4196                 resource.setCreatorUserId(user.getUserId());
4197                 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
4198                 resource.setContactId(resource.getContactId()
4199                                 .toLowerCase());
4200                 if (StringUtils.isEmpty(resource.getToscaResourceName()) && !ModelConverter.isAtomicComponent(resource)) {
4201                         String resourceSystemName;
4202                         if (csarInfo != null && StringUtils.isNotEmpty(csarInfo.getVfResourceName())) {
4203                                 resourceSystemName = ValidationUtils.convertToSystemName(csarInfo.getVfResourceName());
4204                         } else {
4205                                 resourceSystemName = resource.getSystemName();
4206                         }
4207                         resource.setToscaResourceName(CommonBeUtils
4208                                 .generateToscaResourceName(resource.getResourceType().name().toLowerCase(), resourceSystemName));
4209                 }
4210
4211                 // Generate invariant UUID - must be here and not in operation since it
4212                 // should stay constant during clone
4213                 // TODO
4214                 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
4215                 resource.setInvariantUUID(invariantUUID);
4216
4217                 return resource;
4218         }
4219
4220         private Either<Boolean, ResponseFormat> validateResourceType(User user, Resource resource,
4221                                                                                                                                  AuditingActionEnum actionEnum) {
4222                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4223                 if (resource.getResourceType() == null) {
4224                         log.debug("Invalid resource type for resource");
4225                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
4226                         eitherResult = Either.right(errorResponse);
4227                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4228                 }
4229                 return eitherResult;
4230         }
4231
4232         private Either<Boolean, ResponseFormat> validateLifecycleTypesCreate(User user, Resource resource,
4233                                                                                                                                                  AuditingActionEnum actionEnum) {
4234                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4235                 if (resource.getInterfaces() != null && resource.getInterfaces()
4236                                 .size() > 0) {
4237                         log.debug("validate interface lifecycle Types Exist");
4238                         Iterator<InterfaceDefinition> intItr = resource.getInterfaces()
4239                                         .values()
4240                                         .iterator();
4241                         while (intItr.hasNext() && eitherResult.isLeft()) {
4242                                 InterfaceDefinition interfaceDefinition = intItr.next();
4243                                 String intType = interfaceDefinition.getUniqueId();
4244                                 Either<InterfaceDefinition, StorageOperationStatus> eitherCapTypeFound = interfaceTypeOperation
4245                                                 .getInterface(intType);
4246                                 if (eitherCapTypeFound.isRight()) {
4247                                         if (eitherCapTypeFound.right()
4248                                                         .value() == StorageOperationStatus.NOT_FOUND) {
4249                                                 BeEcompErrorManager.getInstance()
4250                                                                 .logBeGraphObjectMissingError("Create Resource - validateLifecycleTypesCreate",
4251                                                                                 "Interface", intType);
4252                                                 log.debug("Lifecycle Type: {} is required by resource: {} but does not exist in the DB",
4253                                                                 intType, resource.getName());
4254                                                 BeEcompErrorManager.getInstance()
4255                                                                 .logBeDaoSystemError("Create Resource - validateLifecycleTypesCreate");
4256                                                 log.debug("request to data model failed with error: {}", eitherCapTypeFound.right()
4257                                                                 .value()
4258                                                                 .name());
4259                                         }
4260
4261                                         ResponseFormat errorResponse = componentsUtils
4262                                                         .getResponseFormat(ActionStatus.MISSING_LIFECYCLE_TYPE, intType);
4263                                         eitherResult = Either.right(errorResponse);
4264                                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4265                                 }
4266
4267                         }
4268                 }
4269                 return eitherResult;
4270         }
4271
4272         private Either<Boolean, ResponseFormat> validateCapabilityTypesCreate(User user,
4273                                                                                                                                                   ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4274                                                                                                                                                   boolean inTransaction) {
4275
4276                 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4277                 if (resource.getCapabilities() != null && resource.getCapabilities()
4278                                 .size() > 0) {
4279                         log.debug("validate capability Types Exist - capabilities section");
4280
4281                         for (Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities()
4282                                         .entrySet()) {
4283
4284                                 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource, actionEnum,
4285                                                 eitherResult, typeEntry, inTransaction);
4286                                 if (eitherResult.isRight()) {
4287                                         return Either.right(eitherResult.right()
4288                                                         .value());
4289                                 }
4290                         }
4291                 }
4292
4293                 if (resource.getRequirements() != null && resource.getRequirements()
4294                                 .size() > 0) {
4295                         log.debug("validate capability Types Exist - requirements section");
4296                         for (String type : resource.getRequirements()
4297                                         .keySet()) {
4298                                 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource,
4299                                                 resource.getRequirements()
4300                                                                 .get(type),
4301                                                 actionEnum, eitherResult, type, inTransaction);
4302                                 if (eitherResult.isRight()) {
4303                                         return Either.right(eitherResult.right()
4304                                                         .value());
4305                                 }
4306                         }
4307                 }
4308
4309                 return eitherResult;
4310         }
4311
4312         // @param typeObject- the object to which the validation is done
4313         private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4314                                                                                                                                                  ICapabilityTypeOperation capabilityTypeOperation, Resource resource, List<?> validationObjects,
4315                                                                                                                                                  AuditingActionEnum actionEnum, Either<Boolean, ResponseFormat> eitherResult, String type,
4316                                                                                                                                                  boolean inTransaction) {
4317                 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4318                                 .getCapabilityType(type, inTransaction);
4319                 if (eitherCapTypeFound.isRight()) {
4320                         if (eitherCapTypeFound.right()
4321                                         .value() == StorageOperationStatus.NOT_FOUND) {
4322                                 BeEcompErrorManager.getInstance()
4323                                                 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4324                                                                 type);
4325                                 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB", type,
4326                                                 resource.getName());
4327                                 BeEcompErrorManager.getInstance()
4328                                                 .logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4329                         }
4330                         log.debug("Trying to get capability type {} failed with error: {}", type, eitherCapTypeFound.right()
4331                                         .value()
4332                                         .name());
4333                         ResponseFormat errorResponse = null;
4334                         if (type != null) {
4335                                 errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, type);
4336                         } else {
4337                                 errorResponse = componentsUtils.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE,
4338                                                 validationObjects);
4339                         }
4340                         eitherResult = Either.right(errorResponse);
4341                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4342                 }
4343                 return eitherResult;
4344         }
4345
4346         private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4347                                                                                                                                                  ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4348                                                                                                                                                  Either<Boolean, ResponseFormat> eitherResult, Entry<String, List<CapabilityDefinition>> typeEntry,
4349                                                                                                                                                  boolean inTransaction) {
4350                 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4351                                 .getCapabilityType(typeEntry.getKey(), inTransaction);
4352                 if (eitherCapTypeFound.isRight()) {
4353                         if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) {
4354                                 BeEcompErrorManager.getInstance()
4355                                                 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4356                                                                 typeEntry.getKey());
4357                                 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB",
4358                                                 typeEntry.getKey(), resource.getName());
4359                                 BeEcompErrorManager.getInstance().logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4360                         }
4361                         log.debug("Trying to get capability type {} failed with error: {}", typeEntry.getKey(),
4362                                         eitherCapTypeFound.right().value().name());
4363                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE,
4364                                         typeEntry.getKey());
4365                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4366                         return Either.right(errorResponse);
4367                 }
4368                 CapabilityTypeDefinition capabilityTypeDefinition = eitherCapTypeFound.left().value();
4369                 if (capabilityTypeDefinition.getProperties() != null) {
4370                         for (CapabilityDefinition capDef : typeEntry.getValue()) {
4371                                 List<ComponentInstanceProperty> properties = capDef.getProperties();
4372                                 List<ComponentInstanceProperty> changedProperties = new ArrayList<>();
4373                                 if (properties == null || properties.isEmpty()) {
4374                                         for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4375                                                 ComponentInstanceProperty newProp = new ComponentInstanceProperty(prop.getValue());
4376                                                 changedProperties.add(newProp);
4377                                         }
4378                                 } else {
4379                                         List<ComponentInstanceProperty> propsToAdd = new ArrayList<>();
4380                                         for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4381                                                 PropertyDefinition propFromDef = prop.getValue();
4382                                                 boolean propFound = false;
4383                                                 for (ComponentInstanceProperty cip : properties) {
4384                                                         if (propFromDef.getName().equals(cip.getName())) {
4385                                                                 //merge property value and property description only, ignore other fields
4386                                                                 if(cip.getDescription() != null && !cip.getDescription().equals(propFromDef.getDescription())){
4387                                                                         propFromDef.setDescription(cip.getDescription());
4388                                                                 }
4389                                                                 propertyDataValueMergeBusinessLogic.mergePropertyValue(propFromDef, cip, new ArrayList<>());
4390                                                                 if(cip.getValue() != null){
4391                                                                         propFromDef.setValue(cip.getValue());
4392                                                                 }
4393                                                                 propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4394                                                                 propFound = true;
4395                                                                 properties.remove(cip);
4396                                                                 break;
4397                                                         }
4398                                                 }
4399                                                 if(!propFound) {
4400                                                         propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4401                                                 }
4402                                         }
4403                                         if (!propsToAdd.isEmpty()) {
4404                                                 changedProperties.addAll(propsToAdd);
4405                                         }
4406                                 }
4407                                 capDef.setProperties(changedProperties);
4408                         }
4409                 }
4410                 return eitherResult;
4411         }
4412
4413         public Resource createResourceByDao(Resource resource, User user, AuditingActionEnum actionEnum,
4414                                                                                 boolean isNormative, boolean inTransaction) {
4415                 // create resource
4416
4417                 // lock new resource name in order to avoid creation resource with same
4418                 // name
4419                 Resource createdResource = null;
4420                 if (!inTransaction) {
4421                         Either<Boolean, ResponseFormat> lockResult = lockComponentByName(resource.getSystemName(), resource,
4422                                         CREATE_RESOURCE);
4423                         if (lockResult.isRight()) {
4424                                 ResponseFormat responseFormat = lockResult.right().value();
4425                                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4426                                 throw new ByResponseFormatComponentException(responseFormat);
4427                         }
4428
4429                         log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
4430                 }
4431                 try {
4432                         if (resource.deriveFromGeneric()) {
4433                                 handleResourceGenericType(resource);
4434                         }
4435                         createdResource = createResourceTransaction(resource, user, isNormative);
4436                         componentsUtils.auditResource(componentsUtils.getResponseFormat(ActionStatus.CREATED), user,
4437                                         createdResource, actionEnum);
4438                         ASDCKpiApi.countCreatedResourcesKPI();
4439                 } catch (ComponentException e) {
4440                         ResponseFormat responseFormat = e.getResponseFormat() == null
4441                                         ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
4442                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4443                         throw e;
4444                 } catch (StorageException e) {
4445                         ResponseFormat responseFormat = componentsUtils
4446                                         .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
4447                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4448                         throw e;
4449                 } finally {
4450             if (!inTransaction) {
4451                                 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(),
4452                                                 NodeTypeEnum.Resource);
4453                         }
4454                 }
4455                 return createdResource;
4456         }
4457
4458         private Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
4459                 // validate resource name uniqueness
4460                 log.debug("validate resource name");
4461                 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade.validateComponentNameExists(
4462                                 resource.getName(), resource.getResourceType(), resource.getComponentType());
4463                 if (eitherValidation.isRight()) {
4464                         loggerSupportability.log(LoggerSupportabilityActions.VALIDATE_NAME,resource.getComponentMetadataForSupportLog(),
4465                                         StatusCode.ERROR,"ERROR while validate component name {} Status is: {}",resource.getName(),eitherValidation.right().value());
4466                         log.debug("Failed to validate component name {}. Status is {}. ", resource.getName(),
4467                                         eitherValidation.right()
4468                                                         .value());
4469                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(eitherValidation.right()
4470                                         .value()));
4471                 }
4472                 if (eitherValidation.left()
4473                                 .value()) {
4474                         log.debug("resource with name: {}, already exists", resource.getName());
4475                         loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
4476                                         StatusCode.ERROR,"resource with name: {} already exists",resource.getName());
4477                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
4478                                         ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
4479                 }
4480
4481                 log.debug("send resource {} to dao for create", resource.getName());
4482
4483                 createArtifactsPlaceHolderData(resource, user);
4484                 // enrich object
4485                 if (!isNormative) {
4486                         log.debug("enrich resource with creator, version and state");
4487                         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
4488                         resource.setVersion(INITIAL_VERSION);
4489                         resource.setHighestVersion(true);
4490                         if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4491                                 resource.setAbstract(false);
4492                         }
4493                 }
4494                 return toscaOperationFacade.createToscaComponent(resource)
4495                                 .left()
4496                                 .on(r -> throwComponentExceptionByResource(r, resource));
4497         }
4498
4499         private Resource throwComponentExceptionByResource(StorageOperationStatus status, Resource resource) {
4500                 ResponseFormat responseFormat = componentsUtils
4501                                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(status), resource);
4502                 throw new ByResponseFormatComponentException(responseFormat);
4503         }
4504
4505         private void createArtifactsPlaceHolderData(Resource resource, User user) {
4506                 // create mandatory artifacts
4507
4508                 // TODO it must be removed after that artifact uniqueId creation will be
4509                 // moved to ArtifactOperation
4510
4511                 setInformationalArtifactsPlaceHolder(resource, user);
4512                 setDeploymentArtifactsPlaceHolder(resource, user);
4513                 setToscaArtifactsPlaceHolders(resource, user);
4514         }
4515
4516         @SuppressWarnings("unchecked")
4517         @Override
4518         public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
4519                 Resource resource = (Resource) component;
4520                 Map<String, ArtifactDefinition> artifactMap = resource.getDeploymentArtifacts();
4521                 if (artifactMap == null) {
4522                         artifactMap = new HashMap<>();
4523                 }
4524                 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
4525                                 .getConfiguration()
4526                                 .getDeploymentResourceArtifacts();
4527                 if (deploymentResourceArtifacts != null) {
4528                         Map<String, ArtifactDefinition> finalArtifactMap = artifactMap;
4529                         deploymentResourceArtifacts
4530                                         .forEach((k, v) -> processDeploymentResourceArtifacts(user, resource, finalArtifactMap, k, v));
4531                 }
4532                 resource.setDeploymentArtifacts(artifactMap);
4533         }
4534
4535         private void processDeploymentResourceArtifacts(User user, Resource resource,
4536                                                                                                         Map<String, ArtifactDefinition> artifactMap, String k, Object v) {
4537                 boolean shouldCreateArtifact = true;
4538                 Map<String, Object> artifactDetails = (Map<String, Object>) v;
4539                 Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES);
4540                 if (object != null) {
4541                         List<String> artifactTypes = (List<String>) object;
4542                         if (!artifactTypes.contains(resource.getResourceType()
4543                                         .name())) {
4544                                 shouldCreateArtifact = false;
4545                                 return;
4546                         }
4547                 } else {
4548                         log.info("resource types for artifact placeholder {} were not defined. default is all resources", k);
4549                 }
4550                 if (shouldCreateArtifact) {
4551                         if (artifactsBusinessLogic != null) {
4552                                 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4553                                                 resource.getUniqueId(), k, (Map<String, Object>) v, user, ArtifactGroupTypeEnum.DEPLOYMENT);
4554                                 if (artifactDefinition != null && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) {
4555                                         artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4556                                 }
4557                         }
4558                 }
4559         }
4560
4561         @SuppressWarnings("unchecked")
4562         private void setInformationalArtifactsPlaceHolder(Resource resource, User user) {
4563                 Map<String, ArtifactDefinition> artifactMap = resource.getArtifacts();
4564                 if (artifactMap == null) {
4565                         artifactMap = new HashMap<>();
4566                 }
4567                 String resourceUniqueId = resource.getUniqueId();
4568                 List<String> exludeResourceCategory = ConfigurationManager.getConfigurationManager()
4569                                 .getConfiguration()
4570                                 .getExcludeResourceCategory();
4571                 List<String> exludeResourceType = ConfigurationManager.getConfigurationManager()
4572                                 .getConfiguration()
4573                                 .getExcludeResourceType();
4574                 Map<String, Object> informationalResourceArtifacts = ConfigurationManager.getConfigurationManager()
4575                                 .getConfiguration()
4576                                 .getInformationalResourceArtifacts();
4577                 List<CategoryDefinition> categories = resource.getCategories();
4578                 boolean isCreateArtifact = true;
4579                 if (exludeResourceCategory != null) {
4580                         String category = categories.get(0)
4581                                         .getName();
4582                         isCreateArtifact = exludeResourceCategory.stream()
4583                                         .noneMatch(e -> e.equalsIgnoreCase(category));
4584                 }
4585                 if (isCreateArtifact && exludeResourceType != null) {
4586                         String resourceType = resource.getResourceType()
4587                                         .name();
4588                         isCreateArtifact = exludeResourceType.stream()
4589                                         .noneMatch(e -> e.equalsIgnoreCase(resourceType));
4590                 }
4591                 if (informationalResourceArtifacts != null && isCreateArtifact) {
4592                         Set<String> keys = informationalResourceArtifacts.keySet();
4593                         for (String informationalResourceArtifactName : keys) {
4594                                 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalResourceArtifacts
4595                                                 .get(informationalResourceArtifactName);
4596                                 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4597                                                 resourceUniqueId, informationalResourceArtifactName, artifactInfoMap, user,
4598                                                 ArtifactGroupTypeEnum.INFORMATIONAL);
4599                                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4600
4601                         }
4602                 }
4603                 resource.setArtifacts(artifactMap);
4604         }
4605
4606         /**
4607          * deleteResource
4608          *
4609          * @param resourceId
4610          * @param user
4611          * @return
4612          */
4613         public ResponseFormat deleteResource(String resourceId, User user) {
4614                 ResponseFormat responseFormat;
4615                 validateUserExists(user);
4616
4617                 Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade.getToscaElement(resourceId);
4618                 if (resourceStatus.isRight()) {
4619                         log.debug("failed to get resource {}", resourceId);
4620                         return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4621                                         .value()), "");
4622                 }
4623
4624                 Resource resource = resourceStatus.left()
4625                                 .value();
4626
4627                 StorageOperationStatus result = StorageOperationStatus.OK;
4628                 lockComponent(resourceId, resource, "Mark resource to delete");
4629                 try {
4630
4631                         result = markComponentToDelete(resource);
4632                         if (result == StorageOperationStatus.OK) {
4633                                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4634                         } else {
4635                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4636                                 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4637                         }
4638                         return responseFormat;
4639
4640                 } finally {
4641                         if (result == null || result != StorageOperationStatus.OK) {
4642                                 janusGraphDao.rollback();
4643                         } else {
4644                 janusGraphDao.commit();
4645                         }
4646                         graphLockOperation.unlockComponent(resourceId, NodeTypeEnum.Resource);
4647                 }
4648
4649         }
4650
4651         public ResponseFormat deleteResourceByNameAndVersion(String resourceName, String version, User user) {
4652                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4653                 validateUserExists(user);
4654                 Resource resource = null;
4655                 StorageOperationStatus result = StorageOperationStatus.OK;
4656                 boolean failed = false;
4657                 try {
4658
4659                         Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade
4660                                         .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, version);
4661                         if (resourceStatus.isRight()) {
4662                                 log.debug("failed to get resource {} version {}", resourceName, version);
4663                                 return componentsUtils
4664                                                 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4665                                                                 .value()), resourceName);
4666                         }
4667
4668                         resource = resourceStatus.left()
4669                                         .value();
4670
4671                 } finally {
4672                         janusGraphDao.commit();
4673                 }
4674                 if (resource != null) {
4675                         lockComponent(resource.getUniqueId(), resource, DELETE_RESOURCE);
4676                         try {
4677                                 result = markComponentToDelete(resource);
4678                                 if (result != StorageOperationStatus.OK) {
4679                                         ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4680                                         responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4681                                         return responseFormat;
4682                                 }
4683                         }catch (ComponentException e){
4684                                 failed = true;
4685                                 throw e;
4686                         }finally {
4687                                 if (failed || result == null || result != StorageOperationStatus.OK) {
4688                                         janusGraphDao.rollback();
4689                                 } else {
4690                     janusGraphDao.commit();
4691                                 }
4692                                 graphLockOperation.unlockComponent(resource.getUniqueId(), NodeTypeEnum.Resource);
4693                         }
4694                 }
4695                 return responseFormat;
4696         }
4697
4698         public Either<Resource, ResponseFormat> getResource(String resourceId, User user) {
4699
4700                 if (user != null) {
4701                         validateUserExists(user);
4702                 }
4703
4704                 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(resourceId);
4705                 if (storageStatus.isRight()) {
4706                         log.debug("failed to get resource by id {}", resourceId);
4707                         return Either.right(componentsUtils
4708                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus.right()
4709                                                         .value()), resourceId));
4710                 }
4711                 if (!(storageStatus.left()
4712                                 .value() instanceof Resource)) {
4713                         return Either.right(componentsUtils.getResponseFormatByResource(
4714                                         componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), resourceId));
4715                 }
4716                 return Either.left(storageStatus.left()
4717                                 .value());
4718
4719         }
4720
4721         public Either<Resource, ResponseFormat> getResourceByNameAndVersion(String resourceName, String resourceVersion,
4722                                                                                                                                                 String userId) {
4723
4724                 validateUserExists(userId);
4725
4726                 Either<Resource, StorageOperationStatus> getResource = toscaOperationFacade
4727                                 .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion);
4728                 if (getResource.isRight()) {
4729                         log.debug("failed to get resource by name {} and version {}", resourceName, resourceVersion);
4730                         return Either.right(componentsUtils
4731                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResource.right()
4732                                                         .value()), resourceName));
4733                 }
4734                 return Either.left(getResource.left()
4735                                 .value());
4736         }
4737
4738         /**
4739          * updateResourceMetadata
4740          *
4741          * @param user
4742          *            - modifier data (userId)
4743          * @param inTransaction
4744          *            TODO
4745          * @param resourceIdToUpdate
4746          *            - the resource identifier
4747          * @param newResource
4748          * @return Either<Resource , responseFormat>
4749          */
4750         public Resource updateResourceMetadata(String resourceIdToUpdate, Resource newResource, Resource currentResource,
4751                                                                                    User user, boolean inTransaction) {
4752
4753                 validateUserExists(user.getUserId());
4754
4755                 log.debug("Get resource with id {}", resourceIdToUpdate);
4756                 boolean needToUnlock = false;
4757
4758                 try {
4759                         if (currentResource == null) {
4760                                 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade
4761                                                 .getToscaElement(resourceIdToUpdate);
4762                                 if (storageStatus.isRight()) {
4763                                         throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatByResource(
4764                                                         componentsUtils.convertFromStorageResponse(storageStatus.right()
4765                                                                         .value()),
4766                                                         ""));
4767                                 }
4768
4769                                 currentResource = storageStatus.left()
4770                                                 .value();
4771                         }
4772                         // verify that resource is checked-out and the user is the last
4773                         // updater
4774                         if (!ComponentValidationUtils.canWorkOnResource(currentResource, user.getUserId())) {
4775                                 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
4776                         }
4777
4778                         // lock resource
4779                         StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceIdToUpdate,
4780                                         NodeTypeEnum.Resource);
4781                         if (lockResult != StorageOperationStatus.OK) {
4782                                 BeEcompErrorManager.getInstance()
4783                                                 .logBeFailedLockObjectError("Upload Artifact - lock ", NodeTypeEnum.Resource.getName(),
4784                                                                 resourceIdToUpdate);
4785                                 log.debug("Failed to lock resource: {}, error - {}", resourceIdToUpdate, lockResult);
4786                                 ResponseFormat responseFormat = componentsUtils
4787                                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(lockResult));
4788                                 throw new ByResponseFormatComponentException(responseFormat);
4789                         }
4790
4791                         needToUnlock = true;
4792
4793                         // critical section starts here
4794                         // convert json to object
4795
4796                         // Update and updated resource must have a non-empty "derivedFrom"
4797                         // list
4798                         // This code is not called from import resources, because of root
4799                         // VF "derivedFrom" should be null (or ignored)
4800                         if (ModelConverter.isAtomicComponent(currentResource)) {
4801                                 validateDerivedFromNotEmpty(null, newResource, null);
4802                                 validateDerivedFromNotEmpty(null, currentResource, null);
4803                         } else {
4804                                 newResource.setDerivedFrom(null);
4805                         }
4806
4807             Either<Resource, ResponseFormat> dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource,
4808                     user, currentResource, false, true);
4809             if (dataModelResponse.isRight()) {
4810                 log.debug("failed to update resource metadata!!!");
4811                 throw new ByResponseFormatComponentException(dataModelResponse.right().value());
4812             }
4813
4814                         log.debug("Resource metadata updated successfully!!!");
4815                         return dataModelResponse.left()
4816                                         .value();
4817
4818                 } catch (ComponentException | StorageException e) {
4819                         rollback(inTransaction, newResource, null, null);
4820                         throw e;
4821                 } finally {
4822                         if (!inTransaction) {
4823                 janusGraphDao.commit();
4824                         }
4825                         if (needToUnlock) {
4826                                 graphLockOperation.unlockComponent(resourceIdToUpdate, NodeTypeEnum.Resource);
4827                         }
4828                 }
4829         }
4830
4831         private Either<Resource, ResponseFormat> updateResourceMetadata(String resourceIdToUpdate, Resource newResource,
4832                                                                                                                                         User user, Resource currentResource, boolean shouldLock, boolean inTransaction) {
4833                 updateVfModuleGroupsNames(currentResource, newResource);
4834                 validateResourceFieldsBeforeUpdate(currentResource, newResource, inTransaction, false);
4835                 // Setting last updater and uniqueId
4836                 newResource.setContactId(newResource.getContactId()
4837                                 .toLowerCase());
4838                 newResource.setLastUpdaterUserId(user.getUserId());
4839                 newResource.setUniqueId(resourceIdToUpdate);
4840                 // Cannot set highest version through UI
4841                 newResource.setHighestVersion(currentResource.isHighestVersion());
4842                 newResource.setCreationDate(currentResource.getCreationDate());
4843
4844                 Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom = processUpdateOfDerivedFrom(currentResource,
4845                                 newResource, user.getUserId(), inTransaction);
4846
4847                 if (processUpdateOfDerivedFrom.isRight()) {
4848                         log.debug("Couldn't update derived from for resource {}", resourceIdToUpdate);
4849                         return Either.right(processUpdateOfDerivedFrom.right()
4850                                         .value());
4851                 }
4852
4853                 log.debug("send resource {} to dao for update", newResource.getUniqueId());
4854                 if (isNotEmpty(newResource.getGroups())) {
4855                         for (GroupDefinition group : newResource.getGroups()) {
4856                                 if (DEFAULT_GROUP_VF_MODULE.equals(group.getType())) {
4857                                         groupBusinessLogic.validateAndUpdateGroupMetadata(newResource.getComponentMetadataDefinition()
4858                                                         .getMetadataDataDefinition()
4859                                                         .getUniqueId(), user, newResource.getComponentType(), group, true, false);
4860                                 }
4861                         }
4862                 }
4863                 Either<Resource, StorageOperationStatus> dataModelResponse = toscaOperationFacade
4864                                 .updateToscaElement(newResource);
4865
4866                 if (dataModelResponse.isRight()) {
4867                         ResponseFormat responseFormat = componentsUtils
4868                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
4869                                                         .value()), newResource);
4870                         return Either.right(responseFormat);
4871                 } else if (dataModelResponse.left()
4872                                 .value() == null) {
4873                         log.debug("No response from updateResource");
4874                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
4875                 }
4876                 return Either.left(dataModelResponse.left()
4877                                 .value());
4878         }
4879
4880         private void updateVfModuleGroupsNames(Resource currentResource, Resource newResource) {
4881                 if (currentResource.getGroups() != null && !currentResource.getName()
4882                                 .equals(newResource.getName())) {
4883                         List<GroupDefinition> updatedGroups = currentResource.getGroups()
4884                                         .stream()
4885                                         .map(group -> getUpdatedGroup(group, currentResource.getName(), newResource.getName()))
4886                                         .collect(toList());
4887                         newResource.setGroups(updatedGroups);
4888                 }
4889         }
4890
4891         private GroupDefinition getUpdatedGroup(GroupDefinition currGroup, String replacePattern, String with) {
4892                 GroupDefinition updatedGroup = new GroupDefinition(currGroup);
4893                 if (updatedGroup.isSamePrefix(replacePattern) && updatedGroup.getType()
4894                                 .equals(DEFAULT_GROUP_VF_MODULE)) {
4895                         String prefix = updatedGroup.getName()
4896                                         .substring(0, replacePattern.length());
4897                         String newGroupName = updatedGroup.getName()
4898                                         .replaceFirst(prefix, with);
4899                         updatedGroup.setName(newGroupName);
4900                 }
4901                 return updatedGroup;
4902         }
4903
4904         /**
4905          * validateResourceFieldsBeforeCreate
4906          *
4907          * @param user
4908          *            - modifier data (userId)
4909          */
4910         private void validateResourceFieldsBeforeCreate(User user, Resource resource,
4911                                                                                                         AuditingActionEnum actionEnum, boolean inTransaction) {
4912                 componentValidator.validate(user, resource, actionEnum);
4913                 // validate category
4914                 log.debug("validate category");
4915                 validateCategory(user, resource, actionEnum, inTransaction);
4916                 // validate vendor name & release & model number
4917                 log.debug("validate vendor name");
4918                 validateVendorName(user, resource, actionEnum);
4919                 log.debug("validate vendor release");
4920                 validateVendorReleaseName(user, resource, actionEnum);
4921                 log.debug("validate resource vendor model number");
4922                 validateResourceVendorModelNumber(user, resource, actionEnum);
4923                 // validate cost
4924                 log.debug("validate cost");
4925                 validateCost(resource);
4926                 // validate licenseType
4927                 log.debug("validate licenseType");
4928                 validateLicenseType(user, resource, actionEnum);
4929                 // validate template (derived from)
4930                 log.debug("validate derived from");
4931                 if (!ModelConverter.isAtomicComponent(resource) && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4932                         resource.setDerivedFrom(null);
4933                 }
4934                 validateDerivedFromExist(user, resource, actionEnum);
4935                 // warn about non-updatable fields
4936                 checkComponentFieldsForOverrideAttempt(resource);
4937                 String currentCreatorFullName = resource.getCreatorFullName();
4938                 if (currentCreatorFullName != null) {
4939                         log.debug("Resource Creator fullname is automatically set and cannot be updated");
4940                 }
4941
4942                 String currentLastUpdaterFullName = resource.getLastUpdaterFullName();
4943                 if (currentLastUpdaterFullName != null) {
4944                         log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
4945                 }
4946
4947                 Long currentLastUpdateDate = resource.getLastUpdateDate();
4948                 if (currentLastUpdateDate != null) {
4949                         log.debug("Resource last update date is automatically set and cannot be updated");
4950                 }
4951
4952                 Boolean currentAbstract = resource.isAbstract();
4953                 if (currentAbstract != null) {
4954                         log.debug("Resource abstract is automatically set and cannot be updated");
4955                 }
4956         }
4957
4958         /**
4959          * validateResourceFieldsBeforeUpdate
4960          *
4961          * @param currentResource
4962          *            - Resource object to validate
4963          * @param isNested
4964          */
4965         private void validateResourceFieldsBeforeUpdate(Resource currentResource, Resource updateInfoResource,
4966                                                                                                         boolean inTransaction, boolean isNested) {
4967                 validateFields(currentResource, updateInfoResource, inTransaction, isNested);
4968                 warnNonEditableFields(currentResource, updateInfoResource);
4969         }
4970
4971         private void warnNonEditableFields(Resource currentResource, Resource updateInfoResource) {
4972                 String currentResourceVersion = currentResource.getVersion();
4973                 String updatedResourceVersion = updateInfoResource.getVersion();
4974
4975                 if ((updatedResourceVersion != null) && (!updatedResourceVersion.equals(currentResourceVersion))) {
4976                         log.debug("Resource version is automatically set and cannot be updated");
4977                 }
4978
4979                 String currentCreatorUserId = currentResource.getCreatorUserId();
4980                 String updatedCreatorUserId = updateInfoResource.getCreatorUserId();
4981
4982                 if ((updatedCreatorUserId != null) && (!updatedCreatorUserId.equals(currentCreatorUserId))) {
4983                         log.debug("Resource Creator UserId is automatically set and cannot be updated");
4984                 }
4985
4986                 String currentCreatorFullName = currentResource.getCreatorFullName();
4987                 String updatedCreatorFullName = updateInfoResource.getCreatorFullName();
4988
4989                 if ((updatedCreatorFullName != null) && (!updatedCreatorFullName.equals(currentCreatorFullName))) {
4990                         log.debug("Resource Creator fullname is automatically set and cannot be updated");
4991                 }
4992
4993                 String currentLastUpdaterUserId = currentResource.getLastUpdaterUserId();
4994                 String updatedLastUpdaterUserId = updateInfoResource.getLastUpdaterUserId();
4995
4996                 if ((updatedLastUpdaterUserId != null) && (!updatedLastUpdaterUserId.equals(currentLastUpdaterUserId))) {
4997                         log.debug("Resource LastUpdater userId is automatically set and cannot be updated");
4998                 }
4999
5000                 String currentLastUpdaterFullName = currentResource.getLastUpdaterFullName();
5001                 String updatedLastUpdaterFullName = updateInfoResource.getLastUpdaterFullName();
5002
5003                 if ((updatedLastUpdaterFullName != null) && (!updatedLastUpdaterFullName.equals(currentLastUpdaterFullName))) {
5004                         log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
5005                 }
5006                 Long currentCreationDate = currentResource.getCreationDate();
5007                 Long updatedCreationDate = updateInfoResource.getCreationDate();
5008
5009                 if ((updatedCreationDate != null) && (!updatedCreationDate.equals(currentCreationDate))) {
5010                         log.debug("Resource Creation date is automatically set and cannot be updated");
5011                 }
5012
5013                 Long currentLastUpdateDate = currentResource.getLastUpdateDate();
5014                 Long updatedLastUpdateDate = updateInfoResource.getLastUpdateDate();
5015
5016                 if ((updatedLastUpdateDate != null) && (!updatedLastUpdateDate.equals(currentLastUpdateDate))) {
5017                         log.debug("Resource last update date is automatically set and cannot be updated");
5018                 }
5019
5020                 LifecycleStateEnum currentLifecycleState = currentResource.getLifecycleState();
5021                 LifecycleStateEnum updatedLifecycleState = updateInfoResource.getLifecycleState();
5022
5023                 if ((updatedLifecycleState != null) && (!updatedLifecycleState.equals(currentLifecycleState))) {
5024                         log.debug("Resource lifecycle state date is automatically set and cannot be updated");
5025                 }
5026
5027                 Boolean currentAbstract = currentResource.isAbstract();
5028                 Boolean updatedAbstract = updateInfoResource.isAbstract();
5029
5030                 if ((updatedAbstract != null) && (!updatedAbstract.equals(currentAbstract))) {
5031                         log.debug("Resource abstract is automatically set and cannot be updated");
5032                 }
5033
5034                 Boolean currentHighestVersion = currentResource.isHighestVersion();
5035                 Boolean updatedHighestVersion = updateInfoResource.isHighestVersion();
5036
5037                 if ((updatedHighestVersion != null) && (!updatedHighestVersion.equals(currentHighestVersion))) {
5038                         log.debug("Resource highest version is automatically set and cannot be updated");
5039                 }
5040
5041                 String currentUuid = currentResource.getUUID();
5042                 String updatedUuid = updateInfoResource.getUUID();
5043
5044                 if ((updatedUuid != null) && (!updatedUuid.equals(currentUuid))) {
5045                         log.debug("Resource UUID is automatically set and cannot be updated");
5046                 }
5047
5048                 log.debug("Resource Type  cannot be updated");
5049                 String currentInvariantUuid = currentResource.getInvariantUUID();
5050                 String updatedInvariantUuid = updateInfoResource.getInvariantUUID();
5051
5052                 if ((updatedInvariantUuid != null) && (!updatedInvariantUuid.equals(currentInvariantUuid))) {
5053                         log.debug("Resource invariant UUID is automatically set and cannot be updated");
5054                         updateInfoResource.setInvariantUUID(currentInvariantUuid);
5055                 }
5056         }
5057
5058         private void validateFields(Resource currentResource, Resource updateInfoResource, boolean inTransaction,
5059                                                                 boolean isNested) {
5060                 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentResource.getVersion());
5061                 log.debug("validate resource name before update");
5062                 validateResourceName(currentResource, updateInfoResource, hasBeenCertified, isNested);
5063                 log.debug("validate description before update");
5064                 componentDescriptionValidator.validateAndCorrectField(null, updateInfoResource, null);
5065                 log.debug("validate icon before update");
5066                 validateIcon(currentResource, updateInfoResource, hasBeenCertified);
5067                 log.debug("validate tags before update");
5068                 componentTagsValidator.validateAndCorrectField(null, updateInfoResource, null);
5069                 log.debug("validate vendor name before update");
5070                 validateVendorName(null, updateInfoResource, null);
5071                 log.debug("validate resource vendor model number before update");
5072                 validateResourceVendorModelNumber(currentResource, updateInfoResource);
5073                 log.debug("validate vendor release before update");
5074                 validateVendorReleaseName(null, updateInfoResource, null);
5075                 log.debug("validate contact info before update");
5076                 componentContactIdValidator.validateAndCorrectField(null, updateInfoResource, null);
5077                 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
5078                 validateDerivedFromDuringUpdate(currentResource, updateInfoResource, hasBeenCertified);
5079                 log.debug("validate category before update");
5080                 validateCategory(currentResource, updateInfoResource, hasBeenCertified, inTransaction);
5081         }
5082
5083         private boolean isResourceNameEquals(Resource currentResource, Resource updateInfoResource) {
5084                 String resourceNameUpdated = updateInfoResource.getName();
5085                 String resourceNameCurrent = currentResource.getName();
5086                 if (resourceNameCurrent.equals(resourceNameUpdated)) {
5087                         return true;
5088                 }
5089                 // In case of CVFC type we should support the case of old VF with CVFC
5090                 // instances that were created without the "Cvfc" suffix
5091                 return currentResource.getResourceType() == ResourceTypeEnum.CVFC
5092                                 && resourceNameUpdated.equals(addCvfcSuffixToResourceName(resourceNameCurrent));
5093         }
5094
5095         private String addCvfcSuffixToResourceName(String resourceName) {
5096                 return resourceName + "Cvfc";
5097         }
5098
5099         private void validateResourceName(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified,
5100                                                                           boolean isNested) {
5101                 String resourceNameUpdated = updateInfoResource.getName();
5102                 if (!isResourceNameEquals(currentResource, updateInfoResource)) {
5103                         if (isNested || !hasBeenCertified) {
5104                                 componentNameValidator.validateAndCorrectField(null, updateInfoResource, null);
5105                                 validateResourceNameUniqueness(updateInfoResource);
5106                                 currentResource.setName(resourceNameUpdated);
5107                                 currentResource.setNormalizedName(ValidationUtils.normaliseComponentName(resourceNameUpdated));
5108                                 currentResource.setSystemName(ValidationUtils.convertToSystemName(resourceNameUpdated));
5109
5110                         } else {
5111                                 log.info("Resource name: {}, cannot be updated once the resource has been certified once.",
5112                                                 resourceNameUpdated);
5113                                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
5114                         }
5115                 }
5116         }
5117
5118         private void validateIcon(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) {
5119                 String iconUpdated = updateInfoResource.getIcon();
5120                 String iconCurrent = currentResource.getIcon();
5121                 if (!iconCurrent.equals(iconUpdated)) {
5122                         if (!hasBeenCertified) {
5123                                 componentIconValidator.validateAndCorrectField(null, updateInfoResource, null);
5124                         } else {
5125                                 log.info("Icon {} cannot be updated once the resource has been certified once.", iconUpdated);
5126                                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
5127                         }
5128                 }
5129         }
5130
5131         private void validateResourceVendorModelNumber(Resource currentResource, Resource updateInfoResource) {
5132                 String updatedResourceVendorModelNumber = updateInfoResource.getResourceVendorModelNumber();
5133                 String currentResourceVendorModelNumber = currentResource.getResourceVendorModelNumber();
5134                 if (!currentResourceVendorModelNumber.equals(updatedResourceVendorModelNumber)) {
5135                         validateResourceVendorModelNumber(null, updateInfoResource, null);
5136                 }
5137         }
5138
5139         private Either<Boolean, ResponseFormat> validateCategory(Resource currentResource, Resource updateInfoResource,
5140                                                                                                                          boolean hasBeenCertified, boolean inTransaction) {
5141                 validateCategory(null, updateInfoResource, null, inTransaction);
5142                 if (hasBeenCertified) {
5143                         CategoryDefinition currentCategory = currentResource.getCategories()
5144                                         .get(0);
5145                         SubCategoryDefinition currentSubCategory = currentCategory.getSubcategories()
5146                                         .get(0);
5147                         CategoryDefinition updateCategory = updateInfoResource.getCategories()
5148                                         .get(0);
5149                         SubCategoryDefinition updtaeSubCategory = updateCategory.getSubcategories()
5150                                         .get(0);
5151                         if (!currentCategory.getName()
5152                                         .equals(updateCategory.getName())
5153                                         || !currentSubCategory.getName()
5154                                         .equals(updtaeSubCategory.getName())) {
5155                                 log.info("Category {} cannot be updated once the resource has been certified once.",
5156                                                 currentResource.getCategories());
5157                                 ResponseFormat errorResponse = componentsUtils
5158                                                 .getResponseFormat(ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
5159                                 return Either.right(errorResponse);
5160                         }
5161                 }
5162                 return Either.left(true);
5163         }
5164
5165         private Either<Boolean, ResponseFormat> validateDerivedFromDuringUpdate(Resource currentResource,
5166                                                                                                                                                         Resource updateInfoResource, boolean hasBeenCertified) {
5167
5168                 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5169                 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5170                 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5171                                 || updatedDerivedFrom.isEmpty()) {
5172                         log.trace("Update normative types");
5173                         return Either.left(true);
5174                 }
5175
5176                 String derivedFromCurrent = currentDerivedFrom.get(0);
5177                 String derivedFromUpdated = updatedDerivedFrom.get(0);
5178
5179                 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5180                         if (!hasBeenCertified) {
5181                                 validateDerivedFromExist(null, updateInfoResource, null);
5182                         } else {
5183                                 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5184                                                 currentResource, updateInfoResource, null);
5185
5186                                 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5187                                                 .value()) {
5188                                         log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5189                                         return validateDerivedFromExtending;
5190                                 }
5191                         }
5192                 } else {
5193                         // For derived from, we must know whether it was actually changed,
5194                         // otherwise we must do no action.
5195                         // Due to changes it inflicts on data model (remove artifacts,
5196                         // properties...), it's not like a flat field which can be
5197                         // overwritten if not changed.
5198                         // So we must indicate that derived from is not changed
5199                         updateInfoResource.setDerivedFrom(null);
5200                 }
5201                 return Either.left(true);
5202         }
5203
5204         private Either<Boolean, ResponseFormat> validateNestedDerivedFromDuringUpdate(Resource currentResource,
5205                                                                                                                                                                   Resource updateInfoResource, boolean hasBeenCertified) {
5206
5207                 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5208                 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5209                 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5210                                 || updatedDerivedFrom.isEmpty()) {
5211                         log.trace("Update normative types");
5212                         return Either.left(true);
5213                 }
5214
5215                 String derivedFromCurrent = currentDerivedFrom.get(0);
5216                 String derivedFromUpdated = updatedDerivedFrom.get(0);
5217
5218                 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5219                         if (!hasBeenCertified) {
5220                                 validateDerivedFromExist(null, updateInfoResource, null);
5221                         } else {
5222                                 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5223                                                 currentResource, updateInfoResource, null);
5224
5225                                 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5226                                                 .value()) {
5227                                         log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5228                                         return validateDerivedFromExtending;
5229                                 }
5230                         }
5231                 }
5232                 return Either.left(true);
5233         }
5234
5235         private void validateDerivedFromExist(User user, Resource resource, AuditingActionEnum actionEnum) {
5236                 if (resource.getDerivedFrom() == null || resource.getDerivedFrom()
5237                                 .isEmpty()) {
5238                         return;
5239                 }
5240                 String templateName = resource.getDerivedFrom()
5241                                 .get(0);
5242                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5243                                 .validateToscaResourceNameExists(templateName);
5244                 if (dataModelResponse.isRight()) {
5245                         StorageOperationStatus storageStatus = dataModelResponse.right()
5246                                         .value();
5247                         BeEcompErrorManager.getInstance()
5248                                         .logBeDaoSystemError("Create Resource - validateDerivedFromExist");
5249                         log.debug("request to data model failed with error: {}", storageStatus);
5250                         ResponseFormat responseFormat = componentsUtils
5251                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus), resource);
5252                         log.trace("audit before sending response");
5253                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5254                         throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus));
5255                 } else if (!dataModelResponse.left()
5256                                 .value()) {
5257                         log.info("resource template with name: {}, does not exists", templateName);
5258                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5259                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5260                         throw new ByActionStatusComponentException(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5261                 }
5262         }
5263
5264         // Tal G for extending inheritance US815447
5265         private Either<Boolean, ResponseFormat> validateDerivedFromExtending(User user, Resource currentResource,
5266                                                                                                                                                  Resource updateInfoResource, AuditingActionEnum actionEnum) {
5267                 String currentTemplateName = currentResource.getDerivedFrom()
5268                                 .get(0);
5269                 String updatedTemplateName = updateInfoResource.getDerivedFrom()
5270                                 .get(0);
5271
5272                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5273                                 .validateToscaResourceNameExtends(currentTemplateName, updatedTemplateName);
5274                 if (dataModelResponse.isRight()) {
5275                         StorageOperationStatus storageStatus = dataModelResponse.right()
5276                                         .value();
5277                         BeEcompErrorManager.getInstance()
5278                                         .logBeDaoSystemError("Create/Update Resource - validateDerivingFromExtendingType");
5279                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
5280                                         componentsUtils.convertFromStorageResponse(storageStatus), currentResource);
5281                         log.trace("audit before sending response");
5282                         componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5283                         return Either.right(responseFormat);
5284                 }
5285
5286                 if (!dataModelResponse.left()
5287                                 .value()) {
5288                         log.info("resource template with name {} does not inherit as original {}", updatedTemplateName,
5289                                         currentTemplateName);
5290                         ResponseFormat responseFormat = componentsUtils
5291                                         .getResponseFormat(ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
5292                         componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5293
5294                         return Either.right(responseFormat);
5295
5296                 }
5297                 return Either.left(true);
5298         }
5299
5300         public void validateDerivedFromNotEmpty(User user, Resource resource, AuditingActionEnum actionEnum) {
5301                 log.debug("validate resource derivedFrom field");
5302                 if ((resource.getDerivedFrom() == null) || (resource.getDerivedFrom()
5303                                 .isEmpty())
5304                                 || (resource.getDerivedFrom()
5305                                 .get(0)) == null
5306                                 || (resource.getDerivedFrom()
5307                                 .get(0)
5308                                 .trim()
5309                                 .isEmpty())) {
5310                         log.info("derived from (template) field is missing for the resource");
5311                         ResponseFormat responseFormat = componentsUtils
5312                                         .getResponseFormat(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5313                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5314
5315                         throw new ByActionStatusComponentException(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5316                 }
5317         }
5318
5319         private void validateResourceNameUniqueness(Resource resource) {
5320
5321                 Either<Boolean, StorageOperationStatus> resourceOperationResponse = toscaOperationFacade
5322                                 .validateComponentNameExists(resource.getName(), resource.getResourceType(),
5323                                                 resource.getComponentType());
5324                 if (resourceOperationResponse.isLeft() && resourceOperationResponse.left()
5325                                 .value()) {
5326                         log.debug("resource with name: {}, already exists", resource.getName());
5327                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
5328                                         ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
5329                 } else if (resourceOperationResponse.isRight()) {
5330                         log.debug("error while validateResourceNameExists for resource: {}", resource.getName());
5331                         throw new StorageException(resourceOperationResponse.right()
5332                                         .value());
5333                 }
5334         }
5335
5336         private void validateCategory(User user, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5337
5338                 List<CategoryDefinition> categories = resource.getCategories();
5339                 if (CollectionUtils.isEmpty(categories)) {
5340                         log.debug(CATEGORY_IS_EMPTY);
5341                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5342                                         ComponentTypeEnum.RESOURCE.getValue());
5343                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5344                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5345                                         ComponentTypeEnum.RESOURCE.getValue());
5346                 }
5347                 if (categories.size() > 1) {
5348                         log.debug("Must be only one category for resource");
5349                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_TOO_MUCH_CATEGORIES,
5350                                         ComponentTypeEnum.RESOURCE.getValue());
5351                 }
5352                 CategoryDefinition category = categories.get(0);
5353                 List<SubCategoryDefinition> subcategories = category.getSubcategories();
5354                 if (CollectionUtils.isEmpty(subcategories)) {
5355                         log.debug("Missinig subcategory for resource");
5356                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY);
5357                 }
5358                 if (subcategories.size() > 1) {
5359                         log.debug("Must be only one sub category for resource");
5360                         throw new ByActionStatusComponentException(ActionStatus.RESOURCE_TOO_MUCH_SUBCATEGORIES);
5361                 }
5362
5363                 SubCategoryDefinition subcategory = subcategories.get(0);
5364
5365                 if (!ValidationUtils.validateStringNotEmpty(category.getName())) {
5366                         log.debug(CATEGORY_IS_EMPTY);
5367                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5368                                         ComponentTypeEnum.RESOURCE.getValue());
5369                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5370                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5371                                         ComponentTypeEnum.RESOURCE.getValue());
5372                 }
5373                 if (!ValidationUtils.validateStringNotEmpty(subcategory.getName())) {
5374                         log.debug(CATEGORY_IS_EMPTY);
5375                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(
5376                                         ActionStatus.COMPONENT_MISSING_SUBCATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5377                         componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5378                         throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY,
5379                                         ComponentTypeEnum.RESOURCE.getValue());
5380                 }
5381
5382                 validateCategoryListed(category, subcategory, user, resource, actionEnum, inTransaction);
5383         }
5384
5385         private void validateCategoryListed(CategoryDefinition category, SubCategoryDefinition subcategory, User user,
5386                                                                                 Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5387                 ResponseFormat responseFormat;
5388                 if (category != null && subcategory != null) {
5389                         log.debug("validating resource category {} against valid categories list", category);
5390                         Either<List<CategoryDefinition>, ActionStatus> categories = elementDao
5391                                         .getAllCategories(NodeTypeEnum.ResourceNewCategory, inTransaction);
5392                         if (categories.isRight()) {
5393                                 log.debug("failed to retrieve resource categories from JanusGraph");
5394                                 responseFormat = componentsUtils.getResponseFormat(categories.right()
5395                                                 .value());
5396                                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5397                                 throw new ByActionStatusComponentException(categories.right()
5398                                                 .value());
5399                         }
5400                         List<CategoryDefinition> categoryList = categories.left()
5401                                         .value();
5402                         Optional<CategoryDefinition> foundCategory = categoryList.stream()
5403                                         .filter(cat -> cat.getName()
5404                                                         .equals(category.getName()))
5405                                         .findFirst();
5406                         if (!foundCategory.isPresent()) {
5407                                 log.debug("Category {} is not part of resource category group. Resource category valid values are {}",
5408                                                 category, categoryList);
5409                                 failOnInvalidCategory(user, resource, actionEnum);
5410                         }
5411                         Optional<SubCategoryDefinition> foundSubcategory = foundCategory.get()
5412                                         .getSubcategories()
5413                                         .stream()
5414                                         .filter(subcat -> subcat.getName()
5415                                                         .equals(subcategory.getName()))
5416                                         .findFirst();
5417                         if (!foundSubcategory.isPresent()) {
5418                                 log.debug(
5419                                                 "SubCategory {} is not part of resource category group. Resource subcategory valid values are {}",
5420                                                 subcategory, foundCategory.get()
5421                                                                 .getSubcategories());
5422                                 failOnInvalidCategory(user, resource, actionEnum);
5423                         }
5424                 }
5425         }
5426
5427         private void failOnInvalidCategory(User user, Resource resource, AuditingActionEnum actionEnum) {
5428                 ResponseFormat responseFormat;
5429                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY,
5430                                 ComponentTypeEnum.RESOURCE.getValue());
5431                 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5432                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5433         }
5434
5435         public void validateVendorReleaseName(User user, Resource resource, AuditingActionEnum actionEnum) {
5436                 String vendorRelease = resource.getVendorRelease();
5437                 log.debug("validate vendor relese name");
5438                 if (!ValidationUtils.validateStringNotEmpty(vendorRelease)) {
5439                         log.info("vendor relese name is missing.");
5440                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_RELEASE);
5441                         componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5442                         throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_RELEASE);
5443                 }
5444
5445                 validateVendorReleaseName(vendorRelease, user, resource, actionEnum);
5446         }
5447
5448         public void validateVendorReleaseName(String vendorRelease, User user, Resource resource,
5449                                                                                   AuditingActionEnum actionEnum) {
5450                 if (vendorRelease != null) {
5451                         if (!ValidationUtils.validateVendorReleaseLength(vendorRelease)) {
5452                                 log.info("vendor release exceds limit.");
5453                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5454                                                 ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5455                                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5456                                 throw new ByActionStatusComponentException(ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT,
5457                                                 "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5458                         }
5459
5460                         if (!ValidationUtils.validateVendorRelease(vendorRelease)) {
5461                                 log.info("vendor release  is not valid.");
5462                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_RELEASE);
5463                                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5464                 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_RELEASE, vendorRelease);
5465             }
5466         }
5467     }
5468
5469     private void validateVendorName(User user, Resource resource,
5470                                     AuditingActionEnum actionEnum) {
5471         String vendorName = resource.getVendorName();
5472         if (!ValidationUtils.validateStringNotEmpty(vendorName)) {
5473             log.info("vendor name is missing.");
5474             ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_NAME);
5475             componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5476             throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_NAME);
5477         }
5478         validateVendorName(vendorName, user, resource, actionEnum);
5479     }
5480
5481     private void validateVendorName(String vendorName, User user, Resource resource,
5482                                     AuditingActionEnum actionEnum) {
5483         if (vendorName != null) {
5484             if (!ValidationUtils.validateVendorNameLength(vendorName)) {
5485                 log.info("vendor name exceds limit.");
5486                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5487                         "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5488                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5489                 throw new ByActionStatusComponentException(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5490                         "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5491             }
5492
5493             if (!ValidationUtils.validateVendorName(vendorName)) {
5494                 log.info("vendor name  is not valid.");
5495                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_NAME);
5496                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5497                 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_NAME, vendorName);
5498             }
5499         }
5500     }
5501
5502     private void validateResourceVendorModelNumber(User user, Resource resource, AuditingActionEnum actionEnum) {
5503         String resourceVendorModelNumber = resource.getResourceVendorModelNumber();
5504         if (StringUtils.isNotEmpty(resourceVendorModelNumber)) {
5505             if (!ValidationUtils.validateResourceVendorModelNumberLength(resourceVendorModelNumber)) {
5506                 log.info("resource vendor model number exceeds limit.");
5507                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5508                         ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5509                         "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5510                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5511                 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5512                         "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5513             }
5514             // resource vendor model number is currently validated as vendor
5515             // name
5516             if (!ValidationUtils.validateVendorName(resourceVendorModelNumber)) {
5517                 log.info("resource vendor model number  is not valid.");
5518                 ResponseFormat errorResponse = componentsUtils
5519                         .getResponseFormat(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5520                 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5521                 throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5522             }
5523         }
5524     }
5525
5526
5527     private void validateCost(Resource resource) {
5528         String cost = resource.getCost();
5529         if (cost != null) {
5530             if (!ValidationUtils.validateCost(cost)) {
5531                 log.debug("resource cost is invalid.");
5532                 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5533             }
5534         }
5535     }
5536
5537     private void validateLicenseType(User user, Resource resource,
5538                                      AuditingActionEnum actionEnum) {
5539         log.debug("validate licenseType");
5540         String licenseType = resource.getLicenseType();
5541         if (licenseType != null) {
5542             List<String> licenseTypes = ConfigurationManager.getConfigurationManager().getConfiguration()
5543                     .getLicenseTypes();
5544             if (!licenseTypes.contains(licenseType)) {
5545                 log.debug("License type {} isn't configured", licenseType);
5546                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
5547                 if (actionEnum != null) {
5548                     // In update case, no audit is required
5549                     componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5550                 }
5551                 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5552             }
5553         }
5554     }
5555
5556         private Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom(Resource currentResource,
5557                                                                                                                                            Resource updatedResource, String userId, boolean inTransaction) {
5558                 if (updatedResource.getDerivedFrom() != null) {
5559                         log.debug("Starting derived from update for resource {}", updatedResource.getUniqueId());
5560                         log.debug("1. Removing interface artifacts from graph");
5561                         // Remove all interface artifacts of resource
5562                         String resourceId = updatedResource.getUniqueId();
5563                         Map<String, InterfaceDefinition> interfaces = currentResource.getInterfaces();
5564
5565                         if (interfaces != null) {
5566                                 Collection<InterfaceDefinition> values = interfaces.values();
5567                                 for (InterfaceDefinition interfaceDefinition : values) {
5568                                         String interfaceType = interfaceTypeOperation.getShortInterfaceName(interfaceDefinition);
5569
5570                                         log.trace("Starting interface artifacts removal for interface type {}", interfaceType);
5571                                         Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
5572                                         if (operations != null) {
5573                                                 for (Entry<String, Operation> operationEntry : operations.entrySet()) {
5574                                                         Operation operation = operationEntry.getValue();
5575                                                         ArtifactDefinition implementation = operation.getImplementationArtifact();
5576                                                         if (implementation != null) {
5577                                                                 String uniqueId = implementation.getUniqueId();
5578                                                                 log.debug("Removing interface artifact definition {}, operation {}, interfaceType {}",
5579                                                                                 uniqueId, operationEntry.getKey(), interfaceType);
5580                                                                 // only thing that transacts and locks here
5581                                                                 Either<ArtifactDefinition, ResponseFormat> deleteArtifactByInterface =
5582                                                                         artifactsBusinessLogic.deleteArtifactByInterface(resourceId, userId, uniqueId, true);
5583                                                                 if (deleteArtifactByInterface.isRight()) {
5584                                                                         log.debug("Couldn't remove artifact definition with id {}", uniqueId);
5585                                                                         if (!inTransaction) {
5586                                                                                 janusGraphDao.rollback();
5587                                                                         }
5588                                                                         return Either.right(deleteArtifactByInterface.right()
5589                                                                                         .value());
5590                                                                 }
5591                                                         } else {
5592                                                                 log.trace("No implementation found for operation {} - nothing to delete",
5593                                                                                 operationEntry.getKey());
5594                                                         }
5595                                                 }
5596                                         } else {
5597                                                 log.trace("No operations found for interface type {}", interfaceType);
5598                                         }
5599                                 }
5600                         }
5601                         log.debug("2. Removing properties");
5602                         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = propertyOperation
5603                                         .deleteAllPropertiesAssociatedToNode(NodeTypeEnum.Resource, resourceId);
5604
5605                         if (findPropertiesOfNode.isRight() && findPropertiesOfNode.right().value() != StorageOperationStatus.OK) {
5606                                 log.debug("Failed to remove all properties of resource");
5607                                 if (!inTransaction) {
5608                     janusGraphDao.rollback();
5609                                 }
5610                                 return Either.right(componentsUtils
5611                                                 .getResponseFormat(componentsUtils.convertFromStorageResponse(findPropertiesOfNode.right()
5612                                                                 .value())));
5613                         }
5614
5615                 } else {
5616                         log.debug("Derived from wasn't changed during update");
5617                 }
5618
5619                 if (inTransaction) {
5620                         return Either.left(true);
5621                 }
5622         janusGraphDao.commit();
5623                 return Either.left(true);
5624
5625         }
5626
5627         /**** Auditing *******************/
5628
5629         protected static IElementOperation getElementDao(Class<IElementOperation> class1, ServletContext context) {
5630                 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
5631                                 .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
5632
5633                 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
5634
5635                 return webApplicationContext.getBean(class1);
5636         }
5637
5638         public ICapabilityTypeOperation getCapabilityTypeOperation() {
5639                 return capabilityTypeOperation;
5640         }
5641
5642         @Autowired
5643         public void setCapabilityTypeOperation(ICapabilityTypeOperation capabilityTypeOperation) {
5644                 this.capabilityTypeOperation = capabilityTypeOperation;
5645         }
5646
5647         public Boolean validatePropertiesDefaultValues(Resource resource) {
5648                 log.debug("validate resource properties default values");
5649                 List<PropertyDefinition> properties = resource.getProperties();
5650                 if (properties != null) {
5651                         iterateOverProperties(properties);
5652                 }
5653                 return true;
5654         }
5655
5656         public void iterateOverProperties(List<PropertyDefinition> properties) {
5657                 String type = null;
5658                 String innerType = null;
5659                 for (PropertyDefinition property : properties) {
5660                         if (!propertyOperation.isPropertyTypeValid(property)) {
5661                                 log.info("Invalid type for property {}", property);
5662                                 throw new ByActionStatusComponentException(ActionStatus.INVALID_PROPERTY_TYPE,
5663                                                 property.getType(), property.getName());
5664                         }
5665
5666                         Map<String, DataTypeDefinition> allDataTypes = getAllDataTypes(applicationDataTypeCache);
5667                         type = property.getType();
5668
5669                         if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5670                                 ResponseFormat responseFormat = validateMapOrListPropertyType(property, innerType, allDataTypes);
5671                                 if (responseFormat != null) {
5672                                         break;
5673                                 }
5674                         }
5675                         validateDefaultPropertyValue(property, allDataTypes, type, innerType);
5676                 }
5677         }
5678
5679         private void validateDefaultPropertyValue(PropertyDefinition property,
5680                                                                                           Map<String, DataTypeDefinition> allDataTypes, String type, String innerType) {
5681                 if (!propertyOperation.isPropertyDefaultValueValid(property, allDataTypes)) {
5682                         log.info("Invalid default value for property {}", property);
5683                         ResponseFormat responseFormat;
5684                         if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5685                                 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE,
5686                                                 property.getName(), type, innerType, property.getDefaultValue());
5687                         }
5688                         throw new ByActionStatusComponentException(ActionStatus.INVALID_DEFAULT_VALUE,
5689                                         property.getName(), type, property.getDefaultValue());
5690                 }
5691         }
5692
5693         private ResponseFormat validateMapOrListPropertyType(PropertyDefinition property, String innerType,
5694                                                                                                                  Map<String, DataTypeDefinition> allDataTypes) {
5695                 ResponseFormat responseFormat = null;
5696                 ImmutablePair<String, Boolean> propertyInnerTypeValid = propertyOperation.isPropertyInnerTypeValid(property,
5697                                 allDataTypes);
5698                 innerType = propertyInnerTypeValid.getLeft();
5699                 if (!propertyInnerTypeValid.getRight()
5700                                 .booleanValue()) {
5701                         log.info("Invalid inner type for property {}", property);
5702                         responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_PROPERTY_INNER_TYPE, innerType,
5703                                         property.getName());
5704                 }
5705                 return responseFormat;
5706         }
5707
5708         @Override
5709         public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
5710                 return deleteMarkedComponents(ComponentTypeEnum.RESOURCE);
5711         }
5712
5713         @Override
5714         public ComponentInstanceBusinessLogic getComponentInstanceBL() {
5715                 return componentInstanceBusinessLogic;
5716         }
5717
5718         private String getComponentTypeForResponse(Component component) {
5719                 String componentTypeForResponse = "SERVICE";
5720                 if (component instanceof Resource) {
5721                         componentTypeForResponse = ((Resource) component).getResourceType()
5722                                         .name();
5723                 }
5724                 return componentTypeForResponse;
5725         }
5726
5727         public Either<Resource, ResponseFormat> getLatestResourceFromCsarUuid(String csarUuid, User user) {
5728                 // validate user
5729                 if (user != null) {
5730                         validateUserExists(user);
5731                 }
5732                 // get resource from csar uuid
5733                 Either<Resource, StorageOperationStatus> either = toscaOperationFacade
5734                                 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUuid, "");
5735                 if (either.isRight()) {
5736                         ResponseFormat resp = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND,
5737                                         csarUuid);
5738                         return Either.right(resp);
5739                 }
5740
5741                 return Either.left(either.left()
5742                                 .value());
5743         }
5744
5745         @Override
5746         public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(
5747                         String componentId, String userId) {
5748                 return null;
5749         }
5750
5751         private Map<String, List<CapabilityDefinition>> getValidComponentInstanceCapabilities(String resourceId,
5752                                                                                                                                                                                   Map<String, List<CapabilityDefinition>> defaultCapabilities,
5753                                                                                                                                                                                   Map<String, List<UploadCapInfo>> uploadedCapabilities) {
5754
5755                 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
5756                 uploadedCapabilities.forEach((k, v) -> addValidComponentInstanceCapabilities(k, v, resourceId,
5757                                 defaultCapabilities, validCapabilitiesMap));
5758                 return validCapabilitiesMap;
5759         }
5760
5761         private void addValidComponentInstanceCapabilities(String key, List<UploadCapInfo> capabilities, String resourceId,
5762                                                                                                            Map<String, List<CapabilityDefinition>> defaultCapabilities,
5763                                                                                                            Map<String, List<CapabilityDefinition>> validCapabilitiesMap) {
5764                 String capabilityType = capabilities.get(0)
5765                                 .getType();
5766                 if (defaultCapabilities.containsKey(capabilityType)) {
5767                         CapabilityDefinition defaultCapability = getCapability(resourceId, defaultCapabilities, capabilityType);
5768                         validateCapabilityProperties(capabilities, resourceId, defaultCapability);
5769                         List<CapabilityDefinition> validCapabilityList = new ArrayList<>();
5770                         validCapabilityList.add(defaultCapability);
5771                         validCapabilitiesMap.put(key, validCapabilityList);
5772                 } else {
5773                         throw new ByActionStatusComponentException(ActionStatus.MISSING_CAPABILITY_TYPE, capabilityType);
5774                 }
5775         }
5776
5777         private void validateCapabilityProperties(List<UploadCapInfo> capabilities, String resourceId,
5778                                                                                           CapabilityDefinition defaultCapability) {
5779                 if (CollectionUtils.isEmpty(defaultCapability.getProperties()) && isNotEmpty(capabilities.get(0)
5780                                 .getProperties())) {
5781                         log.debug("Failed to validate capability {} of component {}. Property list is empty. ",
5782                                         defaultCapability.getName(), resourceId);
5783                         log.debug("Failed to update capability property values. Property list of fetched capability {} is empty. ",
5784                                         defaultCapability.getName());
5785                         throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, resourceId);
5786                 } else if (isNotEmpty(capabilities.get(0)
5787                                 .getProperties())) {
5788                         validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, capabilities.get(0));
5789                 }
5790         }
5791
5792         private CapabilityDefinition getCapability(String resourceId,
5793                                                                                            Map<String, List<CapabilityDefinition>> defaultCapabilities, String capabilityType) {
5794                 CapabilityDefinition defaultCapability;
5795                 if (isNotEmpty(defaultCapabilities.get(capabilityType)
5796                                 .get(0)
5797                                 .getProperties())) {
5798                         defaultCapability = defaultCapabilities.get(capabilityType)
5799                                         .get(0);
5800                 } else {
5801                         Either<Component, StorageOperationStatus> getFullComponentRes = toscaOperationFacade
5802                                         .getToscaFullElement(resourceId);
5803                         if (getFullComponentRes.isRight()) {
5804                                 log.debug("Failed to get full component {}. Status is {}. ", resourceId, getFullComponentRes.right()
5805                                                 .value());
5806                                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NOT_FOUND, resourceId);
5807                         }
5808                         defaultCapability = getFullComponentRes.left()
5809                                         .value()
5810                                         .getCapabilities()
5811                                         .get(capabilityType)
5812                                         .get(0);
5813                 }
5814                 return defaultCapability;
5815         }
5816
5817         private void validateUniquenessUpdateUploadedComponentInstanceCapability(CapabilityDefinition defaultCapability,
5818                                                                                                                                                          UploadCapInfo uploadedCapability) {
5819                 List<ComponentInstanceProperty> validProperties = new ArrayList<>();
5820                 Map<String, PropertyDefinition> defaultProperties = defaultCapability.getProperties()
5821                                 .stream()
5822                                 .collect(toMap(PropertyDefinition::getName, Function.identity()));
5823                 List<UploadPropInfo> uploadedProperties = uploadedCapability.getProperties();
5824                 for (UploadPropInfo property : uploadedProperties) {
5825                         String propertyName = property.getName()
5826                                         .toLowerCase();
5827                         String propertyType = property.getType();
5828                         ComponentInstanceProperty validProperty;
5829                         if (defaultProperties.containsKey(propertyName)
5830                                         && propertTypeEqualsTo(defaultProperties, propertyName, propertyType)) {
5831                                 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS, propertyName);
5832                         }
5833                         validProperty = new ComponentInstanceProperty();
5834                         validProperty.setName(propertyName);
5835                         if (property.getValue() != null) {
5836                                 validProperty.setValue(property.getValue()
5837                                                 .toString());
5838                         }
5839                         validProperty.setDescription(property.getDescription());
5840                         validProperty.setPassword(property.isPassword());
5841                         validProperties.add(validProperty);
5842                 }
5843                 defaultCapability.setProperties(validProperties);
5844         }
5845
5846         private boolean propertTypeEqualsTo(Map<String, PropertyDefinition> defaultProperties, String propertyName,
5847                                                                                 String propertyType) {
5848                 return propertyType != null && !defaultProperties.get(propertyName)
5849                                 .getType()
5850                                 .equals(propertyType);
5851         }
5852
5853         private Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
5854                         List<NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle,
5855                         Resource resource, User user) {
5856
5857                 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
5858                                 ArtifactOperationEnum.class);
5859                 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
5860                 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
5861                                 .left(nodeTypeArtifactsToHandle);
5862                 try {
5863                         // add all found Csar artifacts to list to upload
5864                         List<NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
5865                         List<NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
5866                         List<NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
5867                         for (NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
5868                                 ArtifactDefinition foundArtifact;
5869
5870                                 if (!existingArtifactsToHandle.isEmpty()) {
5871                                         foundArtifact = existingArtifactsToHandle.stream()
5872                                                         .filter(a -> a.getArtifactName()
5873                                                                         .equals(currNewArtifact.getArtifactName()))
5874                                                         .findFirst()
5875                                                         .orElse(null);
5876                                         if (foundArtifact != null) {
5877                                                 if (foundArtifact.getArtifactType().equals(currNewArtifact.getArtifactType())) {
5878                                                         if (!foundArtifact.getArtifactChecksum()
5879                                                                         .equals(currNewArtifact.getArtifactChecksum())) {
5880                                                                 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
5881                                                                 // if current artifact already exists, but has
5882                                                                 // different content, add him to the list to
5883                                                                 // update
5884                                                                 artifactsToUpdate.add(currNewArtifact);
5885                                                         }
5886                                                         // remove found artifact from the list of existing
5887                                                         // artifacts to handle, because it was already
5888                                                         // handled
5889                                                         existingArtifactsToHandle.remove(foundArtifact);
5890                                                         // and remove found artifact from the list to
5891                                                         // upload, because it should either be updated or be
5892                                                         // ignored
5893                                                         artifactsToUpload.remove(currNewArtifact);
5894                                                 } else {
5895                                                         log.debug("Can't upload two artifact with the same name {}.",
5896                                                                         currNewArtifact.getArtifactName());
5897                                                         ResponseFormat responseFormat = ResponseFormatManager.getInstance()
5898                                                                         .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR,
5899                                                                                         currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(),
5900                                                                                         foundArtifact.getArtifactType());
5901                                                         AuditingActionEnum auditingAction = artifactsBusinessLogic
5902                                                                         .detectAuditingType(new ArtifactOperationInfo(false, false,
5903                                                                                         ArtifactOperationEnum.CREATE), foundArtifact.getArtifactChecksum());
5904                                                         artifactsBusinessLogic.handleAuditing(auditingAction, resource, resource.getUniqueId(),
5905                                                                         user, null, null, foundArtifact.getUniqueId(), responseFormat,
5906                                                                         resource.getComponentType(), null);
5907                                                         responseWrapper.setInnerElement(responseFormat);
5908                                                         break;
5909                                                 }
5910                                         }
5911                                 }
5912                         }
5913                         if (responseWrapper.isEmpty()) {
5914                                 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
5915                                         if (currArtifact.getIsFromCsar()) {
5916                                                 artifactsToDelete.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5917                                                         currArtifact.getArtifactType(),
5918                                                         currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5919                                                         currArtifact.getIsFromCsar()));
5920                                         } else {
5921                                                 artifactsToUpdate.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5922                                                         currArtifact.getArtifactType(),
5923                                                         currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5924                                                         currArtifact.getIsFromCsar()));
5925
5926                                         }
5927                                 }
5928                         }
5929                         if (responseWrapper.isEmpty()) {
5930                                 if (!artifactsToUpload.isEmpty()) {
5931                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload);
5932                                 }
5933                                 if (!artifactsToUpdate.isEmpty()) {
5934                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate);
5935                                 }
5936                                 if (!artifactsToDelete.isEmpty()) {
5937                                         nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
5938                                 }
5939                         }
5940                         if (!responseWrapper.isEmpty()) {
5941                                 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
5942                         }
5943                 } catch (Exception e) {
5944                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
5945                         responseWrapper.setInnerElement(responseFormat);
5946                         log.debug("Exception occurred when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
5947                 }
5948                 return nodeTypeArtifactsToHandleRes;
5949         }
5950
5951         ImmutablePair<String, String> buildNestedToscaResourceName(final String nodeResourceType,
5952                                                                                                                            final String vfResourceName,
5953                                                                                                                            final String nodeTypeFullName) {
5954                 String actualType;
5955                 String actualVfName;
5956                 if (ResourceTypeEnum.CVFC.name()
5957                         .equals(nodeResourceType)) {
5958                         actualVfName = vfResourceName + ResourceTypeEnum.CVFC.name();
5959                         actualType = ResourceTypeEnum.VFC.name();
5960                 } else {
5961                         actualVfName = vfResourceName;
5962                         actualType = nodeResourceType;
5963                 }
5964                 String nameWithouNamespacePrefix;
5965                 try {
5966                         final String nodeTypeNamePrefix = getNodeTypeNamePrefix(nodeTypeFullName);
5967                         log.debug("####### buildNestedToscaResourceName nodeResourceType {}, vfResourceName {}, "
5968                                         + "nodeTypeFullName {}, actualType {}, vfResourceName {} ",     nodeResourceType, vfResourceName,
5969                                 nodeTypeFullName, actualType, vfResourceName);
5970                         final StringBuilder toscaResourceName = new StringBuilder(nodeTypeNamePrefix);
5971
5972                         if (!nodeTypeFullName.contains(nodeTypeNamePrefix)) {
5973                                 nameWithouNamespacePrefix = nodeTypeFullName;
5974                         } else {
5975                                 nameWithouNamespacePrefix = nodeTypeFullName.substring(nodeTypeNamePrefix.length());
5976                         }
5977                         final String[] findTypes = nameWithouNamespacePrefix.split("\\.");
5978                         String actualName;
5979                         if (nodeResourceType.equalsIgnoreCase(findTypes[0])){
5980                                 actualName = nameWithouNamespacePrefix.substring(nodeResourceType.length());
5981                         } else {
5982                                 actualName = "." + nameWithouNamespacePrefix;
5983                         }
5984
5985                         if (actualName.startsWith(Constants.ABSTRACT)) {
5986                                 toscaResourceName.append(nodeResourceType.toLowerCase()).append('.')
5987                                         .append(ValidationUtils.convertToSystemName(actualVfName));
5988                         } else {
5989                                 toscaResourceName.append(actualType.toLowerCase()).append('.')
5990                                         .append(ValidationUtils.convertToSystemName(actualVfName)).append('.').append(Constants.ABSTRACT);
5991                         }
5992                         final StringBuilder previousToscaResourceName = new StringBuilder(toscaResourceName);
5993                         final String[] actualNames = actualName.split("\\.");
5994                         if (actualNames.length < 3) {
5995                                 return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5996                                         previousToscaResourceName.append(actualName).toString());
5997                         }
5998                         return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5999                                 previousToscaResourceName.append(actualName.substring(actualNames[1].length() + 1)
6000                                         .toLowerCase()).toString());
6001                 } catch (final Exception e) {
6002                         log.debug("Exception occured when buildNestedToscaResourceName, error is:{}", e.getMessage(), e);
6003                         throw new ByActionStatusComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE, vfResourceName);
6004                 }
6005         }
6006
6007         /**
6008          * Extracts a Node Type Name prefix from the given Node Type Name.
6009          *
6010          * @param fullName Node Type Name
6011          * @return Node Type Name Prefix
6012          */
6013         private String getNodeTypeNamePrefix(final String fullName) {
6014                 String tempPrefix = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
6015                 final List<String> definedNodeTypeNamespaceList = getDefinedNodeTypeNamespaceList();
6016                 log.debug("************* getPrefiX fullName {} FROM {}", fullName, definedNodeTypeNamespaceList);
6017                 final Optional<String> validNameSpace = validateNodeTypeNamePrefix(fullName, definedNodeTypeNamespaceList);
6018                 if (validNameSpace.isPresent()) {
6019                         tempPrefix = validNameSpace.get();
6020                 }
6021                 log.debug("************* getNodeTypeNamePrefix return fullName {} ", tempPrefix);
6022                 return tempPrefix;
6023         }
6024
6025         @Override
6026         public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String resourceId,
6027                                                                                                                                                                                                    List<String> dataParamsToReturn) {
6028
6029                 ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
6030                 Either<Resource, StorageOperationStatus> resourceResultEither =
6031                                 toscaOperationFacade.getToscaElement(resourceId,
6032                                 paramsToRetuen);
6033
6034                 if (resourceResultEither.isRight()) {
6035                         if (resourceResultEither.right().value() == StorageOperationStatus.NOT_FOUND) {
6036                                 log.debug("Failed to found resource with id {} ", resourceId);
6037                                 Either
6038                                                 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
6039                         }
6040
6041                         log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn);
6042                         return Either.right(componentsUtils
6043                                         .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceResultEither.right()
6044                                                         .value()), ""));
6045                 }
6046
6047                 Resource resource = resourceResultEither.left().value();
6048                 if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
6049                         ListUtils.emptyIfNull(resource.getInputs())
6050                                         .forEach(input -> input.setConstraints(setInputConstraint(input)));
6051                 }
6052
6053                 UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resource,
6054                                 dataParamsToReturn);
6055                 return Either.left(dataTransfer);
6056         }
6057
6058         @Override
6059         public Either<Component, ActionStatus> shouldUpgradeToLatestDerived(Component clonedComponent) {
6060                 Resource resource = (Resource) clonedComponent;
6061                 if (ModelConverter.isAtomicComponent(resource.getResourceType())) {
6062                         Either<Component, StorageOperationStatus> shouldUpgradeToLatestDerived = toscaOperationFacade
6063                                         .shouldUpgradeToLatestDerived(resource);
6064                         if (shouldUpgradeToLatestDerived.isRight()) {
6065                                 return Either.right(componentsUtils.convertFromStorageResponse(shouldUpgradeToLatestDerived.right()
6066                                                 .value()));
6067                         }
6068                         return Either.left(shouldUpgradeToLatestDerived.left()
6069                                         .value());
6070                 } else {
6071                         return super.shouldUpgradeToLatestDerived(clonedComponent);
6072                 }
6073         }
6074 }