gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.csar;
  22
  23 import com.google.gson.Gson;
  24 import com.google.gson.JsonElement;
  25 import com.google.gson.JsonObject;
  26 import fj.data.Either;
  27 import org.apache.commons.codec.binary.Base64;
  28 import org.apache.commons.collections.CollectionUtils;
  29 import org.apache.commons.collections.MapUtils;
  30 import org.apache.commons.lang3.StringUtils;
  31 import org.apache.commons.lang3.tuple.ImmutablePair;
  32 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  33 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  34 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  35 import org.openecomp.sdc.be.components.impl.BaseBusinessLogic;
  36 import org.openecomp.sdc.be.components.impl.CsarValidationUtils;
  37 import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
  38 import org.openecomp.sdc.be.components.impl.ImportUtils;
  39 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  40 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  41 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  42 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  43 import org.openecomp.sdc.be.config.Configuration.VfModuleProperty;
  44 import org.openecomp.sdc.be.config.ConfigurationManager;
  45 import org.openecomp.sdc.be.dao.api.ActionStatus;
  46 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
  47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  49 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  50 import org.openecomp.sdc.be.impl.ComponentsUtils;
  51 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
  52 import org.openecomp.sdc.be.info.MergedArtifactInfo;
  53 import org.openecomp.sdc.be.model.ArtifactDefinition;
  54 import org.openecomp.sdc.be.model.ComponentParametersView;
  55 import org.openecomp.sdc.be.model.GroupDefinition;
  56 import org.openecomp.sdc.be.model.GroupProperty;
  57 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  58 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  59 import org.openecomp.sdc.be.model.Operation;
  60 import org.openecomp.sdc.be.model.PropertyDefinition;
  61 import org.openecomp.sdc.be.model.Resource;
  62 import org.openecomp.sdc.be.model.User;
  63 import org.openecomp.sdc.be.model.heat.HeatParameterType;
  64 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  65 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  66 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  67 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  68 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  69 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  70 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  71 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  72 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  73 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  74 import org.openecomp.sdc.be.tosca.CsarUtils;
  75 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  76 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  77 import org.openecomp.sdc.common.api.Constants;
  78 import org.openecomp.sdc.common.log.wrappers.Logger;
  79 import org.openecomp.sdc.exception.ResponseFormat;
  80 import org.springframework.beans.factory.annotation.Autowired;
  81
  82 import java.util.ArrayList;
  83 import java.util.Collection;
  84 import java.util.Collections;
  85 import java.util.HashMap;
  86 import java.util.HashSet;
  87 import java.util.List;
  88 import java.util.Map;
  89 import java.util.Map.Entry;
  90 import java.util.Optional;
  91 import java.util.OptionalInt;
  92 import java.util.Scanner;
  93 import java.util.Set;
  94 import java.util.regex.Matcher;
  95 import java.util.regex.Pattern;
  96 import java.util.stream.Collectors;
  97 import java.util.stream.IntStream;
  98
  99 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.FAILED_UPLOAD_ARTIFACT_TO_COMPONENT;
 100 import static org.openecomp.sdc.be.tosca.CsarUtils.ARTIFACTS_PATH;
 101
 102
 103 @org.springframework.stereotype.Component("csarArtifactsAndGroupsBusinessLogic")
 104 public class CsarArtifactsAndGroupsBusinessLogic extends BaseBusinessLogic {
 105
 106     private static final Logger log = Logger.getLogger(CsarArtifactsAndGroupsBusinessLogic.class.getName());
 107     private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMATR_FILE_NAME = "Artifact  file is not in expected formatr, fileName  {}";
 108     private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME = "Artifact  file is not in expected format, fileName  {}";
 109     private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMATR_FILE_NAME1 = "Artifact  file is not in expected formatr, fileName ";
 110     private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME1 = "Artifact  file is not in expected format, fileName ";
 111     private static final String ARTIFACT_INTERNALS_ARE_INVALID = "Artifact internals are invalid";
 112     private static final String ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE = "Artifact with name {} and type {} already exist with type  {}";
 113     private final Gson gson = new Gson();
 114     private static final Pattern pattern = Pattern.compile("\\..(.*?)\\..");
 115     private static final String LABEL_COUNTER_DELIMITER = "[^0-9]+";
 116     protected final ArtifactsBusinessLogic artifactsBusinessLogic;
 117     private final GroupBusinessLogic groupBusinessLogic;
 118
 119     @Autowired
 120     public CsarArtifactsAndGroupsBusinessLogic(IElementOperation elementDao,
 121         IGroupOperation groupOperation,
 122         IGroupInstanceOperation groupInstanceOperation,
 123         IGroupTypeOperation groupTypeOperation,
 124         GroupBusinessLogic groupBusinessLogic,
 125         InterfaceOperation interfaceOperation,
 126         InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
 127         ArtifactsBusinessLogic artifactsBusinessLogic, ArtifactsOperations artifactToscaOperation) {
 128         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
 129             interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
 130         this.artifactsBusinessLogic = artifactsBusinessLogic;
 131         this.groupBusinessLogic = groupBusinessLogic;
 132     }
 133
 134     public Either<Resource, ResponseFormat> createResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
 135             String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdArtifacts) {
 136
 137         log.debug("parseResourceArtifactsInfoFromFile start");
 138         return  parseResourceArtifactsInfoFromFile(resource, artifactsMetaFile, artifactsMetaFileName)
 139                 .left()
 140                 .bind( p-> createResourceArtifacts(csarInfo, resource, p, createdArtifacts))
 141                 .right()
 142                 .map(rf -> { componentsUtils.auditResource(rf, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return rf;})
 143                 .left()
 144                 .bind(this::getResourcetFromGraph);
 145     }
 146
 147
 148     public Either<Resource, ResponseFormat> updateResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
 149             String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdNewArtifacts,
 150             boolean shouldLock, boolean inTransaction){
 151
 152         Resource updatedResource = resource;
 153
 154         Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceInfoFromYamlEither = parseResourceArtifactsInfoFromFile(
 155                 updatedResource, artifactsMetaFile, artifactsMetaFileName);
 156         if (parseResourceInfoFromYamlEither.isRight()) {
 157             ResponseFormat responseFormat = parseResourceInfoFromYamlEither.right().value();
 158             componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
 159             return Either.right(responseFormat);
 160         }
 161
 162         List<GroupDefinition> groups = updatedResource.getGroups();
 163         Map<String, ArtifactDefinition> deploymentArtifact = updatedResource.getDeploymentArtifacts();
 164         if (MapUtils.isEmpty(deploymentArtifact)) {
 165             deleteGroupsByType(groups, Constants.DEFAULT_GROUP_VF_MODULE, updatedResource);
 166             return createResourceArtifacts(csarInfo, updatedResource, parseResourceInfoFromYamlEither.left().value(),
 167                     createdNewArtifacts);
 168         }
 169
 170         List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete = deploymentArtifact.values().stream()
 171                                                                                                   .collect(Collectors.toList());
 172
 173         int labelCounter = createdDeploymentArtifactsAfterDelete
 174                 .stream()
 175                 .map(ArtifactDefinition::getArtifactLabel)
 176                 .filter(this::isLastCharacterInLabelADigit)
 177                 .map(this::getNextInt)
 178                 .flatMapToInt(this::toStream)
 179                 .max()
 180                 .orElse(-1) + 1;
 181
 182         ////////////////////////////////////// create set parsed
 183         ////////////////////////////////////// artifacts///////////////////////////////////////////
 184         Map<String, List<ArtifactTemplateInfo>> parsedArtifactsMap = parseResourceInfoFromYamlEither.left().value();
 185
 186         List<ArtifactTemplateInfo> artifactsWithoutGroups = parsedArtifactsMap.remove(ArtifactTemplateInfo.CSAR_ARTIFACT);
 187         Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection = parsedArtifactsMap.values();
 188
 189         Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> parsedArtifactsPerGroupEither = createArtifactsTemplateCollection(csarInfo, updatedResource, createdNewArtifacts, shouldLock, inTransaction,
 190                 createdDeploymentArtifactsAfterDelete, labelCounter, parsedArifactsCollection);
 191         if(parsedArtifactsPerGroupEither.isRight()){
 192             log.error("Failed to parse artifacts. Status is {} ", parsedArtifactsPerGroupEither.right().value());
 193             return Either.right(parsedArtifactsPerGroupEither.right().value());
 194         }
 195
 196         Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = parsedArtifactsPerGroupEither.left().value();
 197
 198         // find master in group
 199         Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = findMasterArtifactInGroup(
 200                 groups, deploymentArtifact);
 201
 202         ///////////////////////////////// find artifacts to
 203         ///////////////////////////////// delete////////////////////////////////////////////////////
 204
 205
 206         Map<String, List<ArtifactDefinition>> groupToDelete = new HashMap<>();
 207         Set<ArtifactDefinition> artifactsToDelete = findArtifactThatNotInGroupToDelete(parsedGroup, createdDeploymentArtifactsAfterDelete);
 208
 209         Set<ArtifactTemplateInfo> jsonMasterArtifacts = parsedGroup.keySet();
 210         Map<GroupDefinition, MergedArtifactInfo> mergedgroup = mergeGroupInUpdateFlow(groupArtifact, parsedGroup,
 211                 artifactsToDelete, groupToDelete, jsonMasterArtifacts, createdDeploymentArtifactsAfterDelete);
 212
 213         List<ArtifactDefinition> deletedArtifacts = new ArrayList<>();
 214         Either<Resource, ResponseFormat> deletedArtifactsEither = deleteArtifactsInUpdateCsarFlow(
 215                 updatedResource, csarInfo.getModifier(), shouldLock, inTransaction, artifactsToDelete, groupToDelete, deletedArtifacts);
 216         if (deletedArtifactsEither.isRight()) {
 217             log.debug("Failed to delete artifacts. Status is {} ", deletedArtifactsEither.right().value());
 218
 219             return Either.right(deletedArtifactsEither.right().value());
 220
 221         }
 222         updatedResource = deletedArtifactsEither.left().value();
 223
 224         // need to update resource if we updated artifacts
 225         excludeDeletedArtifacts(deletedArtifacts, createdDeploymentArtifactsAfterDelete);
 226
 227         ////////////// dissociate, associate or create
 228         ////////////// artifacts////////////////////////////
 229         Either<Resource, ResponseFormat> assDissotiateEither = associateAndDissociateArtifactsToGroup(csarInfo,
 230                 updatedResource, createdNewArtifacts, labelCounter,
 231                 createdDeploymentArtifactsAfterDelete, mergedgroup, deletedArtifacts);
 232         groups = updatedResource.getGroups();
 233         if (assDissotiateEither.isRight()) {
 234             log.debug("Failed to delete artifacts. Status is {} ", assDissotiateEither.right().value());
 235             return Either.right(assDissotiateEither.right().value());
 236         }
 237
 238         updatedResource = assDissotiateEither.left().value();
 239         deploymentArtifact = updatedResource.getDeploymentArtifacts();
 240
 241         createdDeploymentArtifactsAfterDelete = deploymentArtifact.values().stream()
 242                                                                         .collect(Collectors.toList());
 243
 244         // update vfModule names
 245         Set<GroupDefinition> groupForAssociateWithMembers = mergedgroup.keySet();
 246         Either<Resource, ResponseFormat> validateUpdateVfGroupNamesRes = updateVfModuleNames(createdNewArtifacts,
 247                 updatedResource, groups, createdDeploymentArtifactsAfterDelete, groupForAssociateWithMembers);
 248         if (validateUpdateVfGroupNamesRes != null) return validateUpdateVfGroupNamesRes;
 249
 250         //////////////// create new artifacts in update
 251         //////////////// flow////////////////////////////
 252         List<ArtifactTemplateInfo> newArtifactsGroup = createNewArtifcats(parsedGroup, groupArtifact);
 253         Either<Resource, ResponseFormat> validateGroupNamesRes = handleArtifactsInGroup(csarInfo, createdNewArtifacts,
 254                 updatedResource, groups, createdDeploymentArtifactsAfterDelete, labelCounter, newArtifactsGroup);
 255         if (validateGroupNamesRes != null) return validateGroupNamesRes;
 256
 257         // updatedGroup
 258         Either<Resource, ResponseFormat> updateVersionEither = updateGroupVersion(updatedResource, groupForAssociateWithMembers);
 259         if (updateVersionEither != null) return updateVersionEither;
 260         if (!CollectionUtils.isEmpty(artifactsWithoutGroups)) {
 261             for (ArtifactTemplateInfo t : artifactsWithoutGroups) {
 262                 List<ArtifactTemplateInfo> artifacts = new ArrayList<>();
 263                 artifacts.add(t);
 264                 Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
 265                         artifacts, createdNewArtifacts, createdDeploymentArtifactsAfterDelete, labelCounter);
 266                 if (checkResponse(resStatus)) return resStatus;
 267             }
 268
 269         }
 270
 271         Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(updatedResource.getUniqueId());
 272         return mapResult(eitherGetResource, updatedResource);
 273     }
 274
 275     private Either<Resource, ResponseFormat> handleArtifactsInGroup(CsarInfo csarInfo, List<ArtifactDefinition> createdNewArtifacts,
 276                                                                     Resource updatedResource, List<GroupDefinition> groups,
 277                                                                     List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete,
 278                                                                     int labelCounter, List<ArtifactTemplateInfo> newArtifactsGroup) {
 279         if (!newArtifactsGroup.isEmpty()) {
 280             Collections.sort(newArtifactsGroup, ArtifactTemplateInfo::compareByGroupName);
 281             int startGroupCounter = groupBusinessLogic.getNextVfModuleNameCounter(groups);
 282             Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
 283                     .validateGenerateVfModuleGroupNames(newArtifactsGroup, updatedResource.getSystemName(), startGroupCounter);
 284             if (validateGroupNamesRes.isRight()) {
 285                 return Either.right(validateGroupNamesRes.right().value());
 286             }
 287             Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
 288                     newArtifactsGroup, createdNewArtifacts, createdDeploymentArtifactsAfterDelete, labelCounter);
 289           checkResponse(resStatus);
 290         }
 291         return null;
 292     }
 293
 294     private boolean checkResponse(Either<Resource, ResponseFormat> resStatus) {
 295         return (resStatus.isRight());
 296     }
 297
 298     private Either<Resource, ResponseFormat> updateVfModuleNames(List<ArtifactDefinition> createdNewArtifacts, Resource updatedResource, List<GroupDefinition> groups, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete, Set<GroupDefinition> groupForAssociateWithMembers) {
 299         if (!CollectionUtils.isEmpty(groups)) {
 300             Either<List<GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
 301                     .validateUpdateVfGroupNamesOnGraph(groups, updatedResource);
 302             if (validateUpdateVfGroupNamesRes.isRight()) {
 303                 return Either.right(validateUpdateVfGroupNamesRes.right().value());
 304             }
 305             updateGroupMemebers(groups, groupForAssociateWithMembers, createdNewArtifacts, createdDeploymentArtifactsAfterDelete);
 306         }
 307         return null;
 308     }
 309
 310     private Either<Resource, ResponseFormat> updateGroupVersion(Resource updatedResource, Set<GroupDefinition> groupForAssociateWithMembers) {
 311         if (!groupForAssociateWithMembers.isEmpty()) {
 312
 313             List<GroupDefinition> groupsId = groupForAssociateWithMembers.stream()
 314                                                                          .collect(Collectors.toList());
 315
 316             Either<List<GroupDefinition>, ResponseFormat> updateVersionEither = groupBusinessLogic
 317                     .updateGroups(updatedResource, groupsId, true);
 318             if (updateVersionEither.isRight()) {
 319                 log.debug("Failed to update groups version. Status is {} ", updateVersionEither.right().value());
 320
 321                 return Either.right(updateVersionEither.right().value());
 322
 323             }
 324         }
 325         return null;
 326     }
 327
 328     private IntStream toStream(OptionalInt optionalInt) {
 329         if (optionalInt.isPresent()) {
 330             return IntStream.of(optionalInt.getAsInt());
 331         }
 332         return IntStream.empty();
 333     }
 334
 335     private OptionalInt getNextInt(String artifactLabel) {
 336         try(Scanner scanner = new Scanner(artifactLabel).useDelimiter(LABEL_COUNTER_DELIMITER)) {
 337             if (scanner.hasNextInt()) {
 338                 return OptionalInt.of(scanner.nextInt());
 339             }
 340             return OptionalInt.empty();
 341         }
 342     }
 343
 344     private boolean isLastCharacterInLabelADigit(String artifactLabel) {
 345         return Character.isDigit(artifactLabel.charAt(artifactLabel.length()-1));
 346     }
 347
 348     private Either<Resource, ResponseFormat> mapResult(Either<Resource, StorageOperationStatus> result, Resource resource) {
 349         return result.right()
 350                      .map(status -> componentsUtils.getResponseFormatByResource(
 351                              componentsUtils.convertFromStorageResponse(status), resource));
 352     }
 353
 354
 355     private void updateGroupMemebers(List<GroupDefinition> groups, Set<GroupDefinition> groupForAssociateWithMembers, List<ArtifactDefinition> createdNewArtifacts, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
 356         List<GroupDefinition> heatGroups = collectGroupsWithMembers(groups);
 357
 358         for (GroupDefinition updatedGroupDef : groupForAssociateWithMembers) {
 359             Map<String, String> members = new HashMap<>();
 360             Set<String> artifactsGroup = new HashSet<>();
 361             artifactsGroup.addAll(updatedGroupDef.getArtifacts());
 362             associateMembersToArtifacts(createdNewArtifacts, createdDeploymentArtifactsAfterDelete, heatGroups,
 363                     artifactsGroup, members);
 364
 365             updatedGroupDef.setMembers(members);
 366         }
 367     }
 368
 369
 370     /**
 371      * @param groups
 372      * @return
 373      */
 374     private List<GroupDefinition> collectGroupsWithMembers(List<GroupDefinition> groups) {
 375         return groups.stream()
 376                      .filter(e -> e.getMembers() != null)
 377                      .collect(Collectors.toList());
 378     }
 379
 380
 381     /**
 382      * Exclude deleted Artificats from Deployment Artifcats
 383      * @param deletedArtifacts
 384      * @param createdDeploymentArtifactsAfterDelete
 385      */
 386     private void excludeDeletedArtifacts(List<ArtifactDefinition> deletedArtifacts, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
 387         for (ArtifactDefinition deletedArtifact : deletedArtifacts) {
 388             ArtifactDefinition artToRemove = null;
 389             for (ArtifactDefinition artFromResource : createdDeploymentArtifactsAfterDelete) {
 390                 if (deletedArtifact.getUniqueId().equalsIgnoreCase(artFromResource.getUniqueId())) {
 391                     artToRemove = artFromResource;
 392                     break;
 393                 }
 394             }
 395             if (artToRemove != null) {
 396                 createdDeploymentArtifactsAfterDelete.remove(artToRemove);
 397             }
 398
 399         }
 400     }
 401
 402
 403     private void deleteGroupsByType(List<GroupDefinition> groups, String groupType, Resource resource) {
 404         if(groups != null){
 405             List<GroupDefinition> listToDelete =  groups.stream()
 406                                                         .filter(g -> g.getType().equals(groupType))
 407                                                         .collect(Collectors.toList());
 408
 409             groupBusinessLogic.deleteGroups(resource, listToDelete);
 410         }
 411     }
 412
 413
 414     private List<ArtifactTemplateInfo> createNewArtifcats(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact) {
 415         List<ArtifactTemplateInfo> newArtifactsGroup = new ArrayList<>();
 416
 417         for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
 418             ArtifactTemplateInfo parsedArtifactMaster = parsedGroupSetEntry.getKey();
 419             boolean isNewGroup = true;
 420             for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
 421                     .entrySet()) {
 422                 Map<ArtifactDefinition, List<ArtifactDefinition>> groupArtifacts = groupListEntry.getValue();
 423                 Set<ArtifactDefinition> group = groupArtifacts.keySet();
 424                 for (ArtifactDefinition artifactInfo : group) {
 425                     if (parsedArtifactMaster.getFileName().equalsIgnoreCase(artifactInfo.getArtifactName())) {
 426                         parsedArtifactMaster.setGroupName(groupListEntry.getKey().getName());
 427                         isNewGroup = false;
 428                     }
 429                 }
 430             }
 431             if (isNewGroup) {
 432                 newArtifactsGroup.add(parsedArtifactMaster);
 433             }
 434
 435         }
 436         return newArtifactsGroup;
 437     }
 438
 439     private Set<ArtifactDefinition> findArtifactThatNotInGroupToDelete(
 440             Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
 441             List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
 442         Set<ArtifactDefinition> artifactsToDelete = new HashSet<>();
 443         for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
 444             Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
 445             for (ArtifactTemplateInfo template : artifactsNames) {
 446                 if(template.getType().equals(ArtifactTypeEnum.HEAT_ARTIFACT.getType())){
 447                     Optional<ArtifactDefinition> op = createdDeploymentArtifactsAfterDelete.stream().filter(a -> a.getArtifactName().equalsIgnoreCase(template.getFileName())).findAny();
 448                     if (op.isPresent() && !op.get().getArtifactType().equalsIgnoreCase(template.getType())) {
 449                         artifactsToDelete.add(op.get());
 450                     }
 451                 }
 452             }
 453         }
 454
 455         return artifactsToDelete;
 456     }
 457
 458
 459     private Either<Resource, ResponseFormat> createResourceArtifacts(CsarInfo csarInfo, Resource resource,
 460             Map<String, List<ArtifactTemplateInfo>> artifactsMap,
 461             List<ArtifactDefinition> createdArtifacts) {
 462
 463         Either<Resource, ResponseFormat> resStatus = Either.left(resource);
 464
 465         Collection<List<ArtifactTemplateInfo>> arifactsCollection = artifactsMap.values();
 466
 467         for (List<ArtifactTemplateInfo> groupTemplateList : arifactsCollection) {
 468             if (groupTemplateList != null) {
 469                 resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, resource, groupTemplateList,
 470                         createdArtifacts, 0);
 471                 if (resStatus.isRight()) {
 472                     return resStatus;
 473                 }
 474             }
 475         }
 476
 477         return resStatus;
 478
 479     }
 480
 481
 482     private Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> createArtifactsTemplateCollection(CsarInfo csarInfo, Resource resource,
 483             List<ArtifactDefinition> createdNewArtifacts, boolean shouldLock, boolean inTransaction,
 484             List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete, int labelCounter,
 485             Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection) {
 486
 487         Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = new HashMap<>();
 488
 489         for (List<ArtifactTemplateInfo> parsedGroupTemplateList : parsedArifactsCollection) {
 490
 491             for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
 492                 if (parsedGroupTemplate.getGroupName() != null) {
 493                     parsedGroupTemplate.setGroupName("");
 494                     Set<ArtifactTemplateInfo> parsedArtifactsNames = new HashSet<>();
 495                     parsedArtifactsNames.add(parsedGroupTemplate);
 496                     List<ArtifactTemplateInfo> relatedGroupTemplateList = parsedGroupTemplate.getRelatedArtifactsInfo();
 497                     if (relatedGroupTemplateList != null && !relatedGroupTemplateList.isEmpty()) {
 498                         createArtifactsGroupSet(parsedGroupTemplateList, parsedArtifactsNames);
 499                     }
 500                     parsedGroup.put(parsedGroupTemplate, parsedArtifactsNames);
 501                 } else {
 502                     List<ArtifactTemplateInfo> arrtifacts = new ArrayList<>();
 503                     arrtifacts.add(parsedGroupTemplate);
 504                     Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo,
 505                             resource, arrtifacts, createdNewArtifacts, createdDeploymentArtifactsAfterDelete,
 506                             labelCounter);
 507                     if (resStatus.isRight()) {
 508                         return Either.right(resStatus.right().value());
 509                     }
 510
 511                 }
 512             }
 513
 514         }
 515         return Either.left(parsedGroup);
 516     }
 517
 518     @SuppressWarnings({ "unchecked", "static-access" })
 519     public Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceArtifactsInfoFromFile(
 520             Resource resource, String artifactsMetaFile, String artifactFileName) {
 521
 522         try {
 523             JsonObject jsonElement = new JsonObject();
 524             jsonElement = gson.fromJson(artifactsMetaFile, jsonElement.getClass());
 525
 526             JsonElement importStructureElement = jsonElement.get(Constants.IMPORT_STRUCTURE);
 527             if (importStructureElement == null || importStructureElement.isJsonNull()) {
 528                 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
 529                 BeEcompErrorManager.getInstance().logInternalDataError(
 530                         ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 531                         ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 532                 return Either
 533                         .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
 534             }
 535
 536             Map<String, List<Map<String, Object>>> artifactTemplateMap;
 537             artifactTemplateMap = ComponentsUtils.parseJsonToObject(importStructureElement.toString(), HashMap.class);
 538             if (artifactTemplateMap.isEmpty()) {
 539                 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
 540                 BeEcompErrorManager.getInstance().logInternalDataError(
 541                         ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 542                         ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 543                 return Either
 544                         .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
 545             }
 546
 547             Set<String> artifactsTypeKeys = artifactTemplateMap.keySet();
 548             Map<String, List<ArtifactTemplateInfo>> artifactsMap = new HashMap<>();
 549             List<ArtifactTemplateInfo> allGroups = new ArrayList<>();
 550             for (String artifactsTypeKey : artifactsTypeKeys) {
 551
 552                 Either <List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListEither = parseArtifactTemplateList(artifactFileName,
 553                         artifactTemplateMap, allGroups, artifactsTypeKey);
 554                 if(artifactTemplateInfoListEither.isRight()){
 555                     return Either.right(artifactTemplateInfoListEither.right().value());
 556                 }
 557                 artifactsMap.put(artifactsTypeKey, artifactTemplateInfoListEither.left().value());
 558             }
 559             int counter = groupBusinessLogic.getNextVfModuleNameCounter(resource.getGroups());
 560             Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
 561                     .validateGenerateVfModuleGroupNames(allGroups, resource.getSystemName(), counter);
 562             if (validateGroupNamesRes.isRight()) {
 563                 return Either.right(validateGroupNamesRes.right().value());
 564             }
 565             return Either.left(artifactsMap);
 566         } catch (Exception e) {
 567             log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
 568             log.debug("failed with exception.", e);
 569             BeEcompErrorManager.getInstance().logInternalDataError(
 570                     ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 571                     ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 572             return Either.right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
 573         }
 574
 575     }
 576
 577     private Either< List<ArtifactTemplateInfo>, ResponseFormat> parseArtifactTemplateList(String artifactFileName,
 578             Map<String, List<Map<String, Object>>> artifactTemplateMap, List<ArtifactTemplateInfo> allGroups,
 579             String artifactsTypeKey) {
 580         List<Map<String, Object>> o = artifactTemplateMap.get(artifactsTypeKey);
 581         Either<List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListPairStatus = createArtifactTemplateInfoModule(
 582                 artifactsTypeKey, o);
 583         if (artifactTemplateInfoListPairStatus.isRight()) {
 584             log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
 585             BeEcompErrorManager.getInstance().logInternalDataError(
 586                     ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 587                     ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 588             return Either.right(artifactTemplateInfoListPairStatus.right().value());
 589         }
 590         List<ArtifactTemplateInfo> artifactTemplateInfoList = artifactTemplateInfoListPairStatus.left().value();
 591         if (artifactTemplateInfoList == null) {
 592             log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
 593             BeEcompErrorManager.getInstance().logInternalDataError(
 594                     ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 595                     ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 596             return Either.right(
 597                     componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
 598
 599         }
 600         if (!artifactsTypeKey.equalsIgnoreCase(ArtifactTemplateInfo.CSAR_ARTIFACT)) {
 601             allGroups.addAll(artifactTemplateInfoList);
 602         }
 603         return Either.left(artifactTemplateInfoList);
 604     }
 605
 606     private Either<List<ArtifactTemplateInfo>, ResponseFormat> createArtifactTemplateInfoModule(String artifactsTypeKey,
 607             List<Map<String, Object>> jsonObject) {
 608         List<ArtifactTemplateInfo> artifactTemplateInfoList = new ArrayList<>();
 609         for (Map<String, Object> o : jsonObject) {
 610             Either<ArtifactTemplateInfo, ResponseFormat> artifacttemplateInfoStatus = ArtifactTemplateInfo
 611                     .createArtifactTemplateInfoFromJson(componentsUtils, artifactsTypeKey, o, artifactTemplateInfoList,
 612                             null);
 613             if (artifacttemplateInfoStatus.isRight()) {
 614                 return Either.right(artifacttemplateInfoStatus.right().value());
 615             }
 616
 617             ArtifactTemplateInfo artifacttemplateInfo = artifacttemplateInfoStatus.left().value();
 618             if (artifacttemplateInfo != null) {
 619                 artifactTemplateInfoList.add(artifacttemplateInfo);
 620             }
 621
 622         }
 623         return Either.left(artifactTemplateInfoList);
 624     }
 625
 626
 627
 628     private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
 629             Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
 630             List<ArtifactDefinition> createdArtifacts, int labelCounter) {
 631         List<GroupDefinition> createdGroups = resource.getGroups();
 632         List<GroupDefinition> heatGroups = null;
 633         if (!CollectionUtils.isEmpty(createdGroups)) {
 634             heatGroups = collectGroupsWithMembers(createdGroups);
 635         }
 636         List<GroupDefinition> needToCreate = new ArrayList<>();
 637         for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
 638             String groupName = groupTemplateInfo.getGroupName();
 639             Set<String> artifactsGroup = new HashSet<>();
 640             Set<String> artifactsUUIDGroup = new HashSet<>();
 641
 642             log.debug("createDeploymentArtifactsFromCsar start");
 643             Either<Resource, ResponseFormat> resStatus = createDeploymentArtifactFromCsar(csarInfo, ARTIFACTS_PATH, resource, artifactsGroup,
 644                     artifactsUUIDGroup, groupTemplateInfo, createdArtifacts, labelCounter);
 645             log.debug("createDeploymentArtifactsFromCsar end");
 646             if (resStatus.isRight()) {
 647                 return resStatus;
 648             }
 649             Map<String, ArtifactDefinition> createdArtifactsMap = createdArtifacts.stream().collect(Collectors.toMap(artifact -> artifact.getArtifactLabel(), artifact -> artifact));
 650             resource.setDeploymentArtifacts(createdArtifactsMap);
 651             if (groupName != null && !groupName.isEmpty()) {
 652
 653                 Either<GroupDefinition, ResponseFormat> groupDefinitionEither = buildGroupDefinition(createdArtifacts, heatGroups, groupTemplateInfo,
 654                         groupName, artifactsGroup, artifactsUUIDGroup);
 655                 if (groupDefinitionEither.isRight()) {
 656                     return Either.right(groupDefinitionEither.right().value());
 657                 }
 658                 needToCreate.add(groupDefinitionEither.left().value());
 659             }
 660         }
 661         Map<String, ArtifactDefinition> createdArtifactsMap = createdArtifacts.stream().collect(Collectors.toMap(artifact -> artifact.getArtifactLabel(), artifact -> artifact));
 662         resource.setDeploymentArtifacts(createdArtifactsMap);
 663
 664         Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic
 665                 .addGroups(resource, needToCreate, false);
 666         if (createGroups.isRight()) {
 667             return Either.right(createGroups.right().value());
 668         }
 669
 670         return Either.left(resource);
 671     }
 672
 673     private Either<GroupDefinition, ResponseFormat>  buildGroupDefinition(List<ArtifactDefinition> createdArtifacts,
 674             List<GroupDefinition> heatGroups, ArtifactTemplateInfo groupTemplateInfo, String groupName,
 675             Set<String> artifactsGroup, Set<String> artifactsUUIDGroup) {
 676
 677         Map<String, String> members = new HashMap<>();
 678
 679         associateMembersToArtifacts(createdArtifacts, null, heatGroups, artifactsGroup, members);
 680
 681         List<String> artifactsList = new ArrayList<>(artifactsGroup);
 682         List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
 683
 684         GroupDefinition groupDefinition = new GroupDefinition();
 685         groupDefinition.setName(groupName);
 686         groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
 687         groupDefinition.setArtifacts(artifactsList);
 688         groupDefinition.setArtifactsUuid(artifactsUUIDList);
 689
 690         if (!members.isEmpty()) {
 691             groupDefinition.setMembers(members);
 692         }
 693         List<GroupProperty> properties = new ArrayList<>();
 694         GroupProperty prop = new GroupProperty();
 695         prop.setName(Constants.IS_BASE);
 696         prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
 697         properties.add(prop);
 698         Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
 699                 .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
 700         if (getLatestGroupTypeRes.isRight()) {
 701             return Either.right(componentsUtils.getResponseFormat(
 702                     componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
 703         }
 704         properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
 705                 createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
 706         groupDefinition.convertFromGroupProperties(properties);
 707         log.debug("createGroup start");
 708         return Either.left(groupDefinition);
 709     }
 710
 711     private Either<Resource, ResponseFormat> createDeploymentArtifactFromCsar(CsarInfo csarInfo, String artifactPath,
 712             Resource resource, Set<String> artifactsGroup, Set<String> artifactsUUIDGroup,
 713             ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts, int labelCounter) {
 714         Either<Resource, ResponseFormat> resStatus = Either.left(resource);
 715
 716         String artifactUid = "";
 717         String artifactEnvUid = "";
 718         String artifactUUID = "";
 719
 720
 721         // check if artifacts already exist
 722         Either<ArtifactDefinition, ResponseFormat> createdArtifactEther = checkIfArtifactAlreadyExist(artifactTemplateInfo, createdArtifacts);
 723         if(createdArtifactEther.isRight()){
 724             return Either.right(createdArtifactEther.right().value());
 725         }
 726         ArtifactDefinition createdArtifact = createdArtifactEther.left().value();
 727         if(createdArtifact == null){
 728
 729             Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
 730                     artifactPath, artifactTemplateInfo, createdArtifacts, labelCounter);
 731             if (newArtifactEither.isRight()) {
 732                 resStatus = Either.right(newArtifactEither.right().value());
 733                 return resStatus;
 734             }
 735             ArtifactDefinition newArtifact = newArtifactEither.left().value();
 736             artifactUid = newArtifact.getUniqueId();
 737             artifactUUID = newArtifact.getArtifactUUID();
 738
 739             final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(newArtifact.getArtifactType());
 740             if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
 741                     || artifactType == ArtifactTypeEnum.HEAT_VOL) {
 742                 ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
 743                         .createHeatEnvPlaceHolder(createdArtifacts, newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
 744                                 resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
 745                                 csarInfo.getModifier(), resource, null);
 746                 artifactEnvUid = createHeatEnvPlaceHolder.getUniqueId();
 747             }
 748         }else{
 749             artifactUid = createdArtifact.getUniqueId();
 750             artifactUUID = createdArtifact.getArtifactUUID();
 751             artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
 752         }
 753         artifactsGroup.add(artifactUid);
 754         artifactsUUIDGroup.add(artifactUUID);
 755         if (!artifactEnvUid.isEmpty()) {
 756             artifactsGroup.add(artifactEnvUid);
 757         }
 758
 759         List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
 760         if (relatedArtifacts != null) {
 761             for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
 762                 resStatus = createDeploymentArtifactFromCsar(csarInfo, artifactPath, resource, artifactsGroup,
 763                         artifactsUUIDGroup, relatedArtifactTemplateInfo, createdArtifacts, labelCounter);
 764                 if (resStatus.isRight()) {
 765                     return resStatus;
 766                 }
 767             }
 768         }
 769         return resStatus;
 770     }
 771
 772     private String checkAndGetHeatEnvId(ArtifactDefinition createdArtifact) {
 773         String artifactEnvUid = "";
 774         final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(createdArtifact.getArtifactType());
 775         if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
 776                 || artifactType == ArtifactTypeEnum.HEAT_VOL) {
 777             artifactEnvUid = createdArtifact.getUniqueId() + ArtifactsBusinessLogic.HEAT_ENV_SUFFIX;
 778         }
 779         return artifactEnvUid;
 780     }
 781
 782     private Either<ArtifactDefinition, ResponseFormat> checkIfArtifactAlreadyExist(ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts){
 783
 784         ArtifactDefinition res = null;
 785         String artifactFileName = artifactTemplateInfo.getFileName();
 786         Optional<ArtifactDefinition> op = createdArtifacts.stream().filter(a -> a.getArtifactName().equals(artifactFileName)).findAny();
 787         if(op.isPresent()){
 788             res = op.get();
 789             if (!res.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
 790                 log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
 791                         artifactTemplateInfo.getType(), res.getArtifactType());
 792                 BeEcompErrorManager.getInstance().logInternalDataError(
 793                         ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
 794                         ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
 795                 return Either.right(componentsUtils.getResponseFormat(
 796                         ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
 797                         artifactTemplateInfo.getType(), res.getArtifactType()));
 798             }
 799         }
 800         return Either.left(res);
 801
 802
 803     }
 804
 805     private Either<ArtifactDefinition, ResponseFormat> createDeploymentArtifact(CsarInfo csarInfo, Resource resource,
 806                                                                                 String artifactPath, ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts,
 807                                                                                 int label) {
 808         int updatedlabel = label;
 809         final String artifactFileName = artifactTemplateInfo.getFileName();
 810         Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContentStatus = CsarValidationUtils
 811                 .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(), artifactPath + artifactFileName,
 812                         artifactFileName, componentsUtils);
 813         if (artifactContentStatus.isRight()) {
 814             return Either.right(artifactContentStatus.right().value());
 815         }
 816         updatedlabel += createdArtifacts.size();
 817
 818         Map<String, Object> json = ArtifactUtils.buildJsonForArtifact(artifactTemplateInfo,
 819                 artifactContentStatus.left().value().getValue(), updatedlabel, true);
 820
 821         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
 822                 resource, csarInfo.getModifier(), json,
 823                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE));
 824
 825         if (uploadArtifactToService.isRight()) {
 826             return Either.right(uploadArtifactToService.right().value());
 827         }
 828
 829         ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
 830         if (currentInfo.getHeatParameters() != null) {
 831
 832             Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
 833                     artifactTemplateInfo, currentInfo, false);
 834             if (updateEnvEither.isRight()) {
 835                 log.debug("failed to update parameters to artifact {}", artifactFileName);
 836                 return Either.right(updateEnvEither.right().value());
 837
 838             }
 839             currentInfo = updateEnvEither.left().value();
 840
 841         }
 842
 843         createdArtifacts.add(currentInfo);
 844
 845         return Either.left(currentInfo);
 846
 847     }
 848
 849
 850
 851     private Either<ArtifactDefinition, ResponseFormat> updateHeatParamsFromCsar(Resource resource, CsarInfo csarInfo,
 852             ArtifactTemplateInfo artifactTemplateInfo, ArtifactDefinition currentInfo, boolean isUpdateEnv) {
 853
 854         Resource updatedResource = resource;
 855         Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
 856         if (artifactTemplateInfo.getEnv() != null && !artifactTemplateInfo.getEnv().isEmpty()) {
 857
 858             Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactParamsStatus = CsarValidationUtils
 859                     .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
 860                             CsarUtils.ARTIFACTS_PATH + artifactTemplateInfo.getEnv(), artifactTemplateInfo.getEnv(),
 861                             componentsUtils);
 862             if (artifactParamsStatus.isRight()) {
 863                 resStatus = Either.right(artifactParamsStatus.right().value());
 864                 return resStatus;
 865             }
 866             Either<List<HeatParameterDefinition>, ResponseFormat> propsStatus = extractHeatParameters(
 867                     ArtifactTypeEnum.HEAT_ENV.getType(), artifactTemplateInfo.getEnv(),
 868                     artifactParamsStatus.left().value().getValue(), false);
 869
 870             if (propsStatus.isLeft()) {
 871                 List<HeatParameterDefinition> updatedHeatEnvParams = propsStatus.left().value();
 872                 resStatus = updateHeatParams(updatedResource, currentInfo, updatedHeatEnvParams);
 873                 if (resStatus.isRight()) {
 874                     return resStatus;
 875                 }
 876
 877             }
 878         }
 879         if (isUpdateEnv) {
 880             Map<String, ArtifactDefinition> artifacts = updatedResource.getDeploymentArtifacts();
 881             Optional<ArtifactDefinition> op = artifacts.values().stream().filter(
 882                     p -> p.getGeneratedFromId() != null && p.getGeneratedFromId().equals(currentInfo.getUniqueId()))
 883                     .findAny();
 884             if (op.isPresent()) {
 885                 ArtifactDefinition artifactInfoHeatEnv = op.get();
 886                 artifactInfoHeatEnv.setHeatParamUpdated(true);
 887                 Either<ArtifactDefinition, StorageOperationStatus> updateArtifactOnResource = artifactToscaOperation
 888                         .updateArtifactOnResource(artifactInfoHeatEnv, updatedResource,
 889                                 artifactInfoHeatEnv.getUniqueId(), null, null,true);
 890                 if (updateArtifactOnResource.isRight()) {
 891                     log.debug("Failed to update heat env on CSAR flow for component {} artifact {} label {}",
 892                             updatedResource.getUniqueId(), artifactInfoHeatEnv.getUniqueId(),
 893                             artifactInfoHeatEnv.getArtifactLabel());
 894                     return Either.right(componentsUtils.getResponseFormat(
 895                             componentsUtils.convertFromStorageResponse(updateArtifactOnResource.right().value())));
 896                 }
 897                 resource.getDeploymentArtifacts().put(updateArtifactOnResource.left().value().getArtifactLabel(), updateArtifactOnResource.left().value());
 898                 resStatus = Either.left(updateArtifactOnResource.left().value());
 899             }
 900
 901         }
 902         return resStatus;
 903     }
 904
 905     private Either<List<HeatParameterDefinition>, ResponseFormat> extractHeatParameters(String artifactType,
 906             String fileName, byte[] content, boolean is64Encoded) {
 907         // extract heat parameters
 908         String heatDecodedPayload = is64Encoded ? new String(Base64.decodeBase64(content)) : new String(content);
 909         Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils
 910                 .getHeatParamsWithoutImplicitTypes(heatDecodedPayload, artifactType);
 911         if (heatParameters.isRight()) {
 912             log.debug("File {} is not in expected key-value form in csar ", fileName);
 913             BeEcompErrorManager.getInstance().logInternalDataError(
 914                     "File " + fileName + " is not in expected key-value form in csar ", "CSAR internals are invalid",
 915                     ErrorSeverity.ERROR);
 916             return Either
 917                     .right(componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, fileName));
 918
 919         }
 920         return Either.left(heatParameters.left().value());
 921
 922     }
 923
 924     private Either<ArtifactDefinition, ResponseFormat> updateHeatParams(Resource resource,
 925             ArtifactDefinition currentInfo, List<HeatParameterDefinition> updatedHeatEnvParams) {
 926
 927         Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
 928         List<HeatParameterDefinition> currentHeatEnvParams = currentInfo.getListHeatParameters();
 929
 930         if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty() && currentHeatEnvParams != null
 931                 && !currentHeatEnvParams.isEmpty()) {
 932
 933             String paramName;
 934             for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
 935
 936                 paramName = heatEnvParam.getName();
 937                 for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
 938                     if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
 939
 940                         String updatedParamValue = heatEnvParam.getCurrentValue();
 941                         if (updatedParamValue == null) {
 942                             updatedParamValue = heatEnvParam.getDefaultValue();
 943                         }
 944                         HeatParameterType paramType = HeatParameterType.isValidType(currHeatParam.getType());
 945                         if (!paramType.getValidator().isValid(updatedParamValue, null)) {
 946                             ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
 947                             ResponseFormat responseFormat = componentsUtils.getResponseFormat(status,
 948                                     ArtifactTypeEnum.HEAT_ENV.getType(), paramType.getType(), paramName);
 949                             resStatus = Either.right(responseFormat);
 950                             return resStatus;
 951                         }
 952                         currHeatParam.setCurrentValue(
 953                                 paramType.getConverter().convert(updatedParamValue, null, null));
 954
 955                         break;
 956                     }
 957                 }
 958             }
 959             currentInfo.setListHeatParameters(currentHeatEnvParams);
 960             Either<ArtifactDefinition, StorageOperationStatus> updateArtifactOnResource = artifactToscaOperation
 961                     .updateArtifactOnResource(currentInfo, resource, currentInfo.getUniqueId(),
 962                             null, null, true);
 963             if (updateArtifactOnResource.isRight()) {
 964                 log.debug(
 965                         "Failed to update heat parameters of heat on CSAR flow for component {} artifact {} label {}",
 966                         resource.getUniqueId(), currentInfo.getUniqueId(), currentInfo.getArtifactLabel());
 967                 return Either.right(componentsUtils.getResponseFormat(
 968                         componentsUtils.convertFromStorageResponse(updateArtifactOnResource.right().value())));
 969             }
 970             resource.getDeploymentArtifacts().put(currentInfo.getArtifactLabel(), currentInfo);
 971             resStatus = Either.left(updateArtifactOnResource.left().value());
 972         }
 973         return resStatus;
 974     }
 975
 976     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> createOrUpdateCsarArtifactFromJson(
 977             Resource resource, User user, Map<String, Object> json, ArtifactOperationInfo operation) {
 978
 979         String jsonStr = gson.toJson(json);
 980         ArtifactDefinition artifactDefinitionFromJson = RepresentationUtils.convertJsonToArtifactDefinition(jsonStr,
 981                 ArtifactDefinition.class, false);
 982
 983         Either<ArtifactDefinition, Operation> result;
 984         try {
 985              result = artifactsBusinessLogic.handleLoadedArtifact(
 986                     resource, user, operation, false, true, ComponentTypeEnum.RESOURCE, artifactDefinitionFromJson);
 987         } catch (ComponentException e) {
 988             log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, ComponentTypeEnum.RESOURCE, resource.getName());
 989             return Either.right(componentsUtils.getResponseFormat(e));
 990         } catch (Exception e) {
 991             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 992             log.debug("Exception occurred when createOrUpdateCsarArtifactFromJson, error is:{}", e.getMessage(), e);
 993             return Either.right(responseFormat);
 994         }
 995         return Either.left(result);
 996     }
 997
 998     private void associateMembersToArtifacts(List<ArtifactDefinition> createdArtifacts,
 999             List<ArtifactDefinition> artifactsFromResource, List<GroupDefinition> heatGroups,
1000             Set<String> artifactsGroup, Map<String, String> members) {
1001         if (heatGroups != null && !heatGroups.isEmpty()) {
1002             for (GroupDefinition heatGroup : heatGroups) {
1003                 List<GroupProperty> grpoupProps = heatGroup.convertToGroupProperties();
1004                 if (grpoupProps != null) {
1005                     associateMembersToVFgroups(createdArtifacts, artifactsFromResource, grpoupProps, artifactsGroup, heatGroup, members);
1006                 }
1007             }
1008         }
1009     }
1010
1011     private void associateMembersToVFgroups(List<ArtifactDefinition> createdArtifacts, List<ArtifactDefinition> artifactsFromResource, List<GroupProperty> grpoupProps, Set<String> artifactsGroup, GroupDefinition heatGroup, Map<String, String> members){
1012         Optional<GroupProperty> op = grpoupProps.stream()
1013                 .filter(p -> p.getName().equals(Constants.HEAT_FILE_PROPS)).findAny();
1014         if (op.isPresent()) {
1015             GroupProperty prop = op.get();
1016             String heatFileNAme = prop.getValue();
1017             if (null == heatFileNAme || heatFileNAme.isEmpty()) {
1018                 return;
1019             }
1020             List<ArtifactDefinition> artifacts = new ArrayList<>();
1021             for (String artifactId : artifactsGroup) {
1022                 Optional<ArtifactDefinition> opArt = createdArtifacts.stream()
1023                         .filter(p -> p.getUniqueId().equals(artifactId)).findAny();
1024                 opArt.ifPresent(artifacts::add);
1025                 if (artifactsFromResource != null) {
1026                     opArt = artifactsFromResource.stream().filter(p -> p.getUniqueId().equals(artifactId))
1027                             .findAny();
1028                     opArt.ifPresent(artifacts::add);
1029                 }
1030             }
1031             Optional<ArtifactDefinition> resOp = artifacts.stream()
1032                     .filter(p -> heatFileNAme.contains(p.getArtifactName())).findAny();
1033             resOp.ifPresent(artifactDefinition -> members.putAll(heatGroup.getMembers()));
1034         }
1035     }
1036
1037     public List<GroupProperty> createVfModuleAdditionalProperties(boolean isBase, String moduleName,
1038             List<GroupProperty> properties, List<ArtifactDefinition> deploymentArtifacts, List<String> artifactsInGroup,
1039             GroupTypeDefinition groupType) {
1040         Map<String, VfModuleProperty> vfModuleProperties = ConfigurationManager.getConfigurationManager()
1041                 .getConfiguration().getVfModuleProperties();
1042         vfModuleProperties.entrySet().forEach(p -> {
1043             GroupProperty prop = new GroupProperty();
1044             prop.setName(p.getKey());
1045             if (isBase) {
1046                 prop.setValue(p.getValue().getForBaseModule());
1047                 prop.setDefaultValue(p.getValue().getForBaseModule());
1048             } else {
1049                 prop.setValue(p.getValue().getForNonBaseModule());
1050                 prop.setDefaultValue(p.getValue().getForNonBaseModule());
1051             }
1052             properties.add(prop);
1053
1054         });
1055         GroupProperty proplabel = new GroupProperty();
1056         proplabel.setName("vf_module_label");
1057
1058         Matcher matcher = pattern.matcher(moduleName);
1059
1060         if (matcher.find()) {
1061             proplabel.setValue(matcher.group(1));
1062             proplabel.setDefaultValue(matcher.group(1));
1063         } else {
1064             proplabel.setValue(moduleName);
1065             proplabel.setDefaultValue(moduleName);
1066         }
1067         properties.add(proplabel);
1068
1069         GroupProperty propvolume = new GroupProperty();
1070         propvolume.setName("volume_group");
1071         boolean isVolume = false;
1072         for (String artifactId : artifactsInGroup) {
1073             ArtifactDefinition artifactDef = null;
1074             artifactDef = ArtifactUtils.findArtifactInList(deploymentArtifacts, artifactId);
1075             if (artifactDef != null
1076                     && artifactDef.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) {
1077                 isVolume = true;
1078                 break;
1079             }
1080         }
1081         propvolume.setValue(String.valueOf(isVolume));
1082         propvolume.setDefaultValue(String.valueOf(isVolume));
1083         properties.add(propvolume);
1084         mergeWithGroupTypeProperties(properties, groupType.getProperties());
1085         return properties;
1086     }
1087
1088     private void mergeWithGroupTypeProperties(List<GroupProperty> properties,
1089             List<PropertyDefinition> groupTypeProperties) {
1090
1091         Map<String, GroupProperty> propertiesMap = properties.stream()
1092                 .collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p));
1093         for (PropertyDefinition groupTypeProperty : groupTypeProperties) {
1094             if (!propertiesMap.containsKey(groupTypeProperty.getName())) {
1095                 properties.add(new GroupProperty(groupTypeProperty));
1096             }
1097         }
1098     }
1099
1100     private Map<GroupDefinition, MergedArtifactInfo> mergeGroupInUpdateFlow(
1101             Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact,
1102             Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition> artifactsToDelete,
1103             Map<String, List<ArtifactDefinition>> groupToDelete, Set<ArtifactTemplateInfo> jsonMasterArtifacts,
1104             List<ArtifactDefinition> createdDeploymentArtifacts) {
1105         Map<GroupDefinition, MergedArtifactInfo> mergedgroup = new HashMap<>();
1106         for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
1107                 .entrySet()) {
1108             Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap = groupListEntry.getValue();
1109             boolean isNeedToDeleteGroup = true;
1110             List<ArtifactDefinition> listToDelete = null;
1111             for (ArtifactDefinition maserArtifact : createdArtifactMap.keySet()) {
1112                 listToDelete = prepareArtifactsToDelete(parsedGroup, artifactsToDelete, createdDeploymentArtifacts, createdArtifactMap, maserArtifact);
1113                 if (artifactsToDelete != null && !artifactsToDelete.isEmpty()) {
1114                     GroupDefinition group = groupListEntry.getKey();
1115                     deleteArtifacts(artifactsToDelete, group);
1116
1117                 }
1118
1119                 for (ArtifactTemplateInfo jsonMasterArtifact : jsonMasterArtifacts) {
1120                     isNeedToDeleteGroup = isNeedToDeleteGroup(mergedgroup, groupListEntry, createdArtifactMap, isNeedToDeleteGroup, maserArtifact, jsonMasterArtifact);
1121                 }
1122
1123             }
1124             if (isNeedToDeleteGroup) {
1125                 groupToDelete.put(groupListEntry.getKey().getUniqueId(), listToDelete);
1126             }
1127
1128         }
1129         return mergedgroup;
1130     }
1131
1132     private boolean isNeedToDeleteGroup(Map<GroupDefinition, MergedArtifactInfo> mergedgroup, Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry, Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap, boolean isNeedToDeleteGroup, ArtifactDefinition maserArtifact, ArtifactTemplateInfo jsonMasterArtifact) {
1133         if (maserArtifact.getArtifactName().equalsIgnoreCase(jsonMasterArtifact.getFileName())) {
1134             MergedArtifactInfo mergedGroup = new MergedArtifactInfo();
1135             mergedGroup.setJsonArtifactTemplate(jsonMasterArtifact);
1136             mergedGroup.setCreatedArtifact(createdArtifactMap.get(maserArtifact));
1137             mergedgroup.put(groupListEntry.getKey(), mergedGroup);
1138             isNeedToDeleteGroup = false;
1139
1140         }
1141         return isNeedToDeleteGroup;
1142     }
1143
1144     private List<ArtifactDefinition> prepareArtifactsToDelete(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition> artifactsToDelete, List<ArtifactDefinition> createdDeploymentArtifacts, Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap, ArtifactDefinition maserArtifact) {
1145         List<ArtifactDefinition> listToDelete;
1146         listToDelete = createdArtifactMap.get(maserArtifact);
1147         for (ArtifactDefinition artToDelete : listToDelete) {
1148             findArtifactToDelete(parsedGroup, artifactsToDelete, artToDelete, createdDeploymentArtifacts);
1149         }
1150         return listToDelete;
1151     }
1152
1153     private void deleteArtifacts(Set<ArtifactDefinition> artifactsToDelete, GroupDefinition group) {
1154         for (ArtifactDefinition artifactDefinition : artifactsToDelete) {
1155             if (CollectionUtils.isNotEmpty(group.getArtifacts())
1156                     && group.getArtifacts().contains(artifactDefinition.getUniqueId())) {
1157                 group.getArtifacts().remove(artifactDefinition.getUniqueId());
1158
1159             }
1160             if (CollectionUtils.isNotEmpty(group.getArtifactsUuid())
1161                     && group.getArtifactsUuid().contains(artifactDefinition.getArtifactUUID())) {
1162                 group.getArtifactsUuid().remove(artifactDefinition.getArtifactUUID());
1163
1164             }
1165         }
1166     }
1167
1168     private void findArtifactToDelete(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
1169             Set<ArtifactDefinition> artifactsToDelete, ArtifactDefinition artifact,
1170             List<ArtifactDefinition> createdDeploymentArtifacts) {
1171         boolean isNeedToDeleteArtifact = true;
1172         String artifactType = artifact.getArtifactType();
1173         ArtifactDefinition generatedFromArt = null;
1174         if (artifact.getGeneratedFromId() != null && !artifact.getGeneratedFromId().isEmpty()) {
1175             Optional<ArtifactDefinition> op = createdDeploymentArtifacts.stream()
1176                     .filter(p -> p.getUniqueId().equals(artifact.getGeneratedFromId())).findAny();
1177             if (op.isPresent()) {
1178                 generatedFromArt = op.get();
1179             }
1180
1181         }
1182
1183         isNeedToDeleteArtifact(parsedGroup, artifactsToDelete, artifact, isNeedToDeleteArtifact, artifactType, generatedFromArt);
1184     }
1185
1186     private void isNeedToDeleteArtifact(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition>
1187             artifactsToDelete, ArtifactDefinition artifact, boolean isNeedToDeleteArtifact, String artifactType, ArtifactDefinition generatedFromArt) {
1188
1189         for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
1190             Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
1191             for (ArtifactTemplateInfo template : artifactsNames) {
1192                 if (artifact.getArtifactName().equalsIgnoreCase(template.getFileName())
1193                         && artifactType.equalsIgnoreCase(template.getType())) {
1194                     isNeedToDeleteArtifact = false;
1195                     break;
1196
1197                 } else {
1198
1199                     if (generatedFromArt != null) {
1200                         if (generatedFromArt.getArtifactName().equalsIgnoreCase(template.getFileName())
1201                                 && generatedFromArt.getArtifactType().equalsIgnoreCase(template.getType())) {
1202                             isNeedToDeleteArtifact = false;
1203                             break;
1204                         }
1205                     }
1206                 }
1207             }
1208
1209         }
1210         if (isNeedToDeleteArtifact) {
1211             artifactsToDelete.add(artifact);
1212
1213         }
1214     }
1215
1216     private Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> findMasterArtifactInGroup(
1217             List<GroupDefinition> groups, Map<String, ArtifactDefinition> deploymentArtifact) {
1218         Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = new HashMap<>();
1219
1220         for (GroupDefinition group : groups) {
1221             Map<ArtifactDefinition, List<ArtifactDefinition>> gupsMap = new HashMap<>();
1222             List<ArtifactDefinition> artifacts = new ArrayList<>();
1223             List<String> artifactsList = group.getArtifacts();
1224             if (artifactsList != null && !artifactsList.isEmpty()) {
1225
1226                 ArtifactDefinition masterArtifact = ArtifactUtils.findMasterArtifact(deploymentArtifact, artifacts,
1227                         artifactsList);
1228                 if (masterArtifact != null) {
1229                     gupsMap.put(masterArtifact, artifacts);
1230                 }
1231                 groupArtifact.put(group, gupsMap);
1232
1233             }
1234         }
1235         return groupArtifact;
1236     }
1237
1238     private Either<Resource, ResponseFormat> deleteArtifactsInUpdateCsarFlow(Resource resource,
1239             User user, boolean shouldLock, boolean inTransaction, Set<ArtifactDefinition> artifactsToDelete,
1240             Map<String, List<ArtifactDefinition>> groupToDelete, List<ArtifactDefinition> deletedArtifacts) {
1241
1242         Resource updatedResource = resource;
1243
1244         String resourceId = updatedResource.getUniqueId();
1245         if (!artifactsToDelete.isEmpty()) {
1246             for (ArtifactDefinition artifact : artifactsToDelete) {
1247                 String artifactType = artifact.getArtifactType();
1248                 final ArtifactTypeEnum artifactTypeEnum = ArtifactTypeEnum.parse(artifactType);
1249                 if (artifactTypeEnum != ArtifactTypeEnum.HEAT_ENV) {
1250                     Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
1251                             .handleDelete(resourceId, artifact.getUniqueId(), user,
1252                                 updatedResource, shouldLock, inTransaction);
1253
1254                     if (handleDelete.isRight()) {
1255                         return Either.right(handleDelete.right().value());
1256                     }
1257
1258                     deletedArtifacts.add(handleDelete.left().value());
1259                 }
1260
1261             }
1262         }
1263         if (!groupToDelete.isEmpty()) {
1264             log.debug("try to delete group");
1265             List<GroupDefinition> groupDefinitionstoDelete = new ArrayList<>();
1266             List<GroupDefinition> groups = updatedResource.getGroups();
1267             for (Entry<String, List<ArtifactDefinition>> deleteGroup : groupToDelete.entrySet()) {
1268                 Optional<GroupDefinition> op = groups.stream()
1269                         .filter(gr -> gr.getUniqueId().equals(deleteGroup.getKey())).findAny();
1270                 if (op.isPresent()) {
1271                     groupDefinitionstoDelete.add(op.get());
1272                 }
1273
1274             }
1275             if (!groupDefinitionstoDelete.isEmpty()) {
1276                 Either<List<GroupDefinition>, ResponseFormat> prepareGroups = groupBusinessLogic.deleteGroups(resource, groupDefinitionstoDelete);
1277                 if (prepareGroups.isRight()) {
1278                     return Either.right(prepareGroups.right().value());
1279                 }
1280             }
1281         }
1282         List<GroupDefinition> oldGroups = updatedResource.getGroups();
1283         Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
1284                 .getToscaElement(updatedResource.getUniqueId());
1285         if (eitherGerResource.isRight()) {
1286             ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
1287                     componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), updatedResource);
1288
1289             return Either.right(responseFormat);
1290
1291         }
1292         updatedResource = eitherGerResource.left().value();
1293         updatedResource.setGroups(oldGroups);
1294         return Either.left(updatedResource);
1295     }
1296
1297     private void createArtifactsGroupSet(List<ArtifactTemplateInfo> parsedGroupTemplateList,
1298             Set<ArtifactTemplateInfo> parsedArtifactsName) {
1299
1300         for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
1301             parsedArtifactsName.add(parsedGroupTemplate);
1302             List<ArtifactTemplateInfo> relatedArtifacts = parsedGroupTemplate.getRelatedArtifactsInfo();
1303             if (relatedArtifacts != null && !relatedArtifacts.isEmpty()) {
1304                 createArtifactsGroupSet(relatedArtifacts, parsedArtifactsName);
1305             }
1306         }
1307     }
1308
1309     private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
1310             Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
1311             List<ArtifactDefinition> createdNewArtifacts, List<ArtifactDefinition> artifactsFromResource,
1312             int labelCounter) {
1313
1314         Resource updatedResource = resource;
1315
1316         Either<Resource, ResponseFormat> resStatus = Either.left(updatedResource);
1317         List<GroupDefinition> createdGroups = updatedResource.getGroups();
1318         List<GroupDefinition> heatGroups = null;
1319         if (createdGroups != null && !createdGroups.isEmpty()) {
1320             heatGroups = collectGroupsWithMembers(createdGroups);
1321         }
1322
1323         List<GroupDefinition> needToAdd = new ArrayList<>();
1324         for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
1325             String groupName = groupTemplateInfo.getGroupName();
1326             Set<String> artifactsGroup = new HashSet<>();
1327             Set<String> artifactsUUIDGroup = new HashSet<>();
1328
1329             resStatus = createDeploymentArtifactsFromCsar(csarInfo, updatedResource, artifactsGroup, artifactsUUIDGroup,
1330                     groupTemplateInfo, createdNewArtifacts, artifactsFromResource, labelCounter);
1331             if (resStatus.isRight()) {
1332                 return resStatus;
1333             }
1334             if (!StringUtils.isEmpty(groupName)) {
1335                 Map<String, String> members = new HashMap<>();
1336                 associateMembersToArtifacts(createdNewArtifacts, artifactsFromResource, heatGroups, artifactsGroup,
1337                         members);
1338
1339                 List<String> artifactsList = new ArrayList<>(artifactsGroup);
1340                 List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
1341
1342                 GroupDefinition groupDefinition = new GroupDefinition();
1343                 groupDefinition.setName(groupName);
1344                 groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
1345                 groupDefinition.setArtifacts(artifactsList);
1346                 groupDefinition.setArtifactsUuid(artifactsUUIDList);
1347
1348                 if (!members.isEmpty()) {
1349                     groupDefinition.setMembers(members);
1350                 }
1351
1352                 List<GroupProperty> properties = new ArrayList<>();
1353                 GroupProperty prop = new GroupProperty();
1354                 prop.setName(Constants.IS_BASE);
1355                 prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
1356                 properties.add(prop);
1357
1358                 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1359                 createdArtifacts.addAll(createdNewArtifacts);
1360                 createdArtifacts.addAll(artifactsFromResource);
1361                 Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
1362                         .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
1363                 if (getLatestGroupTypeRes.isRight()) {
1364                     return Either.right(componentsUtils.getResponseFormat(
1365                             componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
1366                 }
1367                 properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
1368                         createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
1369                 groupDefinition.convertFromGroupProperties(properties);
1370
1371                 needToAdd.add(groupDefinition);
1372             }
1373         }
1374         ComponentParametersView componentParametersView = new ComponentParametersView();
1375         componentParametersView.disableAll();
1376         componentParametersView.setIgnoreArtifacts(false);
1377         componentParametersView.setIgnoreGroups(false);
1378         componentParametersView.setIgnoreComponentInstances(false);
1379
1380         Either<Resource, StorageOperationStatus> component = toscaOperationFacade
1381                 .getToscaElement(updatedResource.getUniqueId(), componentParametersView);
1382         if (component.isRight()) {
1383             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1384         }
1385         updatedResource = component.left().value();
1386
1387          Either<List<GroupDefinition>, ResponseFormat> addGroups = groupBusinessLogic.addGroups(updatedResource, needToAdd, false);
1388         if (addGroups.isRight()) {
1389             return Either.right(addGroups.right().value());
1390         }
1391
1392         return resStatus;
1393     }
1394
1395     private Either<Resource, ResponseFormat> createDeploymentArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
1396             Set<String> artifactsGroup, Set<String> artifactsUUIDGroup, ArtifactTemplateInfo artifactTemplateInfo,
1397             List<ArtifactDefinition> createdArtifacts, List<ArtifactDefinition> artifactsFromResource, int labelCounter) {
1398         Either<Resource, ResponseFormat> resStatus = Either.left(resource);
1399         String artifactFileName = artifactTemplateInfo.getFileName();
1400         String artifactUid = "";
1401         String artifactUUID = "";
1402         String artifactEnvUid = "";
1403         boolean alreadyExist = false;
1404
1405         // check if artifacts already exist
1406         if (artifactsFromResource != null && !artifactsFromResource.isEmpty()) {
1407             for (ArtifactDefinition artifactFromResource : artifactsFromResource) {
1408                 if (artifactFromResource.getArtifactName().equals(artifactFileName)) {
1409                     artifactUid = artifactFromResource.getUniqueId();
1410                     artifactUUID = artifactFromResource.getArtifactUUID();
1411                     if (!artifactFromResource.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1412                         log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
1413                                 artifactTemplateInfo.getType(), artifactFromResource.getArtifactType());
1414                         BeEcompErrorManager.getInstance().logInternalDataError(
1415                                 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1416                                 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1417                         return Either.right(componentsUtils.getResponseFormat(
1418                                 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1419                                 artifactTemplateInfo.getType(), artifactFromResource.getArtifactType()));
1420                     }
1421                     alreadyExist = true;
1422                     artifactEnvUid = checkAndGetHeatEnvId(artifactFromResource);
1423                     break;
1424                 }
1425
1426             }
1427
1428         }
1429         if (!alreadyExist) {
1430             for (ArtifactDefinition createdArtifact : createdArtifacts) {
1431                 if (createdArtifact.getArtifactName().equals(artifactFileName)) {
1432                     artifactUid = createdArtifact.getUniqueId();
1433                     artifactUUID = createdArtifact.getArtifactUUID();
1434
1435                     if (!createdArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1436                         log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
1437                                 artifactTemplateInfo.getType(), createdArtifact.getArtifactType());
1438                         BeEcompErrorManager.getInstance().logInternalDataError(
1439                                 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1440                                 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1441                         return Either.right(componentsUtils.getResponseFormat(
1442                                 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1443                                 artifactTemplateInfo.getType(), createdArtifact.getArtifactType()));
1444                     }
1445                     alreadyExist = true;
1446                     artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
1447                     break;
1448                 }
1449
1450             }
1451         }
1452         // if not exist need to create
1453         if (!alreadyExist) {
1454
1455             Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
1456                     ARTIFACTS_PATH, artifactTemplateInfo, createdArtifacts, labelCounter);
1457             if (newArtifactEither.isRight()) {
1458                 resStatus = Either.right(newArtifactEither.right().value());
1459                 return resStatus;
1460             }
1461             ArtifactDefinition newArtifact = newArtifactEither.left().value();
1462             artifactUid = newArtifact.getUniqueId();
1463             artifactUUID = newArtifact.getArtifactUUID();
1464             final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(newArtifact.getArtifactType());
1465             if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
1466                     || artifactType == ArtifactTypeEnum.HEAT_VOL) {
1467                 ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
1468                         .createHeatEnvPlaceHolder(createdArtifacts, newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
1469                                 resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
1470                                 csarInfo.getModifier(), resource, null);
1471                 artifactEnvUid = createHeatEnvPlaceHolder.getUniqueId();
1472             }
1473         }
1474
1475         artifactsGroup.add(artifactUid);
1476         artifactsUUIDGroup.add(artifactUUID);
1477         if (!artifactEnvUid.isEmpty()) {
1478             artifactsGroup.add(artifactEnvUid);
1479         }
1480
1481         List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
1482         if (relatedArtifacts != null) {
1483             for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
1484                 resStatus = createDeploymentArtifactsFromCsar(csarInfo, resource, artifactsGroup, artifactsUUIDGroup,
1485                         relatedArtifactTemplateInfo, createdArtifacts, artifactsFromResource, labelCounter);
1486                 if (resStatus.isRight()) {
1487                     return resStatus;
1488                 }
1489             }
1490         }
1491         return resStatus;
1492     }
1493
1494     private Either<Resource, ResponseFormat> associateAndDissociateArtifactsToGroup(CsarInfo csarInfo,
1495                                                                                     Resource resource, List<ArtifactDefinition> createdNewArtifacts, int labelCounter,
1496                                                                                     List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete,
1497                                                                                     Map<GroupDefinition, MergedArtifactInfo> mergedgroup, List<ArtifactDefinition> deletedArtifacts) {
1498         Map<GroupDefinition, List<ArtifactTemplateInfo>> artifactsToAssotiate = new HashMap<>();
1499         Map<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateMap = new HashMap<>();
1500         Either<Resource, ResponseFormat> resEither;
1501         for (Entry<GroupDefinition, MergedArtifactInfo> entry : mergedgroup.entrySet()) {
1502             List<ArtifactDefinition> dissArtifactsInGroup = entry.getValue()
1503                     .getListToDissotiateArtifactFromGroup(deletedArtifacts);
1504             GroupDefinition grDef = entry.getKey();
1505             if (dissArtifactsInGroup != null && !dissArtifactsInGroup.isEmpty()) {
1506                 for (ArtifactDefinition art : dissArtifactsInGroup) {
1507                     grDef.getArtifacts().remove(art.getUniqueId());
1508                     grDef.getArtifactsUuid().remove(art.getArtifactUUID());
1509                 }
1510             }
1511
1512             List<ArtifactTemplateInfo> newArtifactsInGroup = entry.getValue().getListToAssociateArtifactToGroup();
1513             if (newArtifactsInGroup != null && !newArtifactsInGroup.isEmpty()) {
1514                 artifactsToAssotiate.put(entry.getKey(), newArtifactsInGroup);
1515             }
1516
1517             List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdate = entry.getValue()
1518                     .getListToUpdateArtifactInGroup();
1519             if (artifactsToUpdate != null && !artifactsToUpdate.isEmpty()) {
1520                 artifactsToUpdateMap.put(entry.getKey(), artifactsToUpdate);
1521             }
1522         }
1523
1524         if (!artifactsToUpdateMap.isEmpty()) {
1525             List<ArtifactDefinition> updatedArtifacts = new ArrayList<>();
1526             for (Entry<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateEntry : artifactsToUpdateMap
1527                     .entrySet()) {
1528                 List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdateList = artifactsToUpdateEntry
1529                         .getValue();
1530                 GroupDefinition groupToUpdate = artifactsToUpdateEntry.getKey();
1531
1532                 for (ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo> artifact : artifactsToUpdateList) {
1533                     String prevUUID = artifact.getKey().getArtifactUUID();
1534                     String prevId = artifact.getKey().getUniqueId();
1535                     String prevHeatEnvId = checkAndGetHeatEnvId(artifact.getKey());
1536                     Either<ArtifactDefinition, ResponseFormat> updateArtifactEither = updateDeploymentArtifactsFromCsar(
1537                             csarInfo, resource, artifact.getKey(), artifact.getValue(), updatedArtifacts,
1538                             artifact.getRight().getRelatedArtifactsInfo());
1539                     if (updateArtifactEither.isRight()) {
1540                         log.debug("failed to update artifacts. status is {}", updateArtifactEither.right().value());
1541                         resEither = Either.right(updateArtifactEither.right().value());
1542                         return resEither;
1543                     }
1544                     ArtifactDefinition artAfterUpdate = updateArtifactEither.left().value();
1545                     if (!prevUUID.equals(artAfterUpdate.getArtifactUUID())
1546                             || !prevId.equals(artAfterUpdate.getUniqueId())) {
1547                         groupToUpdate.getArtifacts().remove(prevId);
1548                         groupToUpdate.getArtifactsUuid().remove(prevUUID);
1549                         groupToUpdate.getArtifacts().add(artAfterUpdate.getUniqueId());
1550                         groupToUpdate.getArtifactsUuid().add(artAfterUpdate.getArtifactUUID());
1551                     }
1552                     Optional<ArtifactDefinition> op = updatedArtifacts.stream()
1553                             .filter(p -> p.getGeneratedFromId() != null
1554                             && p.getGeneratedFromId().equals(artAfterUpdate.getUniqueId()))
1555                             .findAny();
1556                     if (op.isPresent()) {
1557                         ArtifactDefinition artifactInfoHeatEnv = op.get();
1558                         groupToUpdate.getArtifacts().remove(prevHeatEnvId);
1559                         groupToUpdate.getArtifacts().add(artifactInfoHeatEnv.getUniqueId());
1560                     }
1561
1562                 }
1563             }
1564         }
1565
1566         for (Entry<GroupDefinition, List<ArtifactTemplateInfo>> associateEntry : artifactsToAssotiate.entrySet()) {
1567             List<ArtifactTemplateInfo> associatedArtifact = associateEntry.getValue();
1568             Set<String> arifactsUids = new HashSet<>();
1569             Set<String> arifactsUuids = new HashSet<>();
1570             for (ArtifactTemplateInfo artifactTemplate : associatedArtifact) { // try
1571                 // to
1572                 // find
1573                 // artifact
1574                 // in
1575                 // resource
1576                 boolean isCreate = true;
1577                 for (ArtifactDefinition createdArtifact : createdDeploymentArtifactsAfterDelete) {
1578                     if (artifactTemplate.getFileName().equalsIgnoreCase(createdArtifact.getArtifactName())) {
1579                         arifactsUids.add(createdArtifact.getUniqueId());
1580                         arifactsUuids.add(createdArtifact.getArtifactUUID());
1581                         isCreate = false;
1582                         String heatEnvId = checkAndGetHeatEnvId(createdArtifact);
1583                         if (!heatEnvId.isEmpty()) {
1584                             arifactsUids.add(heatEnvId);
1585                             Optional<ArtifactDefinition> op = createdDeploymentArtifactsAfterDelete.stream()
1586                                     .filter(p -> p.getUniqueId().equals(heatEnvId)).findAny();
1587                             if (op.isPresent()) {
1588                                 this.artifactToscaOperation.updateHeatEnvPlaceholder(op.get(), resource,
1589                                         resource.getComponentType().getNodeType());
1590
1591                             }
1592                         }
1593
1594                         break;
1595                     }
1596
1597                 }
1598                 if (isCreate) { // check if already created
1599                     for (ArtifactDefinition createdNewArtifact : createdNewArtifacts) {
1600                         if (artifactTemplate.getFileName().equalsIgnoreCase(createdNewArtifact.getArtifactName())) {
1601                             arifactsUids.add(createdNewArtifact.getUniqueId());
1602                             arifactsUuids.add(createdNewArtifact.getArtifactUUID());
1603                             isCreate = false;
1604                             String heatEnvId = checkAndGetHeatEnvId(createdNewArtifact);
1605                             if (!heatEnvId.isEmpty()) {
1606                                 arifactsUids.add(heatEnvId);
1607                             }
1608                             break;
1609                         }
1610                     }
1611                 }
1612
1613                 if (isCreate) {
1614                     Either<ArtifactDefinition, ResponseFormat> createArtifactEither = createDeploymentArtifact(csarInfo,
1615                             resource, ARTIFACTS_PATH, artifactTemplate, createdNewArtifacts, labelCounter);
1616                     if (createArtifactEither.isRight()) {
1617                         resEither = Either.right(createArtifactEither.right().value());
1618                         return resEither;
1619                     }
1620                     ArtifactDefinition createdArtifact = createArtifactEither.left().value();
1621                     arifactsUids.add(createdArtifact.getUniqueId());
1622                     arifactsUuids.add(createdArtifact.getArtifactUUID());
1623                     final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(createdArtifact.getArtifactType());
1624                     if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
1625                             || artifactType == ArtifactTypeEnum.HEAT_VOL) {
1626                         ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
1627                                 .createHeatEnvPlaceHolder(new ArrayList<>(), createdArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
1628                                         resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
1629                                         csarInfo.getModifier(), resource, null);
1630                         String heatEnvId = createHeatEnvPlaceHolder.getUniqueId();
1631                         arifactsUids.add(heatEnvId);
1632                     }
1633                 }
1634
1635             }
1636             if (arifactsUids != null && !arifactsUids.isEmpty()) {
1637                 List<String> artifactsToAssociate = new ArrayList<>();
1638                 artifactsToAssociate.addAll(arifactsUids);
1639                 GroupDefinition assotiateGroup = associateEntry.getKey();
1640                 assotiateGroup.getArtifacts().addAll(arifactsUids);
1641                 assotiateGroup.getArtifactsUuid().addAll(arifactsUuids);
1642             }
1643         }
1644
1645         ComponentParametersView parametersView = new ComponentParametersView();
1646         parametersView.disableAll();
1647         parametersView.setIgnoreComponentInstances(false);
1648         parametersView.setIgnoreUsers(false);
1649         parametersView.setIgnoreArtifacts(false);
1650         parametersView.setIgnoreGroups(false);
1651
1652         Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
1653                 .getToscaElement(resource.getUniqueId(), parametersView);
1654
1655         if (eitherGerResource.isRight()) {
1656             ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
1657                     componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
1658
1659             resEither = Either.right(responseFormat);
1660             return resEither;
1661
1662         }
1663         resEither = Either.left(eitherGerResource.left().value());
1664         return resEither;
1665     }
1666
1667     private Either<ArtifactDefinition, ResponseFormat> updateDeploymentArtifactsFromCsar(CsarInfo csarInfo,
1668             Resource resource, ArtifactDefinition oldArtifact, ArtifactTemplateInfo artifactTemplateInfo,
1669             List<ArtifactDefinition> updatedArtifacts, List<ArtifactTemplateInfo> updatedRequiredArtifacts) {
1670
1671         Either<ArtifactDefinition, ResponseFormat> resStatus = null;
1672         String artifactFileName = artifactTemplateInfo.getFileName();
1673
1674         // check if artifacts already exist
1675         for (ArtifactDefinition updatedArtifact : updatedArtifacts) {
1676             if (updatedArtifact.getArtifactName().equals(artifactFileName)) {
1677                 if (!updatedArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1678                     log.debug("Artifact with name {} and type {} already updated with type  {}", artifactFileName,
1679                             artifactTemplateInfo.getType(), updatedArtifact.getArtifactType());
1680                     BeEcompErrorManager.getInstance().logInternalDataError(
1681                             ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1682                             ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1683                     resStatus = Either.right(componentsUtils.getResponseFormat(
1684                             ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1685                             artifactTemplateInfo.getType(), updatedArtifact.getArtifactType()));
1686                     return resStatus;
1687                 }
1688                 resStatus = Either.left(updatedArtifact);
1689                 return resStatus;
1690             }
1691
1692         }
1693
1694         Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContententStatus = CsarValidationUtils
1695                 .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
1696                         CsarUtils.ARTIFACTS_PATH + artifactFileName, artifactFileName, componentsUtils);
1697         if (artifactContententStatus.isRight()) {
1698             resStatus = Either.right(artifactContententStatus.right().value());
1699             return resStatus;
1700         }
1701
1702         Map<String, Object> json = ArtifactUtils.buildJsonForUpdateArtifact(oldArtifact.getUniqueId(), artifactFileName,
1703                 oldArtifact.getArtifactType(), ArtifactGroupTypeEnum.DEPLOYMENT, oldArtifact.getArtifactLabel(),
1704                 oldArtifact.getArtifactDisplayName(), oldArtifact.getDescription(),
1705                 artifactContententStatus.left().value().getRight(), updatedRequiredArtifacts, oldArtifact.getIsFromCsar());
1706
1707         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
1708                 resource, csarInfo.getModifier(), json,
1709                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE));
1710
1711         if (uploadArtifactToService.isRight()) {
1712             resStatus = Either.right(uploadArtifactToService.right().value());
1713             return resStatus;
1714         }
1715         ArtifactDefinition previousInfo = uploadArtifactToService.left().value().left().value();
1716         ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
1717         updatedArtifacts.add(currentInfo);
1718
1719         Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
1720                 artifactTemplateInfo, currentInfo, true);
1721
1722         if (updateEnvEither.isRight()) {
1723             log.debug("failed to update parameters to artifact {}", artifactFileName);
1724             resStatus = Either.right(updateEnvEither.right().value());
1725             return resStatus;
1726         }
1727
1728         artifactsBusinessLogic.updateGroupForHeat(previousInfo, updateEnvEither.left().value(), resource);
1729
1730         updatedArtifacts.add(updateEnvEither.left().value());
1731         resStatus = Either.left(currentInfo);
1732         return resStatus;
1733     }
1734
1735     public Either<Resource, ResponseFormat> deleteVFModules(Resource resource, CsarInfo csarInfo, boolean shouldLock, boolean inTransaction) {
1736         Resource updatedResource = resource;
1737         List<GroupDefinition> groupsToDelete = updatedResource.getGroups();
1738         if(groupsToDelete != null && !groupsToDelete.isEmpty()){
1739             List<GroupDefinition> vfGroupsToDelete = groupsToDelete.stream().filter(g -> g.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)).collect(Collectors.toList());
1740             if(!vfGroupsToDelete.isEmpty()){
1741                 for(GroupDefinition gr : vfGroupsToDelete){
1742                     List<String> artifacts = gr.getArtifacts();
1743                     for (String artifactId : artifacts) {
1744                         Either<ArtifactDefinition, ResponseFormat> handleDelete =
1745                             artifactsBusinessLogic.handleDelete(
1746                                 updatedResource.getUniqueId(), artifactId, csarInfo.getModifier(),
1747                                 updatedResource, shouldLock, inTransaction);
1748                         if (handleDelete.isRight()) {
1749                             log.debug("Couldn't delete  artifact {}", artifactId);
1750                             return Either.right(handleDelete.right().value());
1751                         }
1752                     }
1753
1754                 }
1755                 groupBusinessLogic.deleteGroups(updatedResource, vfGroupsToDelete);
1756
1757                 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(updatedResource.getUniqueId());
1758                 if (eitherGetResource.isRight()) {
1759                     ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), updatedResource);
1760
1761                     return Either.right(responseFormat);
1762
1763                 }
1764                 updatedResource = eitherGetResource.left().value();
1765             }
1766         }
1767         return Either.left(updatedResource);
1768     }
1769
1770     private Either<Resource, ResponseFormat>  getResourcetFromGraph(Resource component){
1771         log.debug("getResource start");
1772         return toscaOperationFacade.getToscaElement(component.getUniqueId())
1773                 .right()
1774                 .map(rf ->  componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(rf), component))
1775                 .left()
1776                 .map (c -> (Resource) c);
1777
1778
1779     }
1780
1781 }