catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java

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