gerrit.onap Code Review - sdc.git/blob

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