catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import com.google.common.annotations.VisibleForTesting;
  24 import com.google.gson.Gson;
  25 import com.google.gson.GsonBuilder;
  26 import fj.data.Either;
  27 import org.apache.commons.codec.binary.Base64;
  28 import org.apache.commons.collections.CollectionUtils;
  29 import org.apache.commons.collections.MapUtils;
  30 import org.apache.commons.lang.StringUtils;
  31 import org.apache.commons.lang3.tuple.ImmutablePair;
  32 import org.elasticsearch.common.Strings;
  33 import org.openecomp.sdc.be.components.ArtifactsResolver;
  34 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  35 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  36 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  37 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  38 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction.LifecycleChanceActionEnum;
  39 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  40 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  41 import org.openecomp.sdc.be.config.ConfigurationManager;
  42 import org.openecomp.sdc.be.config.validation.DeploymentArtifactHeatConfiguration;
  43 import org.openecomp.sdc.be.dao.api.ActionStatus;
  44 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  45 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  46 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  47 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  53 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  54 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
  55 import org.openecomp.sdc.be.model.*;
  56 import org.openecomp.sdc.be.model.heat.HeatParameterType;
  57 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
  58 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
  59 import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
  60 import org.openecomp.sdc.be.model.operations.api.*;
  61 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  62 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  63 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  64 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  65 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  66 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  67 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  68 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  69 import org.openecomp.sdc.be.tosca.CsarUtils;
  70 import org.openecomp.sdc.be.tosca.ToscaError;
  71 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
  72 import org.openecomp.sdc.be.tosca.ToscaRepresentation;
  73 import org.openecomp.sdc.be.user.IUserBusinessLogic;
  74 import org.openecomp.sdc.be.user.Role;
  75 import org.openecomp.sdc.be.user.UserBusinessLogic;
  76 import org.openecomp.sdc.be.utils.TypeUtils;
  77 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  78 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  79 import org.openecomp.sdc.common.api.Constants;
  80 import org.openecomp.sdc.common.datastructure.Wrapper;
  81 import org.openecomp.sdc.common.log.wrappers.Logger;
  82 import org.openecomp.sdc.common.util.GeneralUtility;
  83 import org.openecomp.sdc.common.util.ValidationUtils;
  84 import org.openecomp.sdc.common.util.YamlToObjectConverter;
  85 import org.openecomp.sdc.exception.ResponseFormat;
  86
  87 import org.springframework.beans.factory.annotation.Autowired;
  88 import org.xml.sax.*;
  89 import org.yaml.snakeyaml.Yaml;
  90
  91 import javax.servlet.http.HttpServletRequest;
  92 import javax.xml.XMLConstants;
  93 import javax.xml.parsers.ParserConfigurationException;
  94 import javax.xml.parsers.SAXParserFactory;
  95 import java.io.ByteArrayInputStream;
  96 import java.io.IOException;
  97 import java.math.BigDecimal;
  98 import java.util.*;
  99 import java.util.Map.Entry;
 100 import java.util.function.Predicate;
 101 import java.util.function.Supplier;
 102 import java.util.stream.Collectors;
 103
 104 @org.springframework.stereotype.Component("artifactBusinessLogic")
 105 public class ArtifactsBusinessLogic extends BaseBusinessLogic {
 106     private static final String RESOURCE_INSTANCE = "resource instance";
 107     private static final String ARTIFACT_TYPE_OTHER = "OTHER";
 108     private static final String ARTIFACT_DESCRIPTION = "artifact description";
 109     private static final String ARTIFACT_LABEL = "artifact label";
 110     private static final String ARTIFACT_URL = "artifact url";
 111     private static final String ARTIFACT_NAME = "artifact name";
 112     private static final String ARTIFACT_PAYLOAD = "artifact payload";
 113
 114     private static final String ARTIFACT_PLACEHOLDER_TYPE = "type";
 115     private static final String ARTIFACT_PLACEHOLDER_DISPLAY_NAME = "displayName";
 116     private static final Object ARTIFACT_PLACEHOLDER_DESCRIPTION = "description";
 117
 118     public static final String HEAT_ENV_NAME = "heatEnv";
 119     public static final String HEAT_VF_ENV_NAME = "VfHeatEnv";
 120     public static final String HEAT_ENV_SUFFIX = "env";
 121     private static final String ARTIFACT_PLACEHOLDER_FILE_EXTENSION = "fileExtension";
 122
 123     private static final Logger log = Logger.getLogger(ArtifactsBusinessLogic.class);
 124     public static final String FAILED_UPDATE_GROUPS = "Failed to update groups of the component {}. ";
 125     public static final String FAILED_UPDATE_ARTIFACT = "Failed to delete or update the artifact {}. Parent uniqueId is {}";
 126     public static final String FAILED_SAVE_ARTIFACT = "Failed to save the artifact.";
 127     public static final String UPDATE_ARTIFACT_LOCK = "Update Artifact - lock ";
 128     public static final String FAILED_DOWNLOAD_ARTIFACT = "Download artifact {} failed";
 129     public static final String FAILED_UPLOAD_ARTIFACT_TO_COMPONENT = "Failed to upload artifact to component with type {} and uuid {}. Status is {}. ";
 130     public static final String FAILED_UPLOAD_ARTIFACT_TO_INSTANCE = "Failed to upload artifact to component instance {} of component with type {} and uuid {}. Status is {}. ";
 131     public static final String FAILED_FETCH_COMPONENT = "Could not fetch component with type {} and uuid {}. Status is {}. ";
 132     public static final String NULL_PARAMETER = "One of the function parameteres is null";
 133     public static final String COMPONENT_INSTANCE_NOT_FOUND = "Component instance {} was not found for component {}";
 134     public static final String ROLLBACK = "all changes rollback";
 135     public static final String COMMIT = "all changes committed";
 136     public static final String ARTIFACT_SAVED = "Artifact saved into ES - {}";
 137     public static final String UPDATE_ARTIFACT = "Update Artifact";
 138     public static final String FOUND_DEPLOYMENT_ARTIFACT = "Found deployment artifact {}";
 139     private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 140
 141     @javax.annotation.Resource
 142     private IInterfaceLifecycleOperation interfaceLifecycleOperation;
 143     @javax.annotation.Resource
 144     private IUserAdminOperation userOperaton;
 145
 146     @javax.annotation.Resource
 147     private IElementOperation elementOperation;
 148
 149     @javax.annotation.Resource
 150     private ResourceBusinessLogic resourceBusinessLogic;
 151
 152     @javax.annotation.Resource
 153     private ServiceBusinessLogic serviceBusinessLogic;
 154
 155     @javax.annotation.Resource
 156     private UserBusinessLogic userAdminManager;
 157
 158     @javax.annotation.Resource
 159     private IHeatParametersOperation heatParametersOperation;
 160
 161     @Autowired
 162     private ArtifactCassandraDao artifactCassandraDao;
 163
 164     @Autowired
 165     private ToscaExportHandler toscaExportUtils;
 166
 167     @Autowired
 168     private CsarUtils csarUtils;
 169
 170     @Autowired
 171     private LifecycleBusinessLogic lifecycleBusinessLogic;
 172
 173     @Autowired
 174     private IUserBusinessLogic userBusinessLogic;
 175
 176     @Autowired
 177     private NodeTemplateOperation nodeTemplateOperation;
 178
 179     @Autowired
 180     private ArtifactsResolver artifactsResolver;
 181
 182     @Autowired
 183     private InterfaceOperation interfaceOperation;
 184
 185     public enum ArtifactOperationEnum {
 186         CREATE, UPDATE, DELETE, DOWNLOAD, LINK;
 187
 188         public static boolean isCreateOrLink(ArtifactOperationEnum operation) {
 189             return operation == CREATE || operation == LINK;
 190         }
 191     }
 192
 193     public class ArtifactOperationInfo {
 194
 195         private ArtifactOperationEnum artifactOperationEnum;
 196         private boolean isExternalApi;
 197         private boolean ignoreLifecycleState;
 198
 199         public ArtifactOperationInfo(boolean isExternalApi, boolean ignoreLifecycleState, ArtifactOperationEnum artifactOperationEnum) {
 200             this.artifactOperationEnum = artifactOperationEnum;
 201             this.isExternalApi = isExternalApi;
 202             this.ignoreLifecycleState = ignoreLifecycleState;
 203         }
 204
 205         public boolean isExternalApi() {
 206             return isExternalApi;
 207         }
 208
 209         public boolean ignoreLifecycleState() {
 210             return ignoreLifecycleState;
 211         }
 212
 213         public ArtifactOperationEnum getArtifactOperationEnum() {
 214             return artifactOperationEnum;
 215         }
 216
 217     }
 218
 219     // new flow US556184
 220     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleArtifactRequest(String componentId, String userId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactId, ArtifactDefinition artifactInfo,
 221                                                                                                String origMd5, String originData, String interfaceUuid, String operationUuid, String parentId, String containerComponentType) {
 222         return handleArtifactRequest(componentId, userId, componentType, operation, artifactId, artifactInfo, origMd5, originData, interfaceUuid, operationUuid, parentId, containerComponentType, true, false);
 223     }
 224
 225     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleArtifactRequest(String componentId, String userId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactId, ArtifactDefinition artifactInfo,
 226                                                                                                String origMd5, String originData, String interfaceUuid, String operationUuid, String parentId, String containerComponentType, boolean shouldLock, boolean inTransaction) {
 227
 228         // step 1 - detect auditing type
 229         AuditingActionEnum auditingAction = detectAuditingType(operation, origMd5);
 230         // step 2 - check header
 231         if (userId == null) {
 232             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 233             log.debug("handleArtifactRequest - no HTTP_CSP_HEADER , component id {}", componentId);
 234             handleAuditing(auditingAction, null, componentId, null, null, null, artifactId, responseFormat, componentType, null);
 235             return Either.right(responseFormat);
 236         }
 237         // step 3 - check user existence
 238         Either<User, ResponseFormat> userResult = validateUserExists(userId, auditingAction, componentId, artifactId, componentType, inTransaction);
 239         if (userResult.isRight()) {
 240             return Either.right(userResult.right().value());
 241         }
 242
 243         // step 4 - check user's role
 244         User user = userResult.left().value();
 245         Either<Boolean, ResponseFormat> validateUserRole = validateUserRole(user, auditingAction, componentId, artifactId, componentType, operation);
 246         if (validateUserRole.isRight()) {
 247             return Either.right(validateUserRole.right().value());
 248         }
 249
 250         // steps 5 - 6 - 7
 251         // 5. check service/resource existence
 252         // 6. check service/resource check out
 253         // 7. user is owner of checkout state
 254         org.openecomp.sdc.be.model.Component component = null;
 255         String realComponentId = componentType == ComponentTypeEnum.RESOURCE_INSTANCE ? parentId : componentId;
 256         Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponent = validateComponentExists(realComponentId, auditingAction, user, artifactId, componentType, containerComponentType);
 257         if (validateComponent.isRight()) {
 258             return Either.right(validateComponent.right().value());
 259         }
 260         component = validateComponent.left().value();
 261         Either<Boolean, ResponseFormat> validateWorkOnResource = validateWorkOnComponent(component, userId, auditingAction, user, artifactId, operation);
 262         if (validateWorkOnResource.isRight()) {
 263             return Either.right(validateWorkOnResource.right().value());
 264         }
 265         // step 8
 266
 267         return validateAndHandleArtifact(componentId, componentType, operation, artifactId, artifactInfo, origMd5, originData, interfaceUuid, operationUuid, user, component,
 268                 shouldLock, inTransaction, true);
 269     }
 270
 271     /**
 272      * This Method validates only the Artifact and does not validate user / role / component ect...<br>
 273      * For regular usage use <br>
 274      * {@link #handleArtifactRequest(String, String, ComponentTypeEnum, ArtifactOperationInfo, String, ArtifactDefinition, String, String, String, String, String, String)}
 275      *
 276      * @return
 277      */
 278     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> validateAndHandleArtifact(String componentUniqueId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactUniqueId,
 279                                                                                                    ArtifactDefinition artifactDefinition, String origMd5, String originData, String interfaceUuid, String operationName, User user, Component component, boolean shouldLock, boolean inTransaction, boolean needUpdateGroup) {
 280         Component parent = component;
 281         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 282
 283         AuditingActionEnum auditingAction = detectAuditingType(operation, origMd5);
 284         artifactDefinition = validateArtifact(componentUniqueId, componentType, operation, artifactUniqueId, artifactDefinition, auditingAction, user, component, parent, errorWrapper, shouldLock, inTransaction);
 285
 286         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result;
 287         if (errorWrapper.isEmpty()) {
 288             // step 10
 289             result = doAction(componentUniqueId, componentType, operation, artifactUniqueId, artifactDefinition, origMd5, originData, interfaceUuid, operationName, auditingAction, user, parent, shouldLock, inTransaction, needUpdateGroup);
 290         }
 291         else {
 292             result = Either.right(errorWrapper.getInnerElement());
 293         }
 294         return result;
 295     }
 296
 297     private ArtifactDefinition validateArtifact(String componentId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, User user,
 298                                                 Component component, Component parent, Wrapper<ResponseFormat> errorWrapper, boolean shouldLock, boolean inTransaction) {
 299         ArtifactDefinition validatedArtifactInfo = artifactInfo;
 300         if (operation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE || operation.getArtifactOperationEnum() == ArtifactOperationEnum.DELETE || operation
 301                 .getArtifactOperationEnum() == ArtifactOperationEnum.DOWNLOAD) {
 302             Either<ArtifactDefinition, ResponseFormat> validateArtifact = validateArtifact(componentId, componentType, artifactId, component);
 303             if (validateArtifact.isRight()) {
 304                 ResponseFormat responseFormat = validateArtifact.right().value();
 305                 handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
 306                 errorWrapper.setInnerElement(validateArtifact.right().value());
 307             }
 308             else if (operation.getArtifactOperationEnum() == ArtifactOperationEnum.DOWNLOAD) {
 309                 validatedArtifactInfo = validateArtifact.left().value();
 310                     handleHeatEnvDownload(componentId, componentType, user, component, validateArtifact, errorWrapper, shouldLock, inTransaction);
 311             }
 312         }
 313         return validatedArtifactInfo;
 314     }
 315
 316     private void handleHeatEnvDownload(String componentId, ComponentTypeEnum componentType, User user, org.openecomp.sdc.be.model.Component component, Either<ArtifactDefinition,
 317             ResponseFormat> validateArtifact, Wrapper<ResponseFormat> errorWrapper, boolean shouldLock, boolean inTransaction) {
 318         ArtifactDefinition validatedArtifact = validateArtifact.left().value();
 319
 320         if (validatedArtifact.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())
 321                 && ComponentTypeEnum.SERVICE == component.getComponentType()) {
 322             ComponentInstance componentInstance = component.getComponentInstances()
 323                                                            .stream()
 324                                                            .filter(p -> p.getUniqueId().equals(componentId))
 325                                                            .findAny()
 326                                                            .get();
 327             Map<String, ArtifactDefinition> deploymentArtifacts = componentInstance.getDeploymentArtifacts();
 328
 329             ArtifactDefinition heatEnvWithHeatParams = deploymentArtifacts.values()
 330                                                                           .stream()
 331                                                                           .filter(p -> p.getUniqueId()
 332                                                                                         .equals(validatedArtifact.getUniqueId()))
 333                                                                           .findAny()
 334                                                                           .get();
 335             Either<ArtifactDefinition, ResponseFormat> eitherGenerated = generateHeatEnvArtifact(heatEnvWithHeatParams, componentType, component, componentInstance
 336                     .getName(), user, componentId, shouldLock, inTransaction);
 337             if (eitherGenerated.isRight()) {
 338                 errorWrapper.setInnerElement(eitherGenerated.right().value());
 339             }
 340         }
 341     }
 342
 343     private boolean artifactGenerationRequired(org.openecomp.sdc.be.model.Component component, ArtifactDefinition artifactInfo) {
 344         boolean needGenerate;
 345         needGenerate = artifactInfo.getArtifactGroupType() == ArtifactGroupTypeEnum.TOSCA && (component.getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKIN || component
 346                 .getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 347         needGenerate = needGenerate || (ComponentTypeEnum.RESOURCE == component.getComponentType() && (artifactInfo.getArtifactType()
 348                                                                                                                    .equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV
 349                                                                                                                            .getType()) || isAbstractVfcEmptyCsar((Resource) component, artifactInfo)));
 350         return needGenerate;
 351     }
 352
 353     private boolean isAbstractVfcEmptyCsar(Resource resource, ArtifactDefinition artifactInfo) {
 354         return resource.isAbstract() && artifactInfo.getArtifactGroupType() == ArtifactGroupTypeEnum.TOSCA && artifactInfo
 355                 .getArtifactType()
 356                 .equals(ArtifactTypeEnum.TOSCA_CSAR.getType()) && StringUtils.isEmpty(artifactInfo.getArtifactChecksum());
 357     }
 358
 359     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> generateAndSaveToscaArtifact(ArtifactDefinition artifactDefinition, org.openecomp.sdc.be.model.Component component, User user, boolean isInCertificationRequest,
 360                                                                                                       boolean shouldLock, boolean inTransaction, boolean fetchTemplatesFromDB) {
 361
 362         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> generated = generateToscaArtifact(component, artifactDefinition, isInCertificationRequest, fetchTemplatesFromDB);
 363         if (generated.isRight()) {
 364             return generated;
 365         }
 366         byte[] decodedPayload = artifactDefinition.getPayloadData();
 367         artifactDefinition.setEsId(artifactDefinition.getUniqueId());
 368         artifactDefinition.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(decodedPayload));
 369         return lockComponentAndUpdateArtifact(component.getUniqueId(), artifactDefinition, AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, artifactDefinition
 370                         .getUniqueId(), user, component.getComponentType(), component, decodedPayload, null, null,
 371                 shouldLock, inTransaction);
 372
 373     }
 374
 375     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> generateToscaArtifact(Component parent, ArtifactDefinition artifactInfo, boolean isInCertificationRequest, boolean fetchTemplatesFromDB) {
 376         log.debug("tosca artifact generation");
 377         if (artifactInfo.getArtifactType().equals(ArtifactTypeEnum.TOSCA_CSAR.getType())) {
 378             Either<byte[], ResponseFormat> generated = csarUtils.createCsar(parent, fetchTemplatesFromDB, isInCertificationRequest);
 379
 380             if (generated.isRight()) {
 381                 log.debug("Failed to export tosca csar for component {} error {}", parent.getUniqueId(), generated.right()
 382                                                                                                                   .value());
 383
 384                 return Either.right(generated.right().value());
 385             }
 386             byte[] value = generated.left().value();
 387             artifactInfo.setPayload(value);
 388
 389         }
 390         else {
 391             Either<ToscaRepresentation, ToscaError> exportComponent = toscaExportUtils.exportComponent(parent);
 392             if (exportComponent.isRight()) {
 393                 log.debug("Failed export tosca yaml for component {} error {}", parent.getUniqueId(), exportComponent.right()
 394                                                                                                                      .value());
 395                 ActionStatus status = componentsUtils.convertFromToscaError(exportComponent.right().value());
 396                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(status);
 397                 return Either.right(responseFormat);
 398             }
 399             log.debug("Tosca yaml exported for component {} ", parent.getUniqueId());
 400             String payload = exportComponent.left().value().getMainYaml();
 401             artifactInfo.setPayloadData(payload);
 402         }
 403         return Either.left(Either.left(artifactInfo));
 404     }
 405
 406     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> doAction(String componentId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactId, ArtifactDefinition artifactInfo, String origMd5,
 407                                                                                    String originData, String interfaceName, String operationName, AuditingActionEnum auditingAction, User user, org.openecomp.sdc.be.model.Component parent, boolean shouldLock, boolean inTransaction, boolean needUpdateGroup) {
 408         switch (operation.getArtifactOperationEnum()) {
 409             case DOWNLOAD:
 410                 if (artifactGenerationRequired(parent, artifactInfo)) {
 411                     return generateNotSavedArtifact(parent, artifactInfo);
 412                 }
 413                 return handleDownload(componentId, artifactId, user, auditingAction, componentType, parent);
 414             case DELETE:
 415                 return handleDelete(componentId, artifactId, user, auditingAction, componentType, parent, shouldLock, inTransaction);
 416             case UPDATE:
 417                 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result = null;
 418                 ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactInfo.getArtifactType());
 419                 if (componentType.equals(ComponentTypeEnum.RESOURCE_INSTANCE)
 420                         && (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_VOL || artifactType == ArtifactTypeEnum.HEAT_NET || artifactType == ArtifactTypeEnum.HEAT_ENV)) {
 421                     result = handleUpdateHeatEnv(componentId, artifactInfo, auditingAction, artifactId, user, componentType, parent, originData, origMd5, operation, shouldLock, inTransaction);
 422                     if (needUpdateGroup && result.isLeft()) {
 423                         Either<ArtifactDefinition, Operation> updateResult = result.left().value();
 424                         ActionStatus error = updateGroupInstance(artifactInfo, updateResult.left()
 425                                                                                            .value(), parent, componentType, componentId);
 426                         if (error != ActionStatus.OK) {
 427                             result = Either.right(componentsUtils.getResponseFormat(error));
 428                         }
 429                     }
 430                 }
 431                 else {
 432                     if (componentType.equals(ComponentTypeEnum.RESOURCE) && artifactType == ArtifactTypeEnum.HEAT_ENV) {
 433                         result = handleUpdateHeatWithHeatEnvParams(componentId, artifactInfo, auditingAction, artifactId, user, componentType, parent, originData, origMd5, operation, shouldLock, inTransaction, needUpdateGroup);
 434                     }
 435                 }
 436                 if (result == null) {
 437                     result = handleUpdate(componentId, artifactInfo, operation, auditingAction, artifactId, user, componentType, parent, origMd5, originData, interfaceName, operationName, shouldLock, inTransaction);
 438                     if (needUpdateGroup && result.isLeft()) {
 439                         Either<ArtifactDefinition, Operation> updateResult = result.left().value();
 440
 441                         ActionStatus error = updateGroupForHeat(artifactInfo, updateResult.left()
 442                                                                                           .value(), parent, componentType);
 443                         if (error != ActionStatus.OK) {
 444                             result = Either.right(componentsUtils.getResponseFormat(error));
 445                         }
 446                     }
 447                 }
 448                 return result;
 449             case CREATE:
 450                 return handleCreate(componentId, artifactInfo, operation, auditingAction, user, componentType, parent, origMd5, originData, interfaceName, operationName, shouldLock, inTransaction);
 451             case LINK:
 452                 return handleLink(componentId, artifactInfo, auditingAction, user, componentType, parent, shouldLock, inTransaction);
 453         }
 454         return null;
 455     }
 456
 457     private ActionStatus updateGroupForHeat(ArtifactDefinition artifactInfo, ArtifactDefinition artAfterUpdate, Component parent, ComponentTypeEnum componentType) {
 458         List<GroupDefinition> groups = parent.getGroups();
 459         if (groups != null && !groups.isEmpty()) {
 460             List<GroupDataDefinition> groupToUpdate = groups.stream()
 461                                                             .filter(g -> g.getArtifacts() != null && g.getArtifacts()
 462                                                                                                       .contains(artifactInfo
 463                                                                                                               .getUniqueId()))
 464                                                             .collect(Collectors.toList());
 465             if (groupToUpdate != null && !groupToUpdate.isEmpty()) {
 466                 groupToUpdate.forEach(g -> {
 467                     g.getArtifacts().remove(artifactInfo.getUniqueId());
 468                     g.getArtifactsUuid().remove(artifactInfo.getArtifactUUID());
 469                     g.getArtifacts().add(artAfterUpdate.getUniqueId());
 470                     g.getArtifactsUuid().add(artAfterUpdate.getArtifactUUID());
 471                 });
 472                 Either<List<GroupDefinition>, StorageOperationStatus> status = toscaOperationFacade.updateGroupsOnComponent(parent, groupToUpdate);
 473                 if (status.isRight()) {
 474                     log.debug(FAILED_UPDATE_GROUPS, parent.getUniqueId());
 475                     return componentsUtils.convertFromStorageResponse(status.right().value());
 476                 }
 477             }
 478         }
 479         return ActionStatus.OK;
 480     }
 481
 482     private ActionStatus updateGroupForHeat(ArtifactDefinition artifactInfoHeat, ArtifactDefinition artHeatAfterUpdate, ArtifactDefinition artifactInfoHeatE, ArtifactDefinition artHEAfterUpdate, Component parent, ComponentTypeEnum componentType) {
 483         List<GroupDefinition> groups = parent.getGroups();
 484         if (groups != null && !groups.isEmpty()) {
 485             List<GroupDataDefinition> groupToUpdate = groups.stream()
 486                                                             .filter(g -> g.getArtifacts() != null && g.getArtifacts()
 487                                                                                                       .contains(artifactInfoHeat
 488                                                                                                               .getUniqueId()))
 489                                                             .collect(Collectors.toList());
 490             if (groupToUpdate != null && !groupToUpdate.isEmpty()) {
 491                 groupToUpdate.forEach(g -> {
 492                     g.getArtifacts().remove(artifactInfoHeat.getUniqueId());
 493                     g.getArtifactsUuid().remove(artifactInfoHeat.getArtifactUUID());
 494                     g.getArtifacts().remove(artifactInfoHeatE.getUniqueId());
 495                     g.getArtifacts().add(artHeatAfterUpdate.getUniqueId());
 496                     g.getArtifactsUuid().add(artHeatAfterUpdate.getArtifactUUID());
 497                     g.getArtifacts().add(artHEAfterUpdate.getUniqueId());
 498                 });
 499                 Either<List<GroupDefinition>, StorageOperationStatus> status = toscaOperationFacade.updateGroupsOnComponent(parent, groupToUpdate);
 500                 if (status.isRight()) {
 501                     log.debug(FAILED_UPDATE_GROUPS, parent.getUniqueId());
 502                     return componentsUtils.convertFromStorageResponse(status.right().value());
 503                 }
 504             }
 505         }
 506         return ActionStatus.OK;
 507     }
 508
 509     private ActionStatus updateGroupInstance(ArtifactDefinition artifactInfo, ArtifactDefinition artAfterUpdate, Component parent, ComponentTypeEnum componentType, String parentId) {
 510         List<GroupInstance> updatedGroupInstances = new ArrayList<>();
 511         List<GroupInstance> groupInstances = null;
 512         Optional<ComponentInstance> componentInstOp = parent.getComponentInstances()
 513                                                             .stream()
 514                                                             .filter(ci -> ci.getUniqueId().equals(parentId))
 515                                                             .findFirst();
 516         if (componentInstOp.isPresent()) {
 517             groupInstances = componentInstOp.get().getGroupInstances();
 518         }
 519         if (CollectionUtils.isNotEmpty(groupInstances)) {
 520             boolean isUpdated = false;
 521             for (GroupInstance groupInstance : groupInstances) {
 522                 isUpdated = false;
 523                 if (CollectionUtils.isNotEmpty(groupInstance.getGroupInstanceArtifacts()) && groupInstance.getGroupInstanceArtifacts()
 524                                                                                                           .contains(artifactInfo
 525                                                                                                                   .getUniqueId())) {
 526                     groupInstance.getGroupInstanceArtifacts().remove(artifactInfo.getUniqueId());
 527                     groupInstance.getGroupInstanceArtifacts().add(artAfterUpdate.getUniqueId());
 528                     isUpdated = true;
 529                 }
 530                 if (CollectionUtils.isNotEmpty(groupInstance.getGroupInstanceArtifactsUuid()) && groupInstance.getGroupInstanceArtifactsUuid()
 531                                                                                                               .contains(artifactInfo
 532                                                                                                                       .getArtifactUUID())) {
 533                     groupInstance.getGroupInstanceArtifactsUuid().remove(artifactInfo.getArtifactUUID());
 534                     groupInstance.getGroupInstanceArtifacts().add(artAfterUpdate.getArtifactUUID());
 535                     isUpdated = true;
 536                 }
 537                 if (isUpdated) {
 538                     updatedGroupInstances.add(groupInstance);
 539                 }
 540             }
 541         }
 542         Either<List<GroupInstance>, StorageOperationStatus> status = toscaOperationFacade.updateGroupInstancesOnComponent(parent, parentId, updatedGroupInstances);
 543         if (status.isRight()) {
 544             log.debug(FAILED_UPDATE_GROUPS, parent.getUniqueId());
 545             return componentsUtils.convertFromStorageResponse(status.right().value());
 546         }
 547         return ActionStatus.OK;
 548     }
 549
 550     Either<Either<ArtifactDefinition, Operation>, ResponseFormat> generateNotSavedArtifact(Component parent, ArtifactDefinition artifactInfo) {
 551         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result;
 552         if (artifactInfo.getArtifactGroupType() == ArtifactGroupTypeEnum.TOSCA) {
 553             result = generateToscaArtifact(parent, artifactInfo, false, false);
 554         }
 555         else {
 556             String heatArtifactId = artifactInfo.getGeneratedFromId();
 557             Either<ArtifactDefinition, StorageOperationStatus> heatRes = artifactToscaOperation.getArtifactById(parent.getUniqueId(), heatArtifactId);
 558             if (heatRes.isRight()) {
 559                 log.debug("Failed to fetch heat artifact by generated id {} for heat env {}", heatArtifactId, artifactInfo
 560                         .getUniqueId());
 561                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(heatRes
 562                         .right()
 563                         .value()), "");
 564                 return Either.right(responseFormat);
 565             }
 566             String generatedPayload = generateHeatEnvPayload(heatRes.left().value());
 567             artifactInfo.setPayloadData(generatedPayload);
 568             result = Either.left(Either.left(artifactInfo));
 569         }
 570         return result;
 571     }
 572
 573     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleUpdateHeatWithHeatEnvParams(String componentId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, String artifactId, User user,
 574                                                                                                             ComponentTypeEnum componentType, Component parent, String originData, String origMd5, ArtifactOperationInfo operation, boolean shouldLock, boolean inTransaction, boolean needToUpdateGroup) {
 575         convertParentType(componentType);
 576         String parentId = parent.getUniqueId();
 577         Either<ArtifactDefinition, StorageOperationStatus> artifactHeatRes = artifactToscaOperation.getArtifactById(componentId, artifactInfo
 578                 .getGeneratedFromId());
 579         ArtifactDefinition currHeatArtifact = artifactHeatRes.left().value();
 580
 581         if (origMd5 != null) {
 582             Either<Boolean, ResponseFormat> validateMd5 = validateMd5(origMd5, originData, artifactInfo.getPayloadData(), operation);
 583             if (validateMd5.isRight()) {
 584                 ResponseFormat responseFormat = validateMd5.right().value();
 585                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
 586                 return Either.right(responseFormat);
 587             }
 588
 589             if (artifactInfo.getPayloadData() != null && artifactInfo.getPayloadData().length != 0) {
 590
 591                 Either<byte[], ResponseFormat> payloadEither = handlePayload(artifactInfo, isArtifactMetadataUpdate(auditingAction));
 592                 if (payloadEither.isRight()) {
 593                     ResponseFormat responseFormat = payloadEither.right().value();
 594                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
 595                     return Either.right(responseFormat);
 596                 }
 597             }
 598             else { // duplicate
 599                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD);
 600                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
 601                 return Either.right(responseFormat);
 602             }
 603         }
 604
 605         // lock resource
 606         if (shouldLock) {
 607             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, UPDATE_ARTIFACT_LOCK);
 608             if (lockComponent.isRight()) {
 609                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, lockComponent.right()
 610                                                                                                             .value(), componentType, null);
 611                 return Either.right(lockComponent.right().value());
 612             }
 613         }
 614         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
 615         try {
 616             resultOp = updateHeatParams(componentId, artifactId, artifactInfo, user, auditingAction, parent, componentType, currHeatArtifact, needToUpdateGroup);
 617             return resultOp;
 618
 619         }
 620         finally {
 621             // unlock resource
 622             if (resultOp == null || resultOp.isRight()) {
 623                 log.debug(ROLLBACK);
 624                 if (!inTransaction) {
 625                     titanDao.rollback();
 626                 }
 627             }
 628             else {
 629                 log.debug(COMMIT);
 630                 if (!inTransaction) {
 631                     titanDao.commit();
 632                 }
 633             }
 634             if (shouldLock) {
 635                 graphLockOperation.unlockComponent(parent.getUniqueId(), parent.getComponentType().getNodeType());
 636             }
 637         }
 638     }
 639
 640     public Either<ImmutablePair<String, byte[]>, ResponseFormat> handleDownloadToscaModelRequest(Component component, ArtifactDefinition csarArtifact) {
 641         if (artifactGenerationRequired(component, csarArtifact)) {
 642             Either<byte[], ResponseFormat> generated = csarUtils.createCsar(component, false, false);
 643
 644             if (generated.isRight()) {
 645                 log.debug("Failed to export tosca csar for component {} error {}", component.getUniqueId(), generated.right()
 646                                                                                                                      .value());
 647
 648                 return Either.right(generated.right().value());
 649             }
 650             return Either.left(new ImmutablePair<String, byte[]>(csarArtifact.getArtifactName(), generated.left()
 651                                                                                                           .value()));
 652         }
 653         return downloadArtifact(csarArtifact);
 654     }
 655
 656     public Either<ImmutablePair<String, byte[]>, ResponseFormat> handleDownloadRequestById(String componentId, String artifactId, String userId, ComponentTypeEnum componentType, String parentId, String containerComponentType) {
 657         // perform all validation in common flow
 658         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result = handleArtifactRequest(componentId, userId, componentType, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.DOWNLOAD), artifactId, null, null, null, null,
 659                 null, parentId, containerComponentType);
 660         if (result.isRight()) {
 661             return Either.right(result.right().value());
 662         }
 663         ArtifactDefinition artifactDefinition;
 664         Either<ArtifactDefinition, Operation> insideValue = result.left().value();
 665         if (insideValue.isLeft()) {
 666             artifactDefinition = insideValue.left().value();
 667         }
 668         else {
 669             artifactDefinition = insideValue.right().value().getImplementationArtifact();
 670         }
 671         // for tosca artifacts and heat env on VF level generated on download without saving
 672         if (artifactDefinition.getPayloadData() != null) {
 673             return Either.left(new ImmutablePair<String, byte[]>(artifactDefinition.getArtifactName(), artifactDefinition
 674                     .getPayloadData()));
 675         }
 676         return downloadArtifact(artifactDefinition);
 677     }
 678
 679     public Either<Map<String, ArtifactDefinition>, ResponseFormat> handleGetArtifactsByType(String containerComponentType, String parentId, ComponentTypeEnum componentType, String componentId, String artifactGroupType, String userId) {
 680         // step 1
 681         // detect auditing type
 682         Map<String, ArtifactDefinition> resMap = null;
 683         Either<Map<String, ArtifactDefinition>, ResponseFormat> resultOp = null;
 684
 685         new Wrapper<>();
 686         // step 2
 687         // check header
 688         if (userId == null) {
 689             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 690             log.debug("handleGetArtifactsByType - no HTTP_CSP_HEADER , component id {}", componentId);
 691
 692             resultOp = Either.right(responseFormat);
 693             return resultOp;
 694         }
 695         // step 3
 696         // check user existence
 697         // step 4
 698         // check user's role
 699
 700         validateUserExists(userId, "get artifacts", false);
 701         // steps 5 - 6 - 7
 702         // 5. check service/resource existence
 703         // 6. check service/resource check out
 704         // 7. user is owner of checkout state
 705         org.openecomp.sdc.be.model.Component component = null;
 706         String realComponentId = componentType == ComponentTypeEnum.RESOURCE_INSTANCE ? parentId : componentId;
 707         ComponentParametersView componentFilter = new ComponentParametersView();
 708         componentFilter.disableAll();
 709         componentFilter.setIgnoreArtifacts(false);
 710         if (componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
 711             componentFilter.setIgnoreComponentInstances(false);
 712         }
 713
 714         Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponent = validateComponentExistsByFilter(realComponentId, ComponentTypeEnum
 715                 .findByParamName(containerComponentType), componentFilter);
 716
 717         if (validateComponent.isRight()) {
 718             resultOp = Either.right(validateComponent.right().value());
 719             return resultOp;
 720         }
 721         component = validateComponent.left().value();
 722         Either<Boolean, ResponseFormat> lockComponent = lockComponent(component, UPDATE_ARTIFACT_LOCK);
 723         if (lockComponent.isRight()) {
 724
 725             resultOp = Either.right(lockComponent.right().value());
 726             return resultOp;
 727         }
 728
 729         try {
 730             ArtifactGroupTypeEnum groupType = ArtifactGroupTypeEnum.findType(artifactGroupType);
 731
 732             if (groupType == null) {
 733                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 734                 log.debug("handleGetArtifactsByType - not falid groupType {} , component id {}", artifactGroupType, componentId);
 735
 736                 resultOp = Either.right(responseFormat);
 737                 return resultOp;
 738
 739             }
 740             if (groupType == ArtifactGroupTypeEnum.DEPLOYMENT) {
 741                 List<ArtifactDefinition> list = getDeploymentArtifacts(component, componentType.getNodeType(), componentId);
 742                 if (list != null && !list.isEmpty()) {
 743                     resMap = list.stream().collect(Collectors.toMap(a -> a.getArtifactLabel(), a -> a));
 744                 }
 745                 else {
 746                     resMap = new HashMap<>();
 747                 }
 748                 resultOp = Either.left(resMap);
 749                 return resultOp;
 750             }
 751             else {
 752
 753                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsMapStatus = getArtifacts(realComponentId, componentType
 754                         .getNodeType(), groupType, componentId);
 755                 if (artifactsMapStatus.isRight()) {
 756                     if (artifactsMapStatus.right().value() != StorageOperationStatus.NOT_FOUND) {
 757                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 758                         log.debug("handleGetArtifactsByType - not falid groupType {} , component id {}", artifactGroupType, componentId);
 759                         resultOp = Either.right(responseFormat);
 760                     }
 761                     else {
 762                         resMap = new HashMap<>();
 763                         resultOp = Either.left(resMap);
 764                     }
 765                 }
 766                 else {
 767                     resMap = artifactsMapStatus.left().value();
 768                     resultOp = Either.left(resMap);
 769                 }
 770                 return resultOp;
 771             }
 772         }
 773         finally {
 774             // unlock resource
 775             if (resultOp == null || resultOp.isRight()) {
 776                 log.debug(ROLLBACK);
 777                 titanDao.rollback();
 778             }
 779             else {
 780                 log.debug(COMMIT);
 781                 titanDao.commit();
 782             }
 783
 784             componentType = component.getComponentType();
 785             NodeTypeEnum nodeType = componentType.getNodeType();
 786             graphLockOperation.unlockComponent(component.getUniqueId(), nodeType);
 787         }
 788
 789     }
 790
 791     private Either<ArtifactDefinition, ResponseFormat> validateArtifact(String componentId, ComponentTypeEnum componentType, String artifactId, Component component) {
 792         // step 9
 793         // check artifact existence
 794         Either<ArtifactDefinition, StorageOperationStatus> artifactResult = artifactToscaOperation.getArtifactById(componentId, artifactId, componentType, component
 795                 .getUniqueId());
 796         if (artifactResult.isRight()) {
 797             if (artifactResult.right().value().equals(StorageOperationStatus.ARTIFACT_NOT_FOUND)) {
 798                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, "");
 799                 log.debug("addArtifact - artifact {} not found", artifactId);
 800                 return Either.right(responseFormat);
 801
 802             }
 803             else {
 804                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(artifactResult
 805                         .right()
 806                         .value()));
 807                 log.debug("addArtifact - failed to fetch artifact {}, error {}", artifactId, artifactResult.right()
 808                                                                                                            .value());
 809                 return Either.right(responseFormat);
 810             }
 811         }
 812         // step 9.1
 813         // check artifact belong to component
 814         boolean found = false;
 815         switch (componentType) {
 816             case RESOURCE:
 817             case SERVICE:
 818                 found = checkArtifactInComponent(component, artifactId);
 819                 break;
 820             case RESOURCE_INSTANCE:
 821                 found = checkArtifactInResourceInstance(component, componentId, artifactId);
 822                 break;
 823             default:
 824
 825         }
 826         if (!found) {
 827             String componentName = componentType.name().toLowerCase();
 828             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_ARTIFACT_NOT_FOUND, componentName);
 829             log.debug("addArtifact - Component artifact not found component Id {}, artifact id {}", componentId, artifactId);
 830             return Either.right(responseFormat);
 831         }
 832         return Either.left(artifactResult.left().value());
 833     }
 834
 835     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleCreate(String componentId, ArtifactDefinition artifactInfo, ArtifactOperationInfo operation, AuditingActionEnum auditingAction, User user, ComponentTypeEnum componentType,
 836                                                                                        org.openecomp.sdc.be.model.Component parent, String origMd5, String originData, String interfaceType, String operationName, boolean shouldLock, boolean inTransaction) {
 837
 838         String artifactId = null;
 839
 840         // step 11
 841         Either<byte[], ResponseFormat> payloadEither = validateInput(componentId, artifactInfo, operation, auditingAction, artifactId, user, componentType, parent, origMd5, originData, interfaceType, operationName);
 842         if (payloadEither.isRight()) {
 843             return Either.right(payloadEither.right().value());
 844         }
 845         byte[] decodedPayload = payloadEither.left().value();
 846         convertParentType(componentType);
 847
 848         if (shouldLock) {
 849             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, "Upload Artifact - lock ");
 850             if (lockComponent.isRight()) {
 851                 handleAuditing(auditingAction, parent, componentId, user, null, null, null, lockComponent.right()
 852                                                                                                          .value(), componentType, null);
 853                 return Either.right(lockComponent.right().value());
 854             }
 855         }
 856         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
 857
 858         try {
 859             resultOp = createArtifact(parent, componentId, artifactInfo, decodedPayload, user, componentType, auditingAction, interfaceType, operationName);
 860             return resultOp;
 861         }
 862         finally {
 863             if (shouldLock) {
 864                 unlockComponent(resultOp, parent, inTransaction);
 865             }
 866
 867         }
 868
 869     }
 870
 871     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleLink(String componentId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, User user, ComponentTypeEnum componentType,
 872                                                                                      Component parent, boolean shouldLock, boolean inTransaction) {
 873
 874         if (shouldLock) {
 875             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, "Upload Artifact - lock ");
 876             if (lockComponent.isRight()) {
 877                 handleAuditing(auditingAction, parent, componentId, user, null, null, null, lockComponent.right()
 878                                                                                                          .value(), componentType, null);
 879                 return Either.right(lockComponent.right().value());
 880             }
 881         }
 882         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
 883
 884         try {
 885             resultOp = createAndLinkArtifact(parent, componentId, artifactInfo, user, componentType, auditingAction);
 886             return resultOp;
 887         }
 888         finally {
 889             if (shouldLock) {
 890                 unlockComponent(resultOp, parent, inTransaction);
 891             }
 892
 893         }
 894
 895     }
 896
 897     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> lockComponentAndUpdateArtifact(String parentId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, String artifactId, User user,
 898                                                                                                          ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component parent, byte[] decodedPayload, String interfaceType, String operationName, boolean shouldLock, boolean inTransaction) {
 899
 900         convertParentType(componentType);
 901
 902         // lock resource
 903         if (shouldLock) {
 904             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, UPDATE_ARTIFACT_LOCK);
 905
 906             if (lockComponent.isRight()) {
 907                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, lockComponent.right()
 908                                                                                                             .value(), componentType, null);
 909                 return Either.right(lockComponent.right().value());
 910             }
 911         }
 912
 913         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
 914         try {
 915             resultOp = updateArtifactFlow(parent, parentId, artifactId, artifactInfo, user, decodedPayload, componentType, auditingAction, interfaceType, operationName);
 916             return resultOp;
 917
 918         }
 919         finally {
 920             if (shouldLock) {
 921                 unlockComponent(resultOp, parent, inTransaction);
 922             }
 923         }
 924     }
 925
 926     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleUpdate(String parentId, ArtifactDefinition artifactInfo, ArtifactOperationInfo operation, AuditingActionEnum auditingAction, String artifactId, User user,
 927                                                                                        ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component parent, String origMd5, String originData, String interfaceType, String operationName, boolean shouldLock, boolean inTransaction) {
 928
 929         Either<byte[], ResponseFormat> payloadEither = validateInput(parentId, artifactInfo, operation, auditingAction, artifactId, user, componentType, parent, origMd5, originData, interfaceType, operationName);
 930
 931         if (payloadEither.isRight()) {
 932             return Either.right(payloadEither.right().value());
 933         }
 934         byte[] decodedPayload = payloadEither.left().value();
 935
 936         return lockComponentAndUpdateArtifact(parentId, artifactInfo, auditingAction, artifactId, user, componentType, parent, decodedPayload, interfaceType, operationName, shouldLock, inTransaction);
 937     }
 938
 939     private Either<byte[], ResponseFormat> validateInput(String componentId, ArtifactDefinition artifactInfo, ArtifactOperationInfo operation, AuditingActionEnum auditingAction, String artifactId, User user, ComponentTypeEnum componentType,
 940                                                          Component parent, String origMd5, String originData, String interfaceType, String operationName) {
 941         // Md5 validations
 942         Either<Boolean, ResponseFormat> validateMd5 = validateMd5(origMd5, originData, artifactInfo.getPayloadData(), operation);
 943         if (validateMd5.isRight()) {
 944             ResponseFormat responseFormat = validateMd5.right().value();
 945             handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
 946             return Either.right(responseFormat);
 947         }
 948
 949         // step 11
 950         Either<ArtifactDefinition, ResponseFormat> validateResult = validateInput(componentId, artifactInfo, operation, artifactId, user, interfaceType, operationName, componentType, parent);
 951         if (validateResult.isRight()) {
 952             ResponseFormat responseFormat = validateResult.right().value();
 953             handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
 954             return Either.right(validateResult.right().value());
 955         }
 956
 957         Either<byte[], ResponseFormat> payloadEither = handlePayload(artifactInfo, isArtifactMetadataUpdate(auditingAction));
 958         if (payloadEither.isRight()) {
 959             ResponseFormat responseFormat = payloadEither.right().value();
 960             handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
 961             log.debug("Error during handle payload");
 962             return Either.right(responseFormat);
 963         }
 964
 965         // validate heat parameters. this part must be after the parameters are
 966         // extracted in "handlePayload"
 967         Either<ArtifactDefinition, ResponseFormat> validateAndConvertHeatParamers = validateAndConvertHeatParamers(artifactInfo, artifactInfo
 968                 .getArtifactType());
 969         if (validateAndConvertHeatParamers.isRight()) {
 970             ResponseFormat responseFormat = validateAndConvertHeatParamers.right().value();
 971             handleAuditing(auditingAction, parent, componentId, user, artifactInfo, null, artifactId, responseFormat, componentType, null);
 972             log.debug("Error during handle payload");
 973             return Either.right(responseFormat);
 974         }
 975         return payloadEither;
 976     }
 977
 978     public void handleAuditing(AuditingActionEnum auditingActionEnum, Component component, String componentId, User user, ArtifactDefinition artifactDefinition, String prevArtifactUuid, String currentArtifactUuid, ResponseFormat responseFormat,
 979                                ComponentTypeEnum componentTypeEnum, String resourceInstanceName) {
 980
 981         if (componentsUtils.isExternalApiEvent(auditingActionEnum)) {
 982             return;
 983         }
 984
 985         if (user == null) {
 986             user = new User();
 987             user.setUserId("UNKNOWN");
 988         }
 989         handleInternalAuditEvent(auditingActionEnum, component, componentId, user, artifactDefinition, prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
 990     }
 991
 992     private void handleInternalAuditEvent(AuditingActionEnum auditingActionEnum, Component component, String componentId, User user, ArtifactDefinition artifactDefinition, String prevArtifactUuid, String currentArtifactUuid, ResponseFormat responseFormat, ComponentTypeEnum componentTypeEnum, String resourceInstanceName) {
 993         switch (componentTypeEnum) {
 994             case RESOURCE:
 995                 Resource resource = (Resource) component;
 996                 if (resource == null) {
 997                     // In that case, component ID should be instead of name
 998                     resource = new Resource();
 999                     resource.setName(componentId);
1000                 }
1001                 componentsUtils.auditResource(responseFormat, user, resource, resource.getName(), auditingActionEnum,
1002                         ResourceVersionInfo.newBuilder()
1003                                 .artifactUuid(prevArtifactUuid)
1004                                 .build(), currentArtifactUuid, artifactDefinition);
1005                 break;
1006
1007             case SERVICE:
1008                 Service service = (Service) component;
1009                 if (service == null) {
1010                     // In that case, component ID should be instead of name
1011                     service = new Service();
1012                     service.setName(componentId);
1013                 }
1014                 componentsUtils.auditComponent(responseFormat, user, service, auditingActionEnum, new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()),
1015                         ResourceVersionInfo.newBuilder()
1016                                 .artifactUuid(prevArtifactUuid)
1017                                 .build(),
1018                         ResourceVersionInfo.newBuilder()
1019                                 .artifactUuid(currentArtifactUuid)
1020                                 .build(),
1021                         null, artifactDefinition, null);
1022                 break;
1023
1024             case RESOURCE_INSTANCE:
1025                 if (resourceInstanceName == null) {
1026                     resourceInstanceName = getResourceInstanceNameFromComponent(component, componentId);
1027                 }
1028                 componentsUtils.auditComponent(responseFormat, user, component, auditingActionEnum,
1029                         new ResourceCommonInfo(resourceInstanceName, ComponentTypeEnum.RESOURCE_INSTANCE.getValue()),
1030                         ResourceVersionInfo.newBuilder()
1031                                 .artifactUuid(prevArtifactUuid)
1032                                 .build(),
1033                         ResourceVersionInfo.newBuilder()
1034                                 .artifactUuid(currentArtifactUuid)
1035                                 .build(),
1036                         null, artifactDefinition, null);
1037                 break;
1038             default:
1039                 break;
1040         }
1041     }
1042
1043     private String getResourceInstanceNameFromComponent(Component component, String componentId) {
1044         ComponentInstance resourceInstance = component.getComponentInstances()
1045                                                       .stream()
1046                                                       .filter(p -> p.getUniqueId().equals(componentId))
1047                                                       .findFirst()
1048                                                       .orElse(null);
1049         String resourceInstanceName = null;
1050         if (resourceInstance != null) {
1051             resourceInstanceName = resourceInstance.getName();
1052         }
1053         return resourceInstanceName;
1054     }
1055
1056     private String buildAuditingArtifactData(ArtifactDefinition artifactDefinition) {
1057         StringBuilder sb = new StringBuilder();
1058         if (artifactDefinition != null) {
1059             sb.append(artifactDefinition.getArtifactGroupType().getType())
1060               .append(",")
1061               .append("'")
1062               .append(artifactDefinition.getArtifactLabel())
1063               .append("'")
1064               .append(",")
1065               .append(artifactDefinition.getArtifactType())
1066               .append(",")
1067               .append(artifactDefinition.getArtifactName())
1068               .append(",")
1069               .append(artifactDefinition.getTimeout())
1070               .append(",")
1071               .append(artifactDefinition.getEsId());
1072
1073             sb.append(",");
1074             if (artifactDefinition.getArtifactVersion() != null) {
1075
1076                 sb.append(artifactDefinition.getArtifactVersion());
1077             }
1078             else {
1079                 sb.append(" ");
1080             }
1081             sb.append(",");
1082             if (artifactDefinition.getArtifactUUID() != null) {
1083                 sb.append(artifactDefinition.getArtifactUUID());
1084             }
1085             else {
1086                 sb.append(" ");
1087             }
1088         }
1089         return sb.toString();
1090     }
1091
1092     private Either<Boolean, ResponseFormat> validateMd5(String origMd5, String originData, byte[] payload, ArtifactOperationInfo operation) {
1093
1094         if (origMd5 != null) {
1095             String encodeBase64Str = GeneralUtility.calculateMD5Base64EncodedByString(originData);
1096             if (!encodeBase64Str.equals(origMd5)) {
1097                 log.debug("The calculated md5 is different then the received one");
1098                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_INVALID_MD5));
1099             }
1100         }
1101         else {
1102             if (ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum()) && payload != null && payload.length != 0) {
1103                 log.debug("Missing md5 header during artifact create");
1104                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_INVALID_MD5));
1105             }
1106             // Update metadata
1107             if (payload != null && payload.length != 0) {
1108                 log.debug("Cannot have payload while md5 header is missing");
1109                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1110             }
1111         }
1112         return Either.left(true);
1113     }
1114
1115     private Either<ArtifactDefinition, ResponseFormat> validateInput(String componentId, ArtifactDefinition artifactInfo, ArtifactOperationInfo operation, String artifactId, User user, String interfaceName, String operationName,
1116                                                                      ComponentTypeEnum componentType, Component parentComponent) {
1117
1118         Either<ArtifactDefinition, ResponseFormat> artifactById = findArtifactOnParentComponent(parentComponent, componentType, componentId, operation, artifactId);
1119         if (artifactById.isRight()) {
1120             return Either.right(artifactById.right().value());
1121         }
1122         ArtifactDefinition currentArtifactInfo = artifactById.left().value();
1123
1124         ignoreUnupdateableFieldsInUpdate(operation, artifactInfo, currentArtifactInfo);
1125         Either<Boolean, ResponseFormat> validateInformationalArtifactRes = validateInformationalArtifact(artifactInfo, parentComponent);
1126         if (validateInformationalArtifactRes.isRight()) {
1127             return Either.right(validateInformationalArtifactRes.right().value());
1128         }
1129         Either<Boolean, ResponseFormat> validateAndSetArtifactname = validateAndSetArtifactname(artifactInfo);
1130         if (validateAndSetArtifactname.isRight()) {
1131             return Either.right(validateAndSetArtifactname.right().value());
1132         }
1133         if (operationName != null && interfaceName != null) {
1134             operationName = operationName.toLowerCase();
1135             interfaceName = interfaceName.toLowerCase();
1136         }
1137         Either<ActionStatus, ResponseFormat> logicalNameStatus = handleArtifactLabel(componentId, parentComponent, operation, artifactInfo, operationName, componentType);
1138         if (logicalNameStatus.isRight()) {
1139             return Either.right(logicalNameStatus.right().value());
1140         }
1141         // This is a patch to block possibility of updating service api fields
1142         // through other artifacts flow
1143
1144         ArtifactGroupTypeEnum artifactGroupType = operationName != null ? ArtifactGroupTypeEnum.LIFE_CYCLE : ArtifactGroupTypeEnum.INFORMATIONAL;
1145         if (!ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
1146             checkAndSetUnUpdatableFields(user, artifactInfo, currentArtifactInfo, artifactGroupType);
1147         }
1148         else {
1149             checkCreateFields(user, artifactInfo, artifactGroupType);
1150         }
1151
1152         composeArtifactId(componentId, artifactId, artifactInfo, interfaceName, operationName);
1153         if (currentArtifactInfo != null) {
1154             artifactInfo.setMandatory(currentArtifactInfo.getMandatory());
1155         }
1156
1157         // artifactGroupType is not allowed to be updated
1158         if (!ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
1159             Either<ArtifactDefinition, ResponseFormat> validateGroupType = validateOrSetArtifactGroupType(artifactInfo, currentArtifactInfo);
1160             if (validateGroupType.isRight()) {
1161                 return Either.right(validateGroupType.right().value());
1162             }
1163         }
1164         NodeTypeEnum parentType = convertParentType(componentType);
1165
1166         boolean isCreate = ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum());
1167
1168         if (isDeploymentArtifact(artifactInfo)) {
1169             Either<Boolean, ResponseFormat> deploymentValidationResult = validateDeploymentArtifact(parentComponent, componentId, isCreate, artifactInfo, currentArtifactInfo, parentType);
1170             if (deploymentValidationResult.isRight()) {
1171                 return Either.right(deploymentValidationResult.right().value());
1172             }
1173         }
1174         else {
1175             artifactInfo.setTimeout(NodeTemplateOperation.NON_HEAT_TIMEOUT);
1176         }
1177
1178         Either<Boolean, ResponseFormat> descriptionResult = validateAndCleanDescription(artifactInfo);
1179         if (descriptionResult.isRight()) {
1180             return Either.right(descriptionResult.right().value());
1181         }
1182
1183         if (currentArtifactInfo != null && currentArtifactInfo.getArtifactGroupType()
1184                                                               .equals(ArtifactGroupTypeEnum.SERVICE_API)) {
1185             Either<ActionStatus, ResponseFormat> validateServiceApiType = validateArtifactType(user.getUserId(), artifactInfo, parentType);
1186             if (validateServiceApiType.isRight()) {
1187                 return Either.right(validateServiceApiType.right().value());
1188             }
1189             // Change of type is not allowed and should be ignored
1190
1191             artifactInfo.setArtifactType(ARTIFACT_TYPE_OTHER);
1192
1193             Either<Boolean, ResponseFormat> validateUrl = validateAndServiceApiUrl(artifactInfo);
1194             if (validateUrl.isRight()) {
1195                 return Either.right(validateUrl.right().value());
1196             }
1197
1198             Either<Boolean, ResponseFormat> validateUpdate = validateFirstUpdateHasPayload(artifactInfo, currentArtifactInfo);
1199             if (validateUpdate.isRight()) {
1200                 log.debug("serviceApi first update cnnot be without payload.");
1201                 return Either.right(validateUpdate.right().value());
1202             }
1203         }
1204         else {
1205             Either<ActionStatus, ResponseFormat> validateArtifactType = validateArtifactType(user.getUserId(), artifactInfo, parentType);
1206             if (validateArtifactType.isRight()) {
1207                 return Either.right(validateArtifactType.right().value());
1208             }
1209             if (artifactInfo.getApiUrl() != null) {
1210                 artifactInfo.setApiUrl(null);
1211                 log.error("Artifact URL cannot be set through this API - ignoring");
1212             }
1213
1214             if (artifactInfo.getServiceApi() != null && artifactInfo.getServiceApi()) {
1215                 artifactInfo.setServiceApi(false);
1216                 log.error("Artifact service API flag cannot be changed - ignoring");
1217             }
1218         }
1219
1220         return Either.left(artifactInfo);
1221     }
1222
1223     private void ignoreUnupdateableFieldsInUpdate(ArtifactOperationInfo operation, ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifactInfo) {
1224         if (operation.getArtifactOperationEnum().equals(ArtifactOperationEnum.UPDATE)) {
1225             artifactInfo.setArtifactType(currentArtifactInfo.getArtifactType());
1226             artifactInfo.setArtifactGroupType(currentArtifactInfo.getArtifactGroupType());
1227             artifactInfo.setArtifactLabel(currentArtifactInfo.getArtifactLabel());
1228         }
1229     }
1230
1231     private Either<ArtifactDefinition, ResponseFormat> findArtifactOnParentComponent(Component parentComponent, ComponentTypeEnum componentType, String parentId, ArtifactOperationInfo operation, String artifactId) {
1232
1233         Either<ArtifactDefinition, ResponseFormat> result = null;
1234         ArtifactDefinition foundArtifact = null;
1235         if (StringUtils.isNotEmpty(artifactId)) {
1236             foundArtifact = findArtifact(parentComponent, componentType, parentId, artifactId);
1237         }
1238         if (foundArtifact != null && ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
1239             log.debug("Artifact {} already exist", artifactId);
1240             result = Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_EXIST, foundArtifact.getArtifactLabel()));
1241         }
1242         if (foundArtifact == null && !ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
1243             log.debug("The artifact {} was not found on parent {}. ", artifactId, parentId);
1244             result = Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, ""));
1245         }
1246         if (result == null) {
1247             result = Either.left(foundArtifact);
1248         }
1249         return result;
1250     }
1251
1252     private ArtifactDefinition findArtifact(Component parentComponent, ComponentTypeEnum componentType, String parentId, String artifactId) {
1253         ArtifactDefinition foundArtifact;
1254         if (parentComponent.getUniqueId().equals(parentId)) {
1255             foundArtifact = artifactsResolver.findArtifactOnComponent(parentComponent, componentType, artifactId);
1256         }
1257         else {
1258             ComponentInstance instance = findComponentInstance(parentId, parentComponent);
1259             foundArtifact = artifactsResolver.findArtifactOnComponentInstance(instance, artifactId);
1260         }
1261         return foundArtifact;
1262     }
1263
1264     private Either<Boolean, ResponseFormat> validateInformationalArtifact(ArtifactDefinition artifactInfo, Component parentComponent) {
1265         ComponentTypeEnum parentComponentType = parentComponent.getComponentType();
1266         ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();
1267         Either<Boolean, ResponseFormat> validationResult = Either.left(true);
1268         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactInfo.getArtifactType());
1269         if (artifactType == null) {
1270             validationResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
1271                     .getArtifactType()));
1272         }
1273         else if (parentComponentType == ComponentTypeEnum.RESOURCE && groupType == ArtifactGroupTypeEnum.INFORMATIONAL) {
1274             String artifactTypeName = artifactType.getType();
1275             ResourceTypeEnum parentResourceType = ((Resource) parentComponent).getResourceType();
1276             Map<String, ArtifactTypeConfig> resourceInformationalArtifacts = ConfigurationManager.getConfigurationManager()
1277                                                                                                  .getConfiguration()
1278                                                                                                  .getResourceInformationalArtifacts();
1279             Set<String> validArtifactTypes = resourceInformationalArtifacts.keySet();
1280             if (!validArtifactTypes.contains(artifactTypeName)) {
1281                 validationResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactTypeName));
1282             }
1283             else {
1284                 List<String> validResourceType = resourceInformationalArtifacts.get(artifactTypeName)
1285                                                                                .getValidForResourceTypes();
1286                 if (!validResourceType.contains(parentResourceType.name())) {
1287                     validationResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactTypeName));
1288                 }
1289             }
1290         }
1291         return validationResult;
1292     }
1293
1294     private NodeTypeEnum convertParentType(ComponentTypeEnum componentType) {
1295         if (componentType.equals(ComponentTypeEnum.RESOURCE)) {
1296             return NodeTypeEnum.Resource;
1297         }
1298         else if (componentType.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1299             return NodeTypeEnum.ResourceInstance;
1300         }
1301         else {
1302             return NodeTypeEnum.Service;
1303         }
1304     }
1305
1306     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete(String parentId, String artifactId, User user, AuditingActionEnum auditingAction, ComponentTypeEnum componentType, Component parent,
1307                                                                                       boolean shouldLock, boolean inTransaction) {
1308
1309         NodeTypeEnum parentType = convertParentType(componentType);
1310         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
1311         Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> getArtifactRes = null;
1312         ArtifactDefinition foundArtifact = null;
1313         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
1314         Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getContainerRes = null;
1315         org.openecomp.sdc.be.model.Component fetchedContainerComponent = null;
1316         boolean isDuplicated = false;
1317         String esId = null;
1318         Either<Boolean, StorageOperationStatus> needCloneRes = null;
1319         try {
1320             if (shouldLock) {
1321                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, "Delete Artifact - lock resource: ");
1322                 if (lockComponent.isRight()) {
1323                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, lockComponent.right()
1324                                                                                                                 .value(), componentType, null);
1325                     resultOp = Either.right(lockComponent.right().value());
1326                 }
1327             }
1328             if (resultOp == null) {
1329                 log.debug("Going to fetch the container component {}. ", parent.getUniqueId());
1330                 getContainerRes = toscaOperationFacade.getToscaElement(parent.getUniqueId());
1331                 if (getContainerRes.isRight()) {
1332                     log.debug("Failed to fetch the container component {}. ", parentId);
1333                     responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(getContainerRes
1334                             .right()
1335                             .value()), artifactId);
1336                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1337                     resultOp = Either.right(responseFormat);
1338                 }
1339             }
1340             if (resultOp == null) {
1341                 fetchedContainerComponent = getContainerRes.left().value();
1342                 log.debug("Going to find the artifact {} on the component {}", artifactId, fetchedContainerComponent.getUniqueId());
1343                 getArtifactRes = findArtifact(artifactId, fetchedContainerComponent, parentId, componentType);
1344                 if (getArtifactRes.isRight()) {
1345                     log.debug("Failed to find the artifact {} belonging to {} on the component {}", artifactId, parentId, fetchedContainerComponent
1346                             .getUniqueId());
1347                     responseFormat = componentsUtils.getResponseFormatByArtifactId(getArtifactRes.right()
1348                                                                                                  .value(), artifactId);
1349                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1350                     resultOp = Either.right(responseFormat);
1351                 }
1352                 else {
1353                     foundArtifact = getArtifactRes.left().value().getLeft();
1354                     esId = foundArtifact.getEsId();
1355                 }
1356             }
1357             if (resultOp == null && StringUtils.isNotEmpty(esId)) {
1358                 needCloneRes = artifactToscaOperation.isCloneNeeded(parent.getUniqueId(), foundArtifact, convertParentType(parent
1359                         .getComponentType()));
1360                 if (needCloneRes.isRight()) {
1361                     log.debug(FAILED_UPDATE_ARTIFACT, artifactId, parentId);
1362                     responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(needCloneRes
1363                             .right()
1364                             .value()), foundArtifact.getArtifactDisplayName());
1365                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1366                     resultOp = Either.right(responseFormat);
1367                 }
1368             }
1369             boolean isNeedToDeleteArtifactFromDB = true;
1370             if (resultOp == null) {
1371
1372                 if (componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
1373                     String instanceId = parentId;
1374                     Either<Boolean, ActionStatus> isOnlyResourceInstanceArtifact = isArtifactOnlyResourceInstanceArtifact(foundArtifact, fetchedContainerComponent, instanceId);
1375
1376                     if (isOnlyResourceInstanceArtifact.isRight()) {
1377                         log.debug(FAILED_UPDATE_ARTIFACT, artifactId, parentId);
1378                         responseFormat = componentsUtils.getResponseFormatByArtifactId(isOnlyResourceInstanceArtifact.right()
1379                                                                                                                      .value(), foundArtifact
1380                                 .getArtifactDisplayName());
1381                         handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1382                         return Either.right(responseFormat);
1383                     }
1384                     isNeedToDeleteArtifactFromDB = isOnlyResourceInstanceArtifact.left().value();
1385                 }
1386
1387                 Either<ArtifactDataDefinition, StorageOperationStatus> updatedArtifactRes = deleteOrUpdateArtifactOnGraph(parent, parentId, artifactId, parentType, foundArtifact, needCloneRes
1388                         .left()
1389                         .value());
1390                 if (updatedArtifactRes.isRight()) {
1391                     log.debug(FAILED_UPDATE_ARTIFACT, artifactId, parentId);
1392                     responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(updatedArtifactRes
1393                             .right()
1394                             .value()), foundArtifact.getArtifactDisplayName());
1395                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1396                     resultOp = Either.right(responseFormat);
1397                 }
1398                 else {
1399                     isDuplicated = updatedArtifactRes.left().value().getDuplicated();
1400                 }
1401             }
1402
1403             if (resultOp == null && (!needCloneRes.left().value() && !isDuplicated) && isNeedToDeleteArtifactFromDB) {
1404                 log.debug("Going to delete the artifact {} from the database. ", artifactId);
1405                 CassandraOperationStatus cassandraStatus = artifactCassandraDao.deleteArtifact(esId);
1406                 if (cassandraStatus != CassandraOperationStatus.OK) {
1407                     log.debug("Failed to delete the artifact {} from the database. ", artifactId);
1408                     responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(componentsUtils.convertToStorageOperationStatus(cassandraStatus)), foundArtifact
1409                             .getArtifactDisplayName());
1410                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1411                     resultOp = Either.right(responseFormat);
1412                 }
1413             }
1414             if (resultOp == null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
1415
1416                 List<GroupInstance> updatedGroupInstances = getUpdatedGroupInstances(artifactId, foundArtifact, getArtifactRes
1417                         .left()
1418                         .value()
1419                         .getRight()
1420                         .getGroupInstances());
1421                 if (CollectionUtils.isNotEmpty(updatedGroupInstances)) {
1422                     Either<List<GroupInstance>, StorageOperationStatus> status = toscaOperationFacade.updateGroupInstancesOnComponent(fetchedContainerComponent, parentId, updatedGroupInstances);
1423                     if (status.isRight()) {
1424                         log.debug(FAILED_UPDATE_GROUPS, fetchedContainerComponent.getUniqueId());
1425                         responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(status
1426                                 .right()
1427                                 .value()), foundArtifact.getArtifactDisplayName());
1428                         handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1429                         resultOp = Either.right(responseFormat);
1430                     }
1431                 }
1432             }
1433             if (resultOp == null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
1434                 StorageOperationStatus status = generateCustomizationUUIDOnInstance(parent.getUniqueId(), parentId, componentType);
1435                 if (status != StorageOperationStatus.OK) {
1436                     log.debug("Failed to generate new customization UUID for the component instance {}. ", parentId);
1437                     responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(status), foundArtifact
1438                             .getArtifactDisplayName());
1439                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1440                     resultOp = Either.right(responseFormat);
1441                 }
1442             }
1443             if (resultOp == null && componentType != ComponentTypeEnum.RESOURCE_INSTANCE) {
1444                 List<GroupDataDefinition> updatedGroups = getUpdatedGroups(artifactId, foundArtifact, fetchedContainerComponent
1445                         .getGroups());
1446                 if (CollectionUtils.isNotEmpty(updatedGroups)) {
1447                     Either<List<GroupDefinition>, StorageOperationStatus> status = toscaOperationFacade.updateGroupsOnComponent(fetchedContainerComponent, updatedGroups);
1448                     if (status.isRight()) {
1449                         log.debug(FAILED_UPDATE_GROUPS, fetchedContainerComponent.getUniqueId());
1450                         responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(status
1451                                 .right()
1452                                 .value()), foundArtifact.getArtifactDisplayName());
1453                         handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
1454                         resultOp = Either.right(responseFormat);
1455                     }
1456                 }
1457             }
1458             if (resultOp == null) {
1459                 resultOp = Either.left(Either.left(foundArtifact));
1460                 handleAuditing(auditingAction, parent, parentId, user, foundArtifact, null, artifactId, responseFormat, componentType, null);
1461             }
1462             return resultOp;
1463         }
1464         finally {
1465             if (shouldLock) {
1466                 unlockComponent(resultOp, parent, inTransaction);
1467             }
1468         }
1469     }
1470
1471     private Either<Boolean, ActionStatus> isArtifactOnlyResourceInstanceArtifact(ArtifactDefinition foundArtifact, Component parent, String instanceId) {
1472         Either<Boolean, ActionStatus> result = Either.left(true);
1473         ComponentInstance foundInstance = null;
1474         Optional<ComponentInstance> componentInstanceOpt = parent.getComponentInstances()
1475                                                                  .stream()
1476                                                                  .filter(i -> i.getUniqueId().equals(instanceId))
1477                                                                  .findFirst();
1478         if (!componentInstanceOpt.isPresent()) {
1479             result = Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER);
1480         }
1481         else {
1482             foundInstance = componentInstanceOpt.get();
1483             String componentUid = foundInstance.getComponentUid();
1484             Either<Component, StorageOperationStatus> getContainerRes = toscaOperationFacade.getToscaElement(componentUid);
1485             if (getContainerRes.isRight()) {
1486                 log.debug("Failed to fetch the container component {}. ", componentUid);
1487                 return Either.right(componentsUtils.convertFromStorageResponse(getContainerRes.right().value()));
1488             }
1489             Component origComponent = getContainerRes.left().value();
1490             Map<String, ArtifactDefinition> deploymentArtifacts = origComponent.getDeploymentArtifacts();
1491             if (deploymentArtifacts != null && !deploymentArtifacts.isEmpty()) {
1492                 Optional<String> op = deploymentArtifacts.keySet()
1493                                                          .stream()
1494                                                          .filter(a -> a.equals(foundArtifact.getArtifactLabel()))
1495                                                          .findAny();
1496                 if (op.isPresent()) {
1497                     return Either.left(false);
1498                 }
1499             }
1500             Map<String, ArtifactDefinition> artifacts = origComponent.getArtifacts();
1501             if (artifacts != null && !artifacts.isEmpty()) {
1502                 Optional<String> op = artifacts.keySet()
1503                                                .stream()
1504                                                .filter(a -> a.equals(foundArtifact.getArtifactLabel()))
1505                                                .findAny();
1506                 if (op.isPresent()) {
1507                     return Either.left(false);
1508                 }
1509             }
1510
1511         }
1512         return result;
1513     }
1514
1515     private List<GroupDataDefinition> getUpdatedGroups(String artifactId, ArtifactDefinition foundArtifact, List<GroupDefinition> groups) {
1516         List<GroupDataDefinition> updatedGroups = new ArrayList<>();
1517         boolean isUpdated = false;
1518         if (groups != null) {
1519             for (GroupDefinition group : groups) {
1520                 isUpdated = false;
1521                 if (CollectionUtils.isNotEmpty(group.getArtifacts()) && group.getArtifacts().contains(artifactId)) {
1522                     group.getArtifacts().remove(artifactId);
1523                     isUpdated = true;
1524                 }
1525                 if (CollectionUtils.isNotEmpty(group.getArtifactsUuid()) && group.getArtifactsUuid()
1526                                                                                  .contains(foundArtifact.getArtifactUUID())) {
1527                     group.getArtifactsUuid().remove(foundArtifact.getArtifactUUID());
1528                     isUpdated = true;
1529                 }
1530                 if (isUpdated) {
1531                     updatedGroups.add(group);
1532                 }
1533             }
1534         }
1535         return updatedGroups;
1536     }
1537
1538     private List<GroupInstance> getUpdatedGroupInstances(String artifactId, ArtifactDefinition foundArtifact, List<GroupInstance> groupInstances) {
1539         List<GroupInstance> updatedGroupInstances = new ArrayList<>();
1540         if (CollectionUtils.isNotEmpty(groupInstances)) {
1541             boolean isUpdated = false;
1542             for (GroupInstance groupInstance : groupInstances) {
1543                 isUpdated = false;
1544                 if (CollectionUtils.isNotEmpty(groupInstance.getGroupInstanceArtifacts()) && groupInstance.getGroupInstanceArtifacts()
1545                                                                                                           .contains(artifactId)) {
1546                     groupInstance.getGroupInstanceArtifacts().remove(artifactId);
1547                     isUpdated = true;
1548                 }
1549                 if (CollectionUtils.isNotEmpty(groupInstance.getGroupInstanceArtifactsUuid()) && groupInstance.getGroupInstanceArtifactsUuid()
1550                                                                                                               .contains(foundArtifact
1551                                                                                                                       .getArtifactUUID())) {
1552                     groupInstance.getGroupInstanceArtifactsUuid().remove(foundArtifact.getArtifactUUID());
1553                     isUpdated = true;
1554                 }
1555                 if (isUpdated) {
1556                     updatedGroupInstances.add(groupInstance);
1557                 }
1558             }
1559         }
1560         return updatedGroupInstances;
1561     }
1562
1563     private Either<ArtifactDataDefinition, StorageOperationStatus> deleteOrUpdateArtifactOnGraph(Component component, String parentId, String artifactId, NodeTypeEnum parentType, ArtifactDefinition foundArtifact, Boolean cloneIsNeeded) {
1564
1565         Either<ArtifactDataDefinition, StorageOperationStatus> result;
1566         boolean isMandatory = foundArtifact.getMandatory() || foundArtifact.getServiceApi();
1567         String componentId = component.getUniqueId();
1568         String instanceId = componentId.equals(parentId) ? null : parentId;
1569         if (isMandatory) {
1570             log.debug("Going to update mandatory artifact {} from the component {}", artifactId, parentId);
1571             resetMandatoryArtifactFields(foundArtifact);
1572             result = artifactToscaOperation.updateArtifactOnGraph(componentId, foundArtifact, parentType, artifactId, instanceId, true, true);
1573         }
1574         else if (cloneIsNeeded) {
1575             log.debug("Going to clone artifacts and to delete the artifact {} from the component {}", artifactId, parentId);
1576             result = artifactToscaOperation.deleteArtifactWithCloningOnGraph(componentId, foundArtifact, parentType, instanceId, false);
1577         }
1578         else {
1579             log.debug("Going to delete the artifact {} from the component {}", artifactId, parentId);
1580             result = artifactToscaOperation.removeArtifactOnGraph(foundArtifact, componentId, instanceId, parentType, false);
1581         }
1582         return result;
1583     }
1584
1585     private Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> findArtifact(String artifactId, Component fetchedContainerComponent, String parentId, ComponentTypeEnum componentType) {
1586
1587         Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result = null;
1588         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1589         ComponentInstance foundInstance = null;
1590         if (componentType == ComponentTypeEnum.RESOURCE_INSTANCE && StringUtils.isNotEmpty(parentId)) {
1591             Optional<ComponentInstance> componentInstanceOpt = fetchedContainerComponent.getComponentInstances()
1592                                                                                         .stream()
1593                                                                                         .filter(i -> i.getUniqueId()
1594                                                                                                       .equals(parentId))
1595                                                                                         .findFirst();
1596             if (!componentInstanceOpt.isPresent()) {
1597                 result = Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER);
1598             }
1599             else {
1600                 foundInstance = componentInstanceOpt.get();
1601                 fetchArtifactsFromInstance(artifactId, artifacts, foundInstance);
1602             }
1603         }
1604         else {
1605             fetchArtifactsFromComponent(artifactId, fetchedContainerComponent, artifacts);
1606         }
1607         if (result == null) {
1608             if (artifacts.containsKey(artifactId)) {
1609                 result = Either.left(new ImmutablePair<>(artifacts.get(artifactId), foundInstance));
1610             }
1611             else {
1612                 result = Either.right(ActionStatus.ARTIFACT_NOT_FOUND);
1613             }
1614         }
1615         return result;
1616     }
1617
1618     private void fetchArtifactsFromComponent(String artifactId, Component component, Map<String, ArtifactDefinition> artifacts) {
1619         Map<String, ArtifactDefinition> currArtifacts;
1620         if (!artifacts.containsKey(artifactId) && MapUtils.isNotEmpty(component.getDeploymentArtifacts())) {
1621             currArtifacts = component.getDeploymentArtifacts()
1622                                      .values()
1623                                      .stream()
1624                                      .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
1625             if (MapUtils.isNotEmpty(currArtifacts)) {
1626                 artifacts.putAll(currArtifacts);
1627             }
1628         }
1629         if (!artifacts.containsKey(artifactId) && MapUtils.isNotEmpty(component.getArtifacts())) {
1630             currArtifacts = component.getArtifacts()
1631                                      .values()
1632                                      .stream()
1633                                      .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
1634             if (MapUtils.isNotEmpty(currArtifacts)) {
1635                 artifacts.putAll(currArtifacts);
1636             }
1637         }
1638         if (!artifacts.containsKey(artifactId) && MapUtils.isNotEmpty(component.getArtifacts())) {
1639             currArtifacts = component.getToscaArtifacts()
1640                                      .values()
1641                                      .stream()
1642                                      .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
1643             if (MapUtils.isNotEmpty(currArtifacts)) {
1644                 artifacts.putAll(currArtifacts);
1645             }
1646         }
1647     }
1648
1649     private void fetchArtifactsFromInstance(String artifactId, Map<String, ArtifactDefinition> artifacts, ComponentInstance instance) {
1650         Map<String, ArtifactDefinition> currArtifacts;
1651         if (MapUtils.isNotEmpty(instance.getDeploymentArtifacts())) {
1652             currArtifacts = instance.getDeploymentArtifacts()
1653                                     .values()
1654                                     .stream()
1655                                     .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
1656             if (MapUtils.isNotEmpty(currArtifacts)) {
1657                 artifacts.putAll(currArtifacts);
1658             }
1659         }
1660         if (!artifacts.containsKey(artifactId) && MapUtils.isNotEmpty(instance.getArtifacts())) {
1661             currArtifacts = instance.getArtifacts()
1662                                     .values()
1663                                     .stream()
1664                                     .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
1665             if (MapUtils.isNotEmpty(currArtifacts)) {
1666                 artifacts.putAll(currArtifacts);
1667             }
1668         }
1669     }
1670
1671     private void resetMandatoryArtifactFields(ArtifactDefinition fetchedArtifact) {
1672         if (fetchedArtifact != null) {
1673             log.debug("Going to reset mandatory artifact {} fields. ", fetchedArtifact.getUniqueId());
1674             fetchedArtifact.setEsId(null);
1675             fetchedArtifact.setArtifactName(null);
1676             fetchedArtifact.setDescription(null);
1677             fetchedArtifact.setApiUrl(null);
1678             fetchedArtifact.setArtifactChecksum(null);
1679             nodeTemplateOperation.setDefaultArtifactTimeout(fetchedArtifact.getArtifactGroupType(), fetchedArtifact);
1680             fetchedArtifact.setArtifactUUID(null);
1681             long time = System.currentTimeMillis();
1682             fetchedArtifact.setPayloadUpdateDate(time);
1683             fetchedArtifact.setHeatParameters(null);
1684             fetchedArtifact.setHeatParamsUpdateDate(null);
1685         }
1686     }
1687
1688     private StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId, ComponentTypeEnum componentType) {
1689         StorageOperationStatus error = StorageOperationStatus.OK;
1690         if (componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
1691             log.debug("Need to re-generate  customization UUID for instance {}", instanceId);
1692             error = toscaOperationFacade.generateCustomizationUUIDOnInstance(componentId, instanceId);
1693         }
1694         return error;
1695     }
1696
1697     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDownload(String componentId, String artifactId, User user, AuditingActionEnum auditingAction, ComponentTypeEnum componentType,
1698                                                                                          Component parent) {
1699         Either<ArtifactDefinition, StorageOperationStatus> artifactById = artifactToscaOperation.getArtifactById(componentId, artifactId, componentType, parent
1700                 .getUniqueId());
1701         if (artifactById.isRight()) {
1702             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(artifactById.right().value());
1703             log.debug("Error when getting artifact info by id{}, error: {}", artifactId, actionStatus);
1704             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(actionStatus, "");
1705             handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
1706             return Either.right(responseFormat);
1707         }
1708         ArtifactDefinition artifactDefinition = artifactById.left().value();
1709         if (artifactDefinition == null) {
1710             log.debug("Empty artifact definition returned from DB by artifact id {}", artifactId);
1711             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, "");
1712             handleAuditing(auditingAction, parent, componentId, user, null, null, artifactId, responseFormat, componentType, null);
1713             return Either.right(responseFormat);
1714         }
1715
1716         Either<ArtifactDefinition, Operation> insideEither = Either.left(artifactDefinition);
1717         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
1718         handleAuditing(auditingAction, parent, componentId, user, artifactDefinition, null, artifactId, responseFormat, componentType, null);
1719         return Either.left(insideEither);
1720     }
1721
1722     private Either<ActionStatus, ResponseFormat> handleArtifactLabel(String componentId, Component parentComponent, ArtifactOperationInfo operation, ArtifactDefinition artifactInfo, String operationName,
1723                                                                      ComponentTypeEnum componentType) {
1724
1725         String artifactLabel = artifactInfo.getArtifactLabel();
1726         if (operationName == null && (artifactInfo.getArtifactLabel() == null || artifactInfo.getArtifactLabel()
1727                                                                                              .isEmpty())) {
1728             BeEcompErrorManager.getInstance()
1729                                .logBeMissingArtifactInformationError("Artifact Update / Upload", "artifactLabel");
1730             log.debug("missing artifact logical name for component {}", componentId);
1731             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_LABEL));
1732         }
1733         if (ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum()) && !artifactInfo.getMandatory()) {
1734
1735             if (operationName != null) {
1736                 if (artifactInfo.getArtifactLabel() != null && !operationName.equals(artifactInfo.getArtifactLabel())) {
1737                     log.debug("artifact label cannot be set {}", artifactLabel);
1738                     return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED));
1739                 }
1740                 else {
1741                     artifactLabel = operationName;
1742                 }
1743             }
1744             String displayName = artifactInfo.getArtifactDisplayName();
1745             if (displayName == null || displayName.isEmpty()) {
1746                 displayName = artifactLabel;
1747             }
1748             displayName = ValidationUtils.cleanArtifactDisplayName(displayName);
1749             artifactInfo.setArtifactDisplayName(displayName);
1750
1751             if (!ValidationUtils.validateArtifactLabel(artifactLabel)) {
1752                 log.debug("Invalid format form Artifact label : {}", artifactLabel);
1753                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1754             }
1755             artifactLabel = ValidationUtils.normalizeArtifactLabel(artifactLabel);
1756
1757             if (artifactLabel.isEmpty()) {
1758                 log.debug("missing normalized artifact logical name for component {}", componentId);
1759                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_LABEL));
1760             }
1761
1762             if (!ValidationUtils.validateArtifactLabelLength(artifactLabel)) {
1763                 log.debug("Invalid lenght form Artifact label : {}", artifactLabel);
1764                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, ARTIFACT_LABEL, String
1765                         .valueOf(ValidationUtils.ARTIFACT_LABEL_LENGTH)));
1766             }
1767             if (!validateLabelUniqueness(componentId, parentComponent, artifactLabel, componentType)) {
1768                 log.debug("Non unique Artifact label : {}", artifactLabel);
1769                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_EXIST, artifactLabel));
1770             }
1771         }
1772         artifactInfo.setArtifactLabel(artifactLabel);
1773
1774         return Either.left(ActionStatus.OK);
1775     }
1776
1777     private boolean validateLabelUniqueness(String componentId, Component parentComponent, String artifactLabel, ComponentTypeEnum componentType) {
1778         boolean isUnique = true;
1779         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts;
1780         if (componentType.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1781             artifacts = artifactToscaOperation.getAllInstanceArtifacts(parentComponent.getUniqueId(), componentId);
1782         }
1783         else {
1784             artifacts = artifactToscaOperation.getArtifacts(componentId);
1785         }
1786
1787         if (artifacts.isLeft()) {
1788             for (String label : artifacts.left().value().keySet()) {
1789                 if (label.equals(artifactLabel)) {
1790                     isUnique = false;
1791                     break;
1792                 }
1793             }
1794         }
1795         if (componentType.equals(ComponentTypeEnum.RESOURCE)) {
1796             Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource = interfaceLifecycleOperation
1797                     .getAllInterfacesOfResource(componentId, true, true);
1798             if (allInterfacesOfResource.isLeft()) {
1799                 for (InterfaceDefinition interace : allInterfacesOfResource.left().value().values()) {
1800                     for (Operation operation : interace.getOperationsMap().values()) {
1801                         if (operation.getImplementation() != null && operation.getImplementation()
1802                                                                               .getArtifactLabel()
1803                                                                               .equals(artifactLabel)) {
1804                             isUnique = false;
1805                             break;
1806                         }
1807                     }
1808                 }
1809             }
1810         }
1811         return isUnique;
1812     }
1813
1814     boolean validateArtifactNameUniqueness(String componentId, Component parentComponent, ArtifactDefinition artifactInfo,
1815                                            ComponentTypeEnum componentType) {
1816         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = getArtifacts(componentType,
1817                 parentComponent, componentId, artifactInfo.getArtifactGroupType());
1818         String artifactName = artifactInfo.getArtifactName();
1819         if (artifacts.isLeft() && Objects.nonNull(artifacts.left().value())){
1820             if (artifacts.left().value().values().stream()
1821                     .anyMatch(ad -> artifactName.equals(ad.getArtifactName())
1822                             //check whether it is the same artifact we hold (by label)
1823                             && !artifactInfo.getArtifactLabel().equals(ad.getArtifactLabel()))){
1824                 return false;
1825             }
1826         }
1827         if (ComponentTypeEnum.RESOURCE.equals(componentType)) {
1828             return isUniqueArtifactNameInResourceInterfaces(componentId, artifactName, artifactInfo.getArtifactLabel());
1829         }
1830         return true;
1831     }
1832
1833     private boolean isUniqueArtifactNameInResourceInterfaces(String componentId, String artifactName, String artifactLabel) {
1834         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource = interfaceLifecycleOperation
1835                 .getAllInterfacesOfResource(componentId, true, true);
1836
1837         if (allInterfacesOfResource.isLeft() && Objects.nonNull(allInterfacesOfResource)){
1838             return !allInterfacesOfResource.left().value()
1839                     .values()
1840                     .stream().map(InterfaceDefinition :: getOperationsMap)
1841                     .flatMap(map -> map.values().stream())
1842                     .map(OperationDataDefinition::getImplementation)
1843                     .filter(Objects::nonNull)
1844                     .anyMatch(add -> artifactName.equals(add.getArtifactName())
1845                             && !artifactLabel.equals(add.getArtifactLabel()));
1846         }
1847         return true;
1848     }
1849
1850     private boolean isUniqueLabelInResourceInterfaces(String componentId, String artifactLabel) {
1851         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource = interfaceLifecycleOperation
1852                 .getAllInterfacesOfResource(componentId, true, true);
1853
1854         if (allInterfacesOfResource.isLeft()){
1855             return !allInterfacesOfResource.left().value()
1856                     .values()
1857                     .stream().map(InterfaceDefinition :: getOperationsMap)
1858                     .flatMap(map -> map.values().stream())
1859                     .map(OperationDataDefinition::getImplementation)
1860                     .filter(Objects::nonNull)
1861                     .anyMatch(add -> artifactLabel.equals(add.getArtifactLabel()));
1862         }
1863         return true;
1864     }
1865
1866     private Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(ComponentTypeEnum componentType, Component parentComponent,
1867                                                                                          String componentId, ArtifactGroupTypeEnum artifactGroupType) {
1868         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsResponse;
1869         if (componentType.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1870             artifactsResponse = artifactToscaOperation.getAllInstanceArtifacts(parentComponent.getUniqueId(), componentId);
1871         }
1872         else {
1873             artifactsResponse = artifactToscaOperation.getArtifacts(componentId);
1874         }
1875         if (artifactsResponse.isRight() && artifactsResponse.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
1876             log.debug("failed to retrieve artifacts for {} ", componentId);
1877             return Either.right(artifactsResponse.right().value());
1878         }
1879         return Either.left(artifactsResponse.left().value().entrySet()
1880                 .stream()
1881                 .filter(x -> artifactGroupType.equals(x.getValue().getArtifactGroupType()))
1882                 .collect(Collectors.toMap(Entry::getKey, Entry::getValue)));
1883     }
1884
1885     private List<String> getListOfArtifactName(Map<String, ArtifactDefinition> artifacts) {
1886         return artifacts.entrySet()
1887                 .stream()
1888                 .map(x -> x.getValue().getArtifactName())
1889                 .collect(Collectors.toList());
1890     }
1891
1892     // ***************************************************************
1893
1894     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> createAndLinkArtifact(org.openecomp.sdc.be.model.Component parent, String parentId, ArtifactDefinition artifactInfo, User user,
1895                                                                                                 ComponentTypeEnum componentTypeEnum, AuditingActionEnum auditingActionEnum) {
1896         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
1897         Either<ArtifactDefinition, Operation> insideEither = null;
1898         ComponentInstance foundInstance = findComponentInstance(parentId, parent);
1899         String instanceId = null;
1900         String instanceName = null;
1901         if (foundInstance != null) {
1902             instanceId = foundInstance.getUniqueId();
1903             instanceName = foundInstance.getName();
1904         }
1905         boolean isLeft = false;
1906         String artifactUniqueId = null;
1907         StorageOperationStatus error = null;
1908         // information/deployment/api aritfacts
1909         log.trace("Try to create entry on graph");
1910         NodeTypeEnum nodeType = convertParentType(componentTypeEnum);
1911         Either<ArtifactDefinition, StorageOperationStatus> result = artifactToscaOperation.addArifactToComponent(artifactInfo, parent
1912                 .getUniqueId(), nodeType, true, instanceId);
1913
1914         isLeft = result.isLeft();
1915         if (isLeft) {
1916             artifactUniqueId = result.left().value().getUniqueId();
1917             result.left().value();
1918
1919             insideEither = Either.left(result.left().value());
1920             resultOp = Either.left(insideEither);
1921
1922             error = generateCustomizationUUIDOnInstance(parent.getUniqueId(), parentId, componentTypeEnum);
1923             if (error != StorageOperationStatus.OK) {
1924                 isLeft = false;
1925             }
1926
1927         }
1928         if (isLeft) {
1929             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
1930             handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, artifactUniqueId, artifactUniqueId, responseFormat, componentTypeEnum, instanceName);
1931             return resultOp;
1932         }
1933         else {
1934             log.debug("Failed to create entry on graph for artifact {}", artifactInfo.getArtifactName());
1935             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(error), artifactInfo
1936                     .getArtifactDisplayName());
1937             handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, null, null, responseFormat, componentTypeEnum, instanceName);
1938             resultOp = Either.right(responseFormat);
1939             return resultOp;
1940
1941         }
1942     }
1943
1944     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> createArtifact(org.openecomp.sdc.be.model.Component parent, String parentId, ArtifactDefinition artifactInfo, byte[] decodedPayload, User user,
1945                                                                                          ComponentTypeEnum componentTypeEnum, AuditingActionEnum auditingActionEnum, String interfaceType, String operationName) {
1946
1947         ESArtifactData artifactData = createEsArtifactData(artifactInfo, decodedPayload);
1948         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
1949         Either<ArtifactDefinition, Operation> insideEither = null;
1950         ComponentInstance foundInstance = findComponentInstance(parentId, parent);
1951         String instanceId = null;
1952         String instanceName = null;
1953         if (foundInstance != null) {
1954             if (foundInstance.isArtifactExists(artifactInfo.getArtifactGroupType(), artifactInfo.getArtifactLabel())) {
1955                 log.debug("Failed to create artifact, already exists");
1956                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_EXIST, artifactInfo
1957                         .getArtifactLabel());
1958                 handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, null, artifactInfo.getUniqueId(), responseFormat, componentTypeEnum, foundInstance
1959                         .getName());
1960                 resultOp = Either.right(responseFormat);
1961                 return resultOp;
1962             }
1963
1964             instanceId = foundInstance.getUniqueId();
1965             instanceName = foundInstance.getName();
1966         }
1967         if (artifactData == null) {
1968             BeEcompErrorManager.getInstance().logBeDaoSystemError("Upload Artifact");
1969             log.debug("Failed to create artifact object for ES.");
1970             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1971             handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, null, null, responseFormat, componentTypeEnum, null);
1972             resultOp = Either.right(responseFormat);
1973             return resultOp;
1974
1975         }
1976         // set on graph object id of artifact in ES!
1977         artifactInfo.setEsId(artifactData.getId());
1978
1979         boolean isLeft = false;
1980         String artifactUniqueId = null;
1981         StorageOperationStatus error = null;
1982         if (interfaceType != null && operationName != null) {
1983             // lifecycle artifact
1984             Operation operation = convertToOperation(artifactInfo, operationName);
1985
1986             Either<Operation, StorageOperationStatus> result = interfaceLifecycleOperation.updateInterfaceOperation(parentId, interfaceType, operationName, operation);
1987
1988             isLeft = result.isLeft();
1989             if (isLeft) {
1990                 artifactUniqueId = result.left().value().getImplementation().getUniqueId();
1991                 result.left().value().getImplementation();
1992
1993                 insideEither = Either.right(result.left().value());
1994                 resultOp = Either.left(insideEither);
1995             }
1996             else {
1997                 error = result.right().value();
1998             }
1999         }
2000         else {
2001             // information/deployment/api aritfacts
2002             log.trace("Try to create entry on graph");
2003             NodeTypeEnum nodeType = convertParentType(componentTypeEnum);
2004             Either<ArtifactDefinition, StorageOperationStatus> result = artifactToscaOperation.addArifactToComponent(artifactInfo, parent
2005                     .getUniqueId(), nodeType, true, instanceId);
2006
2007             isLeft = result.isLeft();
2008             if (isLeft) {
2009                 artifactUniqueId = result.left().value().getUniqueId();
2010                 artifactData.setId(result.left().value().getEsId());
2011                 insideEither = Either.left(result.left().value());
2012                 resultOp = Either.left(insideEither);
2013
2014                 error = generateCustomizationUUIDOnInstance(parent.getUniqueId(), parentId, componentTypeEnum);
2015                 if (error != StorageOperationStatus.OK) {
2016                     isLeft = false;
2017                 }
2018
2019             }
2020             else {
2021                 error = result.right().value();
2022             }
2023         }
2024         if (isLeft) {
2025             boolean res = saveArtifacts(artifactData, parentId);
2026
2027             if (res) {
2028                 log.debug(ARTIFACT_SAVED, artifactUniqueId);
2029
2030                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
2031                 handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, artifactUniqueId, artifactUniqueId, responseFormat, componentTypeEnum, instanceName);
2032                 return resultOp;
2033             }
2034             else {
2035                 BeEcompErrorManager.getInstance().logBeDaoSystemError("Upload Artifact");
2036                 log.debug(FAILED_SAVE_ARTIFACT);
2037                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
2038                 handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, null, artifactUniqueId, responseFormat, componentTypeEnum, instanceName);
2039
2040                 resultOp = Either.right(responseFormat);
2041                 return resultOp;
2042             }
2043         }
2044         else {
2045             log.debug("Failed to create entry on graph for artifact {}", artifactInfo.getArtifactName());
2046             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(error), artifactInfo
2047                     .getArtifactDisplayName());
2048             handleAuditing(auditingActionEnum, parent, parentId, user, artifactInfo, null, null, responseFormat, componentTypeEnum, instanceName);
2049             resultOp = Either.right(responseFormat);
2050             return resultOp;
2051         }
2052
2053     }
2054
2055     private ComponentInstance findComponentInstance(String componentInstanceId, Component containerComponent) {
2056         ComponentInstance foundInstance = null;
2057         if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstances())) {
2058             foundInstance = containerComponent.getComponentInstances()
2059                                               .stream()
2060                                               .filter(i -> i.getUniqueId().equals(componentInstanceId))
2061                                               .findFirst()
2062                                               .orElse(null);
2063         }
2064         return foundInstance;
2065     }
2066
2067     private Either<Boolean, ResponseFormat> validateDeploymentArtifact(Component parentComponent, String parentId, boolean isCreate, ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact, NodeTypeEnum parentType) {
2068
2069         Either<Boolean, ResponseFormat> result = Either.left(true);
2070         Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
2071
2072         validateArtifactTypeExists(responseWrapper, artifactInfo);
2073
2074         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactInfo.getArtifactType());
2075
2076         Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = fillDeploymentArtifactTypeConf(parentType);
2077
2078         if (responseWrapper.isEmpty()) {
2079             validateDeploymentArtifactConf(artifactInfo, responseWrapper, artifactType, resourceDeploymentArtifacts);
2080         }
2081
2082         // Common code for all types
2083         // not allowed to change artifactType
2084         if (responseWrapper.isEmpty() && !isCreate) {
2085             Either<Boolean, ResponseFormat> validateServiceApiType = validateArtifactTypeNotChanged(artifactInfo, currentArtifact);
2086             if (validateServiceApiType.isRight()) {
2087                 responseWrapper.setInnerElement(validateServiceApiType.right().value());
2088             }
2089         }
2090         if (responseWrapper.isEmpty()) {
2091             if (parentType.equals(NodeTypeEnum.Resource)) {
2092                 Resource resource = (Resource) parentComponent;
2093                 ResourceTypeEnum resourceType = resource.getResourceType();
2094                 ArtifactTypeConfig config = resourceDeploymentArtifacts.get(artifactType.getType());
2095                 if (config == null) {
2096                     responseWrapper.setInnerElement(ResponseFormatManager.getInstance()
2097                                                                          .getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
2098                                                                                  .getArtifactType()));
2099                 }
2100                 else {
2101                     List<String> myList = config.getValidForResourceTypes();
2102                     Either<Boolean, ResponseFormat> either = validateResourceType(resourceType, artifactInfo, myList);
2103                     if (either.isRight()) {
2104                         responseWrapper.setInnerElement(either.right().value());
2105                     }
2106                 }
2107             }
2108
2109             validateFileExtension(responseWrapper, () -> getDeploymentArtifactTypeConfig(parentType, artifactType), artifactInfo, parentType, artifactType);
2110         }
2111
2112         if (responseWrapper.isEmpty() && !NodeTypeEnum.ResourceInstance.equals(parentType)) {
2113             String artifactName = artifactInfo.getArtifactName();
2114             if (isCreate || !artifactName.equalsIgnoreCase(currentArtifact.getArtifactName())) {
2115                 validateSingleDeploymentArtifactName(responseWrapper, artifactName, parentComponent, parentType);
2116             }
2117         }
2118
2119         if (responseWrapper.isEmpty()) {
2120             switch (artifactType) {
2121                 case HEAT:
2122                 case HEAT_VOL:
2123                 case HEAT_NET:
2124                     result = validateHeatDeploymentArtifact(isCreate, artifactInfo, currentArtifact);
2125                     break;
2126                 case HEAT_ENV:
2127                     result = validateHeatEnvDeploymentArtifact(parentComponent, parentId, artifactInfo, parentType);
2128                     artifactInfo.setTimeout(NodeTemplateOperation.NON_HEAT_TIMEOUT);
2129                     break;
2130                 case DCAE_INVENTORY_TOSCA:
2131                 case DCAE_INVENTORY_JSON:
2132                 case DCAE_INVENTORY_POLICY:
2133                     // Validation is done in handle payload.
2134                 case DCAE_INVENTORY_DOC:
2135                 case DCAE_INVENTORY_BLUEPRINT:
2136                 case DCAE_INVENTORY_EVENT:
2137                     // No specific validation
2138                 default:
2139                     artifactInfo.setTimeout(NodeTemplateOperation.NON_HEAT_TIMEOUT);
2140                     break;
2141             }
2142
2143         }
2144
2145         if (!responseWrapper.isEmpty()) {
2146             result = Either.right(responseWrapper.getInnerElement());
2147         }
2148         return result;
2149     }
2150
2151     private void validateDeploymentArtifactConf(ArtifactDefinition artifactInfo, Wrapper<ResponseFormat> responseWrapper, ArtifactTypeEnum artifactType, Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts) {
2152         if ((resourceDeploymentArtifacts == null) || !resourceDeploymentArtifacts.containsKey(artifactType.name())) {
2153             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2154                                                                  .getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
2155                                                                          .getArtifactType());
2156             responseWrapper.setInnerElement(responseFormat);
2157             log.debug("Artifact Type: {} Not found !", artifactInfo.getArtifactType());
2158         }
2159     }
2160
2161     private Map<String, ArtifactTypeConfig> fillDeploymentArtifactTypeConf(NodeTypeEnum parentType) {
2162         Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = null;
2163         if (parentType.equals(NodeTypeEnum.Resource)) {
2164             resourceDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
2165                                                               .getConfiguration()
2166                                                               .getResourceDeploymentArtifacts();
2167         }
2168         else if (parentType.equals(NodeTypeEnum.ResourceInstance)) {
2169             resourceDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
2170                                                               .getConfiguration()
2171                                                               .getResourceInstanceDeploymentArtifacts();
2172         }
2173         else {
2174             resourceDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
2175                                                               .getConfiguration()
2176                                                               .getServiceDeploymentArtifacts();
2177         }
2178         return resourceDeploymentArtifacts;
2179     }
2180
2181     public void validateArtifactTypeExists(Wrapper<ResponseFormat> responseWrapper, ArtifactDefinition artifactInfo) {
2182         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactInfo.getArtifactType());
2183         if (artifactType == null) {
2184             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2185                                                                  .getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
2186                                                                          .getArtifactType());
2187             responseWrapper.setInnerElement(responseFormat);
2188             log.debug("Artifact Type: {} Not found !", artifactInfo.getArtifactType());
2189         }
2190     }
2191
2192     private ArtifactTypeConfig getDeploymentArtifactTypeConfig(NodeTypeEnum parentType, ArtifactTypeEnum artifactType) {
2193         ArtifactTypeConfig retConfig = null;
2194         String fileType = artifactType.getType();
2195         if (parentType.equals(NodeTypeEnum.Resource)) {
2196             retConfig = ConfigurationManager.getConfigurationManager()
2197                                             .getConfiguration()
2198                                             .getResourceDeploymentArtifacts()
2199                                             .get(fileType);
2200         }
2201         else if (parentType.equals(NodeTypeEnum.Service)) {
2202             retConfig = ConfigurationManager.getConfigurationManager()
2203                                             .getConfiguration()
2204                                             .getServiceDeploymentArtifacts()
2205                                             .get(fileType);
2206         }
2207         else if (parentType.equals(NodeTypeEnum.ResourceInstance)) {
2208             retConfig = ConfigurationManager.getConfigurationManager()
2209                                             .getConfiguration()
2210                                             .getResourceInstanceDeploymentArtifacts()
2211                                             .get(fileType);
2212         }
2213         return retConfig;
2214     }
2215
2216     private Either<Boolean, ResponseFormat> extractHeatParameters(ArtifactDefinition artifactInfo) {
2217         // extract heat parameters
2218         if (artifactInfo.getPayloadData() != null) {
2219             String heatDecodedPayload = new String(Base64.decodeBase64(artifactInfo.getPayloadData()));
2220             Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils.getHeatParamsWithoutImplicitTypes(heatDecodedPayload, artifactInfo
2221                     .getArtifactType());
2222             if (heatParameters.isRight() && (!heatParameters.right()
2223                                                             .value()
2224                                                             .equals(ResultStatusEnum.ELEMENT_NOT_FOUND))) {
2225                 log.info("failed to parse heat parameters ");
2226                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, artifactInfo
2227                         .getArtifactType());
2228                 return Either.right(responseFormat);
2229             }
2230             else if (heatParameters.isLeft() && heatParameters.left().value() != null) {
2231                 artifactInfo.setListHeatParameters(heatParameters.left().value());
2232             }
2233         }
2234         return Either.left(true);
2235
2236     }
2237
2238     // Valid extension
2239     public void validateFileExtension(Wrapper<ResponseFormat> responseWrapper, IDeploymentArtifactTypeConfigGetter deploymentConfigGetter, ArtifactDefinition artifactInfo, NodeTypeEnum parentType, ArtifactTypeEnum artifactType) {
2240         String fileType = artifactType.getType();
2241         List<String> acceptedTypes = null;
2242         ArtifactTypeConfig deploymentAcceptedTypes = deploymentConfigGetter.getDeploymentArtifactConfig();
2243         if (!parentType.equals(NodeTypeEnum.Resource) && !parentType.equals(NodeTypeEnum.Service) && !parentType.equals(NodeTypeEnum.ResourceInstance)) {
2244             log.debug("parent type of artifact can be either resource or service");
2245             responseWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2246             return;
2247         }
2248
2249         if (deploymentAcceptedTypes == null) {
2250             log.debug("parent type of artifact can be either resource or service");
2251             responseWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
2252                     .getArtifactType()));
2253             return;
2254         }
2255         else {
2256             acceptedTypes = deploymentAcceptedTypes.getAcceptedTypes();
2257         }
2258         /*
2259          * No need to check specific types. In case there are no acceptedTypes in configuration, then any type is accepted.
2260          */
2261
2262         String artifactName = artifactInfo.getArtifactName();
2263         String fileExtension = GeneralUtility.getFilenameExtension(artifactName);
2264         // Pavel - File extension validation is case-insensitive - Ella,
2265         // 21/02/2016
2266         if (acceptedTypes != null && !acceptedTypes.isEmpty() && !acceptedTypes.contains(fileExtension.toLowerCase())) {
2267             log.debug("File extension \"{}\" is not allowed for {} which is of type:{}", fileExtension, artifactName, fileType);
2268             responseWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION, fileType));
2269             return;
2270         }
2271     }
2272
2273     private Either<Boolean, ResponseFormat> validateHeatEnvDeploymentArtifact(Component parentComponent, String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum parentType) {
2274
2275         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
2276         Wrapper<ArtifactDefinition> heatMDWrapper = new Wrapper<>();
2277         Wrapper<byte[]> payloadWrapper = new Wrapper<>();
2278
2279         if (errorWrapper.isEmpty()) {
2280             validateValidYaml(errorWrapper, artifactInfo);
2281         }
2282
2283         if (errorWrapper.isEmpty()) {
2284             // Validate Heat Exist
2285             validateHeatExist(parentComponent.getUniqueId(), parentId, errorWrapper, heatMDWrapper, artifactInfo, parentType, parentComponent
2286                     .getComponentType());
2287         }
2288
2289         if (errorWrapper.isEmpty() && !heatMDWrapper.isEmpty()) {
2290             fillArtifactPayloadValidation(errorWrapper, payloadWrapper, heatMDWrapper.getInnerElement());
2291         }
2292
2293         if (errorWrapper.isEmpty() && !heatMDWrapper.isEmpty()) {
2294             validateEnvVsHeat(errorWrapper, artifactInfo, heatMDWrapper.getInnerElement(), payloadWrapper.getInnerElement());
2295         }
2296
2297         // init Response
2298         Either<Boolean, ResponseFormat> eitherResponse;
2299         if (errorWrapper.isEmpty()) {
2300             eitherResponse = Either.left(true);
2301         }
2302         else {
2303             eitherResponse = Either.right(errorWrapper.getInnerElement());
2304         }
2305         return eitherResponse;
2306     }
2307
2308     public void fillArtifactPayloadValidation(Wrapper<ResponseFormat> errorWrapper, Wrapper<byte[]> payloadWrapper, ArtifactDefinition artifactDefinition) {
2309         if (artifactDefinition.getPayloadData() == null || artifactDefinition.getPayloadData().length == 0) {
2310             Either<Boolean, ResponseFormat> fillArtifactPayload = fillArtifactPayload(payloadWrapper, artifactDefinition);
2311             if (fillArtifactPayload.isRight()) {
2312                 errorWrapper.setInnerElement(fillArtifactPayload.right().value());
2313                 log.debug("Error getting payload for artifact:{}", artifactDefinition.getArtifactName());
2314             }
2315         }
2316         else {
2317             payloadWrapper.setInnerElement(artifactDefinition.getPayloadData());
2318         }
2319     }
2320
2321     public Either<Boolean, ResponseFormat> fillArtifactPayload(Wrapper<byte[]> payloadWrapper, ArtifactDefinition artifactMD) {
2322         Either<Boolean, ResponseFormat> result = Either.left(true);
2323         Either<ESArtifactData, CassandraOperationStatus> eitherArtifactData = artifactCassandraDao.getArtifact(artifactMD
2324                 .getEsId());
2325         if (eitherArtifactData.isLeft()) {
2326             byte[] data = eitherArtifactData.left().value().getDataAsArray();
2327             data = Base64.encodeBase64(data);
2328             payloadWrapper.setInnerElement(data);
2329         }
2330         else {
2331             StorageOperationStatus storageStatus = DaoStatusConverter.convertCassandraStatusToStorageStatus(eitherArtifactData
2332                     .right()
2333                     .value());
2334             ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus));
2335             result = Either.right(responseFormat);
2336         }
2337         return result;
2338
2339     }
2340
2341     @SuppressWarnings("unchecked")
2342     private void validateEnvVsHeat(Wrapper<ResponseFormat> errorWrapper, ArtifactDefinition envArtifact, ArtifactDefinition heatArtifact, byte[] heatPayloadData) {
2343         String envPayload = new String(Base64.decodeBase64(envArtifact.getPayloadData()));
2344         Map<String, Object> heatEnvToscaJson = (Map<String, Object>) new Yaml().load(envPayload);
2345         String heatDecodedPayload = new String(Base64.decodeBase64(heatPayloadData));
2346         Map<String, Object> heatToscaJson = (Map<String, Object>) new Yaml().load(heatDecodedPayload);
2347
2348         Either<Map<String, Object>, ResultStatusEnum> eitherHeatEnvProperties = ImportUtils.findFirstToscaMapElement(heatEnvToscaJson, TypeUtils.ToscaTagNamesEnum.PARAMETERS);
2349         Either<Map<String, Object>, ResultStatusEnum> eitherHeatProperties = ImportUtils.findFirstToscaMapElement(heatToscaJson, TypeUtils.ToscaTagNamesEnum.PARAMETERS);
2350         if (eitherHeatEnvProperties.isRight()) {
2351             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2352                                                                  .getResponseFormat(ActionStatus.CORRUPTED_FORMAT, "Heat Env");
2353             errorWrapper.setInnerElement(responseFormat);
2354             log.debug("Invalid heat env format for file:{}", envArtifact.getArtifactName());
2355         }
2356         else if (eitherHeatProperties.isRight()) {
2357             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2358                                                                  .getResponseFormat(ActionStatus.MISMATCH_HEAT_VS_HEAT_ENV, envArtifact
2359                                                                          .getArtifactName(), heatArtifact.getArtifactName());
2360             errorWrapper.setInnerElement(responseFormat);
2361             log.debug("Validation of heat_env for artifact:{} vs heat artifact for artifact :{} failed", envArtifact.getArtifactName(), heatArtifact
2362                     .getArtifactName());
2363         }
2364         else {
2365             Set<String> heatPropertiesKeys = eitherHeatProperties.left().value().keySet();
2366             Set<String> heatEnvPropertiesKeys = eitherHeatEnvProperties.left().value().keySet();
2367             heatEnvPropertiesKeys.removeAll(heatPropertiesKeys);
2368             if (!heatEnvPropertiesKeys.isEmpty()) {
2369                 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2370                                                                      .getResponseFormat(ActionStatus.MISMATCH_HEAT_VS_HEAT_ENV, envArtifact
2371                                                                              .getArtifactName(), heatArtifact.getArtifactName());
2372                 errorWrapper.setInnerElement(responseFormat);
2373             }
2374         }
2375     }
2376
2377     private void validateValidYaml(Wrapper<ResponseFormat> errorWrapper, ArtifactDefinition artifactInfo) {
2378         YamlToObjectConverter yamlConvertor = new YamlToObjectConverter();
2379         boolean isYamlValid = yamlConvertor.isValidYamlEncoded64(artifactInfo.getPayloadData());
2380         if (!isYamlValid) {
2381             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2382                                                                  .getResponseFormat(ActionStatus.INVALID_YAML, artifactInfo
2383                                                                          .getArtifactType());
2384             errorWrapper.setInnerElement(responseFormat);
2385             log.debug("Yaml is not valid for artifact : {}", artifactInfo.getArtifactName());
2386         }
2387     }
2388
2389     private boolean isValidXml(byte[] xmlToParse) {
2390         boolean isXmlValid = true;
2391         try {
2392             XMLReader reader = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
2393             setFeatures(reader);
2394             reader.parse(new InputSource(new ByteArrayInputStream(xmlToParse)));
2395         }
2396         catch (ParserConfigurationException | IOException | SAXException e) {
2397             log.debug("Xml is invalid : {}", e.getMessage(), e);
2398             isXmlValid = false;
2399         }
2400         return isXmlValid;
2401     }
2402
2403     private void setFeatures(XMLReader reader) throws SAXNotSupportedException {
2404         try {
2405             reader.setFeature("http://apache.org/xml/features/validation/schema", false);
2406             reader.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
2407         }
2408         catch (SAXNotRecognizedException e) {
2409             log.debug("Xml parser couldn't set feature: \"http://apache.org/xml/features/validation/schema\", false", e.getMessage(), e);
2410         }
2411     }
2412
2413     private boolean isValidJson(byte[] jsonToParse) {
2414         String parsed = new String(jsonToParse);
2415         try {
2416             gson.fromJson(parsed, Object.class);
2417         }
2418         catch (Exception e) {
2419             log.debug("Json is invalid : {}", e.getMessage(), e);
2420             return false;
2421         }
2422         return true;
2423     }
2424
2425     private void validateSingleDeploymentArtifactName(Wrapper<ResponseFormat> errorWrapper, String artifactName, Component parentComponent, NodeTypeEnum parentType) {
2426         boolean artifactNameFound = false;
2427         Iterator<ArtifactDefinition> parentDeploymentArtifactsItr = getDeploymentArtifacts(parentComponent, parentType, null)
2428                 .iterator();
2429
2430         while (!artifactNameFound && parentDeploymentArtifactsItr.hasNext()) {
2431             artifactNameFound = artifactName.equalsIgnoreCase(parentDeploymentArtifactsItr.next().getArtifactName());
2432         }
2433         if (artifactNameFound) {
2434             String parentName = parentComponent.getName();
2435             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2436                                                                  .getResponseFormat(ActionStatus.DEPLOYMENT_ARTIFACT_NAME_ALREADY_EXISTS, parentType
2437                                                                          .name(), parentName, artifactName);
2438
2439             errorWrapper.setInnerElement(responseFormat);
2440             log.debug("Can't upload artifact: {}, because another artifact with this name already exist.", artifactName);
2441
2442         }
2443     }
2444
2445     private void validateHeatExist(String componentId, String parentRiId, Wrapper<ResponseFormat> errorWrapper, Wrapper<ArtifactDefinition> heatArtifactMDWrapper, ArtifactDefinition heatEnvArtifact, NodeTypeEnum parentType,
2446                                    ComponentTypeEnum componentType) {
2447         Either<ArtifactDefinition, StorageOperationStatus> res = artifactToscaOperation.getHeatArtifactByHeatEnvId(parentRiId, heatEnvArtifact, parentType, componentId, componentType);
2448         if (res.isRight()) {
2449             ResponseFormat responseFormat;
2450             if (res.right().value() == StorageOperationStatus.NOT_FOUND) {
2451                 responseFormat = ResponseFormatManager.getInstance().getResponseFormat(ActionStatus.MISSING_HEAT);
2452             }
2453             else {
2454                 responseFormat = ResponseFormatManager.getInstance().getResponseFormat(ActionStatus.MISSING_HEAT);
2455             }
2456             errorWrapper.setInnerElement(responseFormat);
2457             return;
2458         }
2459         ArtifactDefinition heatArtifact = res.left().value();
2460         heatArtifactMDWrapper.setInnerElement(heatArtifact);
2461     }
2462
2463     private Either<Boolean, ResponseFormat> validateHeatDeploymentArtifact(boolean isCreate, ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact) {
2464         log.trace("Started HEAT pre-payload validation for artifact {}", artifactInfo.getArtifactLabel());
2465         // timeout > 0 for HEAT artifacts
2466         Integer timeout = artifactInfo.getTimeout();
2467         if (timeout == null) {
2468             Integer defaultTimeout = isCreate ? NodeTemplateOperation.getDefaultHeatTimeout() : currentArtifact.getTimeout();
2469             artifactInfo.setTimeout(defaultTimeout);
2470             // HEAT artifact but timeout is invalid
2471         }
2472         else if (timeout < 1) {
2473             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_INVALID_TIMEOUT));
2474         }
2475
2476         // US649856 - Allow several HEAT files on Resource
2477         log.trace("Ended HEAT validation for artifact {}", artifactInfo.getArtifactLabel());
2478         return Either.left(true);
2479     }
2480
2481     private Either<Boolean, ResponseFormat> validateResourceType(ResourceTypeEnum resourceType, ArtifactDefinition artifactInfo, List<String> typeList) {
2482         String listToString = (typeList != null) ? typeList.toString() : "";
2483         ResponseFormat responseFormat = ResponseFormatManager.getInstance()
2484                                                              .getResponseFormat(ActionStatus.MISMATCH_BETWEEN_ARTIFACT_TYPE_AND_COMPONENT_TYPE, artifactInfo
2485                                                                      .getArtifactName(), listToString, resourceType.getValue());
2486         Either<Boolean, ResponseFormat> either = Either.right(responseFormat);
2487         String resourceTypeName = resourceType.name();
2488         if (typeList != null && typeList.contains(resourceTypeName)) {
2489             either = Either.left(true);
2490         }
2491         return either;
2492     }
2493
2494     private Either<ArtifactDefinition, ResponseFormat> validateAndConvertHeatParamers(ArtifactDefinition artifactInfo, String artifactType) {
2495         if (artifactInfo.getHeatParameters() != null) {
2496             for (HeatParameterDefinition heatParam : artifactInfo.getListHeatParameters()) {
2497                 String parameterType = heatParam.getType();
2498                 HeatParameterType heatParameterType = HeatParameterType.isValidType(parameterType);
2499                 String artifactTypeStr = artifactType != null ? artifactType : ArtifactTypeEnum.HEAT.getType();
2500                 if (heatParameterType == null) {
2501                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_HEAT_PARAMETER_TYPE, artifactTypeStr, heatParam
2502                             .getType());
2503                     return Either.right(responseFormat);
2504                 }
2505
2506                 StorageOperationStatus validateAndUpdateProperty = heatParametersOperation.validateAndUpdateProperty(heatParam);
2507                 if (validateAndUpdateProperty != StorageOperationStatus.OK) {
2508                     log.debug("Heat parameter {} is invalid. Status is {}", heatParam.getName(), validateAndUpdateProperty);
2509                     ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
2510                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(status, artifactTypeStr, heatParam
2511                             .getType(), heatParam.getName());
2512                     return Either.right(responseFormat);
2513                 }
2514             }
2515         }
2516         return Either.left(artifactInfo);
2517     }
2518
2519     public List<ArtifactDefinition> getDeploymentArtifacts(Component parentComponent, NodeTypeEnum parentType, String ciId) {
2520         List<ArtifactDefinition> deploymentArtifacts = new ArrayList<>();
2521         if (parentComponent.getDeploymentArtifacts() != null) {
2522             if (NodeTypeEnum.ResourceInstance == parentType && ciId != null) {
2523                 Either<ComponentInstance, ResponseFormat> getRI = getRIFromComponent(parentComponent, ciId, null, null, null);
2524                 if (getRI.isRight()) {
2525                     return deploymentArtifacts;
2526                 }
2527                 ComponentInstance ri = getRI.left().value();
2528                 if (ri.getDeploymentArtifacts() != null) {
2529                     deploymentArtifacts.addAll(ri.getDeploymentArtifacts().values());
2530                 }
2531             }
2532             else if (parentComponent.getDeploymentArtifacts() != null) {
2533                 deploymentArtifacts.addAll(parentComponent.getDeploymentArtifacts().values());
2534             }
2535         }
2536         return deploymentArtifacts;
2537     }
2538
2539     private void checkCreateFields(User user, ArtifactDefinition artifactInfo, ArtifactGroupTypeEnum type) {
2540         // on create if null add informational to current
2541         if (artifactInfo.getArtifactGroupType() == null) {
2542             artifactInfo.setArtifactGroupType(type);
2543         }
2544         if (artifactInfo.getUniqueId() != null) {
2545             log.error("artifact uniqid cannot be set ignoring");
2546         }
2547         artifactInfo.setUniqueId(null);
2548
2549         if (artifactInfo.getArtifactRef() != null) {
2550             log.error("artifact ref cannot be set ignoring");
2551         }
2552         artifactInfo.setArtifactRef(null);
2553
2554         if (artifactInfo.getArtifactRepository() != null) {
2555             log.error("artifact repository cannot be set ignoring");
2556         }
2557         artifactInfo.setArtifactRepository(null);
2558
2559         if (artifactInfo.getUserIdCreator() != null) {
2560             log.error("creator uuid cannot be set ignoring");
2561         }
2562         artifactInfo.setArtifactCreator(user.getUserId());
2563
2564         if (artifactInfo.getUserIdLastUpdater() != null) {
2565             log.error("userId of last updater cannot be set ignoring");
2566         }
2567         artifactInfo.setUserIdLastUpdater(user.getUserId());
2568
2569         if (artifactInfo.getCreatorFullName() != null) {
2570             log.error("creator Full name cannot be set ignoring");
2571         }
2572         String fullName = user.getFirstName() + " " + user.getLastName();
2573         artifactInfo.setUpdaterFullName(fullName);
2574
2575         if (artifactInfo.getUpdaterFullName() != null) {
2576             log.error("updater Full name cannot be set ignoring");
2577         }
2578         artifactInfo.setUpdaterFullName(fullName);
2579
2580         if (artifactInfo.getCreationDate() != null) {
2581             log.error("Creation Date cannot be set ignoring");
2582         }
2583         long time = System.currentTimeMillis();
2584         artifactInfo.setCreationDate(time);
2585
2586         if (artifactInfo.getLastUpdateDate() != null) {
2587             log.error("Last Update Date cannot be set ignoring");
2588         }
2589         artifactInfo.setLastUpdateDate(time);
2590
2591         if (artifactInfo.getEsId() != null) {
2592             log.error("es id cannot be set ignoring");
2593         }
2594         artifactInfo.setEsId(null);
2595
2596     }
2597
2598
2599     private String composeArtifactId(String resourceId, String artifactId, ArtifactDefinition artifactInfo, String interfaceName, String operationName) {
2600         String id = artifactId;
2601         if (artifactId == null || artifactId.isEmpty()) {
2602             String uniqueId = null;
2603             if (interfaceName != null && operationName != null) {
2604                 uniqueId = UniqueIdBuilder.buildArtifactByInterfaceUniqueId(resourceId, interfaceName, operationName, artifactInfo
2605                         .getArtifactLabel());
2606             }
2607             else {
2608                 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId, artifactInfo.getArtifactLabel());
2609             }
2610             artifactInfo.setUniqueId(uniqueId);
2611             artifactInfo.setEsId(uniqueId);
2612             id = uniqueId;
2613         }
2614         else {
2615             artifactInfo.setUniqueId(artifactId);
2616             artifactInfo.setEsId(artifactId);
2617         }
2618         return id;
2619     }
2620
2621     private Either<ActionStatus, ResponseFormat> validateArtifactType(String userId, ArtifactDefinition artifactInfo, NodeTypeEnum parentType) {
2622         if (Strings.isNullOrEmpty(artifactInfo.getArtifactType())) {
2623             BeEcompErrorManager.getInstance()
2624                                .logBeMissingArtifactInformationError("Artifact Update / Upload", "artifactLabel");
2625             log.debug("Missing artifact type for artifact {}", artifactInfo.getArtifactName());
2626             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_ARTIFACT_TYPE));
2627         }
2628
2629         boolean artifactTypeExist = false;
2630         Either<List<ArtifactType>, ActionStatus> allArtifactTypes = null;
2631         ArtifactGroupTypeEnum artifactGroupType = artifactInfo.getArtifactGroupType();
2632
2633         if ((artifactGroupType != null) && artifactGroupType.equals(ArtifactGroupTypeEnum.DEPLOYMENT)) {
2634             allArtifactTypes = getDeploymentArtifactTypes(parentType);
2635         }
2636         else {
2637
2638             allArtifactTypes = elementOperation.getAllArtifactTypes();
2639         }
2640         if (allArtifactTypes.isRight()) {
2641             BeEcompErrorManager.getInstance()
2642                                .logBeInvalidConfigurationError("Artifact Upload / Update", "artifactTypes", allArtifactTypes
2643                                        .right()
2644                                        .value()
2645                                        .name());
2646             log.debug("Failed to retrieve list of suported artifact types. error: {}", allArtifactTypes.right()
2647                                                                                                        .value());
2648             return Either.right(componentsUtils.getResponseFormatByUserId(allArtifactTypes.right().value(), userId));
2649         }
2650
2651         for (ArtifactType type : allArtifactTypes.left().value()) {
2652             if (type.getName().equalsIgnoreCase(artifactInfo.getArtifactType())) {
2653                 artifactInfo.setArtifactType(artifactInfo.getArtifactType().toUpperCase());
2654                 artifactTypeExist = true;
2655                 break;
2656             }
2657         }
2658
2659         if (!artifactTypeExist) {
2660             BeEcompErrorManager.getInstance()
2661                                .logBeInvalidTypeError("Artifact Upload / Delete / Update - Not supported artifact type", artifactInfo
2662                                        .getArtifactType(), "Artifact " + artifactInfo.getArtifactName());
2663             log.debug("Not supported artifact type = {}", artifactInfo.getArtifactType());
2664             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, artifactInfo
2665                     .getArtifactType()));
2666         }
2667
2668         return Either.left(ActionStatus.OK);
2669     }
2670
2671     private Either<List<ArtifactType>, ActionStatus> getDeploymentArtifactTypes(NodeTypeEnum parentType) {
2672
2673         Map<String, ArtifactTypeConfig> deploymentArtifacts ;
2674         List<ArtifactType> artifactTypes = new ArrayList<>();
2675
2676         if (parentType.equals(NodeTypeEnum.Service)) {
2677             deploymentArtifacts = ConfigurationManager.getConfigurationManager()
2678                                                       .getConfiguration()
2679                                                       .getServiceDeploymentArtifacts();
2680         }
2681         else if (parentType.equals(NodeTypeEnum.ResourceInstance)) {
2682             deploymentArtifacts = ConfigurationManager.getConfigurationManager()
2683                                                       .getConfiguration()
2684                                                       .getResourceInstanceDeploymentArtifacts();
2685         }
2686         else {
2687             deploymentArtifacts = ConfigurationManager.getConfigurationManager()
2688                                                       .getConfiguration()
2689                                                       .getResourceDeploymentArtifacts();
2690         }
2691         if (deploymentArtifacts != null) {
2692             for (String artifactType : deploymentArtifacts.keySet()) {
2693                 ArtifactType artifactT = new ArtifactType();
2694                 artifactT.setName(artifactType);
2695                 artifactTypes.add(artifactT);
2696             }
2697             return Either.left(artifactTypes);
2698         }
2699         else {
2700             return Either.right(ActionStatus.GENERAL_ERROR);
2701         }
2702
2703     }
2704
2705     private Either<Boolean, ResponseFormat> validateFirstUpdateHasPayload(ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact) {
2706         if (currentArtifact.getEsId() == null && (artifactInfo.getPayloadData() == null || artifactInfo.getPayloadData().length == 0)) {
2707             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD));
2708         }
2709         return Either.left(true);
2710
2711     }
2712
2713     private Either<Boolean, ResponseFormat> validateAndSetArtifactname(ArtifactDefinition artifactInfo) {
2714         if (artifactInfo.getArtifactName() == null || artifactInfo.getArtifactName().isEmpty()) {
2715             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_ARTIFACT_NAME));
2716         }
2717
2718         String normalizeFileName = ValidationUtils.normalizeFileName(artifactInfo.getArtifactName());
2719         if (normalizeFileName == null || normalizeFileName.isEmpty()) {
2720             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_ARTIFACT_NAME));
2721         }
2722         artifactInfo.setArtifactName(normalizeFileName);
2723
2724         if (!ValidationUtils.validateArtifactNameLength(artifactInfo.getArtifactName())) {
2725             return Either.right(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, ARTIFACT_NAME, String.valueOf(ValidationUtils.ARTIFACT_NAME_LENGTH)));
2726         }
2727
2728         return Either.left(true);
2729     }
2730
2731     private Either<Boolean, ResponseFormat> validateArtifactTypeNotChanged(ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact) {
2732         if (artifactInfo.getArtifactType() == null || artifactInfo.getArtifactType().isEmpty()) {
2733             log.info("artifact type is missing operation ignored");
2734             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_ARTIFACT_TYPE));
2735         }
2736
2737         if (!currentArtifact.getArtifactType().equalsIgnoreCase(artifactInfo.getArtifactType())) {
2738             log.info("artifact type cannot be changed operation ignored");
2739             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2740         }
2741         return Either.left(true);
2742     }
2743
2744     private Either<ArtifactDefinition, ResponseFormat> validateOrSetArtifactGroupType(ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact) {
2745         if (artifactInfo.getArtifactGroupType() == null) {
2746             artifactInfo.setArtifactGroupType(currentArtifact.getArtifactGroupType());
2747         }
2748
2749         else if (!currentArtifact.getArtifactGroupType()
2750                                  .getType()
2751                                  .equalsIgnoreCase(artifactInfo.getArtifactGroupType().getType())) {
2752             log.info("artifact group type cannot be changed. operation failed");
2753             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2754         }
2755         return Either.left(artifactInfo);
2756     }
2757
2758     private void checkAndSetUnUpdatableFields(User user, ArtifactDefinition artifactInfo, ArtifactDefinition currentArtifact, ArtifactGroupTypeEnum type) {
2759
2760         // on update if null add informational to current
2761         if (currentArtifact.getArtifactGroupType() == null && type != null) {
2762             currentArtifact.setArtifactGroupType(type);
2763         }
2764
2765         if (artifactInfo.getUniqueId() != null && !currentArtifact.getUniqueId().equals(artifactInfo.getUniqueId())) {
2766             log.error("artifact uniqid cannot be set ignoring");
2767         }
2768         artifactInfo.setUniqueId(currentArtifact.getUniqueId());
2769
2770         if (artifactInfo.getArtifactRef() != null && !currentArtifact.getArtifactRef()
2771                                                                      .equals(artifactInfo.getArtifactRef())) {
2772             log.error("artifact ref cannot be set ignoring");
2773         }
2774         artifactInfo.setArtifactRef(currentArtifact.getArtifactRef());
2775
2776         if (artifactInfo.getArtifactRepository() != null && !currentArtifact.getArtifactRepository()
2777                                                                             .equals(artifactInfo.getArtifactRepository())) {
2778             log.error("artifact repository cannot be set ignoring");
2779         }
2780         artifactInfo.setArtifactRepository(currentArtifact.getArtifactRepository());
2781
2782         if (artifactInfo.getUserIdCreator() != null && !currentArtifact.getUserIdCreator()
2783                                                                        .equals(artifactInfo.getUserIdCreator())) {
2784             log.error("creator uuid cannot be set ignoring");
2785         }
2786         artifactInfo.setUserIdCreator(currentArtifact.getUserIdCreator());
2787
2788         if (artifactInfo.getArtifactCreator() != null && !currentArtifact.getArtifactCreator()
2789                                                                          .equals(artifactInfo.getArtifactCreator())) {
2790             log.error("artifact creator cannot be set ignoring");
2791         }
2792         artifactInfo.setArtifactCreator(currentArtifact.getArtifactCreator());
2793
2794         if (artifactInfo.getUserIdLastUpdater() != null && !currentArtifact.getUserIdLastUpdater()
2795                                                                            .equals(artifactInfo.getUserIdLastUpdater())) {
2796             log.error("userId of last updater cannot be set ignoring");
2797         }
2798         artifactInfo.setUserIdLastUpdater(user.getUserId());
2799
2800         if (artifactInfo.getCreatorFullName() != null && !currentArtifact.getCreatorFullName()
2801                                                                          .equals(artifactInfo.getCreatorFullName())) {
2802             log.error("creator Full name cannot be set ignoring");
2803         }
2804         artifactInfo.setCreatorFullName(currentArtifact.getCreatorFullName());
2805
2806         if (artifactInfo.getUpdaterFullName() != null && !currentArtifact.getUpdaterFullName()
2807                                                                          .equals(artifactInfo.getUpdaterFullName())) {
2808             log.error("updater Full name cannot be set ignoring");
2809         }
2810         String fullName = user.getFirstName() + " " + user.getLastName();
2811         artifactInfo.setUpdaterFullName(fullName);
2812
2813         if (artifactInfo.getCreationDate() != null && !currentArtifact.getCreationDate()
2814                                                                       .equals(artifactInfo.getCreationDate())) {
2815             log.error("Creation Date cannot be set ignoring");
2816         }
2817         artifactInfo.setCreationDate(currentArtifact.getCreationDate());
2818
2819         if (artifactInfo.getLastUpdateDate() != null && !currentArtifact.getLastUpdateDate()
2820                                                                         .equals(artifactInfo.getLastUpdateDate())) {
2821             log.error("Last Update Date cannot be set ignoring");
2822         }
2823         long time = System.currentTimeMillis();
2824         artifactInfo.setLastUpdateDate(time);
2825
2826         if (artifactInfo.getEsId() != null && !currentArtifact.getEsId().equals(artifactInfo.getEsId())) {
2827             log.error("es id cannot be set ignoring");
2828         }
2829         artifactInfo.setEsId(currentArtifact.getUniqueId());
2830
2831         if (artifactInfo.getArtifactDisplayName() != null && !currentArtifact.getArtifactDisplayName()
2832                                                                              .equals(artifactInfo.getArtifactDisplayName())) {
2833             log.error(" Artifact Display Name cannot be set ignoring");
2834         }
2835         artifactInfo.setArtifactDisplayName(currentArtifact.getArtifactDisplayName());
2836
2837         if (artifactInfo.getServiceApi() != null && !currentArtifact.getServiceApi()
2838                                                                     .equals(artifactInfo.getServiceApi())) {
2839             log.debug("serviceApi cannot be set. ignoring.");
2840         }
2841         artifactInfo.setServiceApi(currentArtifact.getServiceApi());
2842
2843         if (artifactInfo.getArtifactGroupType() != null && !currentArtifact.getArtifactGroupType()
2844                                                                            .equals(artifactInfo.getArtifactGroupType())) {
2845             log.debug("artifact group cannot be set. ignoring.");
2846         }
2847         artifactInfo.setArtifactGroupType(currentArtifact.getArtifactGroupType());
2848
2849         artifactInfo.setArtifactVersion(currentArtifact.getArtifactVersion());
2850
2851         if (artifactInfo.getArtifactUUID() != null && !artifactInfo.getArtifactUUID()
2852                                                                    .isEmpty() && !currentArtifact.getArtifactUUID()
2853                                                                                                  .equals(artifactInfo.getArtifactUUID())) {
2854             log.debug("artifact UUID cannot be set. ignoring.");
2855         }
2856         artifactInfo.setArtifactUUID(currentArtifact.getArtifactUUID());
2857
2858         if ((artifactInfo.getHeatParameters() != null) && (currentArtifact.getHeatParameters() != null) && !artifactInfo
2859                 .getHeatParameters()
2860                 .isEmpty() && !currentArtifact.getHeatParameters().isEmpty()) {
2861             checkAndSetUnupdatableHeatParams(artifactInfo.getListHeatParameters(), currentArtifact.getListHeatParameters());
2862         }
2863     }
2864
2865     private void checkAndSetUnupdatableHeatParams(List<HeatParameterDefinition> heatParameters, List<HeatParameterDefinition> currentParameters) {
2866
2867         Map<String, HeatParameterDefinition> currentParametersMap = getMapOfParameters(currentParameters);
2868         for (HeatParameterDefinition parameter : heatParameters) {
2869             HeatParameterDefinition currentParam = currentParametersMap.get(parameter.getUniqueId());
2870
2871             if (currentParam != null) {
2872
2873                 if (parameter.getName() != null && !parameter.getName().equalsIgnoreCase(currentParam.getName())) {
2874                     log.debug("heat parameter name cannot be updated  ({}). ignoring.", parameter.getName());
2875                     parameter.setName(currentParam.getName());
2876                 }
2877                 if (parameter.getDefaultValue() != null && !parameter.getDefaultValue()
2878                                                                      .equalsIgnoreCase(currentParam.getDefaultValue())) {
2879                     log.debug("heat parameter defaultValue cannot be updated  ({}). ignoring.", parameter.getDefaultValue());
2880                     parameter.setDefaultValue(currentParam.getDefaultValue());
2881                 }
2882                 if (parameter.getType() != null && !parameter.getType().equalsIgnoreCase(currentParam.getType())) {
2883                     log.debug("heat parameter type cannot be updated  ({}). ignoring.", parameter.getType());
2884                     parameter.setType(currentParam.getType());
2885                 }
2886                 if (parameter.getDescription() != null && !parameter.getDescription()
2887                                                                     .equalsIgnoreCase(currentParam.getDescription())) {
2888                     log.debug("heat parameter description cannot be updated  ({}). ignoring.", parameter.getDescription());
2889                     parameter.setDescription(currentParam.getDescription());
2890                 }
2891
2892                 // check and set current value
2893                 if ((parameter.getCurrentValue() == null) && (currentParam.getDefaultValue() != null)) {
2894                     log.debug("heat parameter current value is null. set it to default value {}). ignoring.", parameter.getDefaultValue());
2895                     parameter.setCurrentValue(currentParam.getDefaultValue());
2896                 }
2897             }
2898         }
2899     }
2900
2901     private Map<String, HeatParameterDefinition> getMapOfParameters(List<HeatParameterDefinition> currentParameters) {
2902
2903         Map<String, HeatParameterDefinition> currentParamsMap = new HashMap<String, HeatParameterDefinition>();
2904         for (HeatParameterDefinition param : currentParameters) {
2905             currentParamsMap.put(param.getUniqueId(), param);
2906         }
2907         return currentParamsMap;
2908     }
2909
2910     private Either<Boolean, ResponseFormat> validateAndServiceApiUrl(ArtifactDefinition artifactInfo) {
2911         if (!ValidationUtils.validateStringNotEmpty(artifactInfo.getApiUrl())) {
2912             log.debug("Artifact url cannot be empty.");
2913             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_URL));
2914         }
2915         artifactInfo.setApiUrl(artifactInfo.getApiUrl().toLowerCase());
2916
2917         if (!ValidationUtils.validateUrl(artifactInfo.getApiUrl())) {
2918             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_SERVICE_API_URL));
2919         }
2920         if (!ValidationUtils.validateUrlLength(artifactInfo.getApiUrl())) {
2921             return Either.right(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, ARTIFACT_URL, String.valueOf(ValidationUtils.API_URL_LENGTH)));
2922         }
2923
2924         return Either.left(true);
2925     }
2926
2927     private Either<Boolean, ResponseFormat> validateAndCleanDescription(ArtifactDefinition artifactInfo) {
2928         if (artifactInfo.getDescription() == null || artifactInfo.getDescription().isEmpty()) {
2929             log.debug("Artifact description cannot be empty.");
2930             return Either.right(componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_DESCRIPTION));
2931         }
2932         String description = artifactInfo.getDescription();
2933         description = ValidationUtils.removeNoneUtf8Chars(description);
2934         description = ValidationUtils.normaliseWhitespace(description);
2935         description = ValidationUtils.stripOctets(description);
2936         description = ValidationUtils.removeHtmlTagsOnly(description);
2937         if (!ValidationUtils.validateIsEnglish(description)) {
2938             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2939         }
2940         if (!ValidationUtils.validateLength(description, ValidationUtils.ARTIFACT_DESCRIPTION_MAX_LENGTH)) {
2941             return Either.right(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, ARTIFACT_DESCRIPTION, String
2942                     .valueOf(ValidationUtils.ARTIFACT_DESCRIPTION_MAX_LENGTH)));
2943         }
2944         artifactInfo.setDescription(description);
2945         return Either.left(true);
2946     }
2947
2948     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateArtifactFlow(org.openecomp.sdc.be.model.Component parent, String parentId, String artifactId, ArtifactDefinition artifactInfo, User user, byte[] decodedPayload,
2949                                                                                              ComponentTypeEnum componentType, AuditingActionEnum auditingAction, String interfaceType, String operationUuid) {
2950         ESArtifactData artifactData = createEsArtifactData(artifactInfo, decodedPayload);
2951         String prevArtifactId = null;
2952         String currArtifactId = artifactId;
2953
2954         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
2955         Either<ArtifactDefinition, Operation> insideEither = null;
2956
2957         log.trace("Try to update entry on graph");
2958         String artifactUniqueId = null;
2959         ArtifactDefinition artifactDefinition = artifactInfo;
2960         StorageOperationStatus error;
2961
2962         boolean isLeft;
2963         if (interfaceType == null || operationUuid == null) {
2964             log.debug("Entity on graph is updated. Update artifact in ES");
2965             boolean res = true;
2966             // Changing previous and current artifactId for auditing
2967             prevArtifactId = currArtifactId;
2968             currArtifactId = artifactDefinition.getUniqueId();
2969
2970
2971             if (decodedPayload == null) {
2972                 if (!artifactDefinition.getMandatory() || artifactDefinition.getEsId() != null) {
2973                     Either<ESArtifactData, CassandraOperationStatus> artifactFromCassandra = artifactCassandraDao.getArtifact(artifactDefinition
2974                             .getEsId());
2975                     if (artifactFromCassandra.isRight()) {
2976                         log.debug("Failed to get artifact data from ES for artifact id  {}", artifactId);
2977                         error = DaoStatusConverter.convertCassandraStatusToStorageStatus(artifactFromCassandra.right()
2978                                 .value());
2979                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
2980                         handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId, currArtifactId, responseFormat, componentType, null);
2981                         resultOp = Either.right(responseFormat);
2982                         return resultOp;
2983                     }
2984                     // clone data to new artifact
2985                     artifactData.setData(artifactFromCassandra.left().value().getData());
2986                     artifactData.setId(artifactFromCassandra.left().value().getId());
2987                 }
2988             } else {
2989                 if (artifactDefinition.getEsId() == null) {
2990                     artifactDefinition.setEsId(artifactDefinition.getUniqueId());
2991                     artifactData.setId(artifactDefinition.getUniqueId());
2992                 }
2993             }
2994
2995             NodeTypeEnum convertParentType = convertParentType(componentType);
2996             Either<ArtifactDefinition, StorageOperationStatus> result = artifactToscaOperation.updateArtifactOnResource(artifactInfo, parent
2997                     .getUniqueId(), artifactId, convertParentType, parentId);
2998             isLeft = result.isLeft();
2999             if (isLeft) {
3000                 artifactUniqueId = result.left().value().getUniqueId();
3001                 artifactDefinition = result.left().value();
3002                 String artifactType = artifactInfo.getArtifactType();
3003                 if (NodeTypeEnum.Resource == convertParentType
3004                         && (ArtifactTypeEnum.HEAT.getType().equalsIgnoreCase(artifactType)
3005                         || ArtifactTypeEnum.HEAT_VOL.getType().equalsIgnoreCase(artifactType)
3006                         || ArtifactTypeEnum.HEAT_NET.getType().equalsIgnoreCase(artifactType))
3007                         && !artifactUniqueId.equals(artifactId)) {
3008                     // need to update the generated id in heat env
3009                     Map<String, ArtifactDefinition> deploymentArtifacts = parent.getDeploymentArtifacts();
3010                     Optional<Entry<String, ArtifactDefinition>> findFirst = deploymentArtifacts.entrySet()
3011                             .stream()
3012                             .filter(a -> a.getValue()
3013                                     .getGeneratedFromId() != null && a
3014                                     .getValue()
3015                                     .getGeneratedFromId()
3016                                     .equals(artifactId))
3017                             .findFirst();
3018                     if (findFirst.isPresent()) {
3019                         ArtifactDefinition artifactEnvInfo = findFirst.get().getValue();
3020                         artifactEnvInfo.setArtifactChecksum(null);
3021                         artifactToscaOperation.updateHeatEnvArtifact(parent.getUniqueId(), artifactEnvInfo, artifactId, artifactUniqueId, convertParentType, parentId);
3022                     }
3023                 }
3024                 error = generateCustomizationUUIDOnInstance(parent.getUniqueId(), parentId, componentType);
3025
3026                 insideEither = Either.left(result.left().value());
3027                 resultOp = Either.left(insideEither);
3028                 if (error != StorageOperationStatus.OK) {
3029                     isLeft = false;
3030                 }
3031
3032             } else {
3033                 error = result.right().value();
3034             }
3035             if (isLeft) {
3036
3037                 // create new entry in ES
3038                 res = true;
3039                 if (artifactData.getData() != null) {
3040                     if (!artifactDefinition.getDuplicated() || artifactData.getId() == null) {
3041                         artifactData.setId(artifactDefinition.getEsId());
3042                     }
3043                     res = saveArtifacts(artifactData, parentId);
3044
3045                 }
3046             }
3047
3048             if (res) {
3049                 log.debug(ARTIFACT_SAVED, artifactUniqueId);
3050                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
3051                 handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId, currArtifactId, responseFormat, componentType, null);
3052             } else {
3053                 BeEcompErrorManager.getInstance().logBeDaoSystemError(UPDATE_ARTIFACT);
3054                 log.debug(FAILED_SAVE_ARTIFACT);
3055                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
3056                 handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId, currArtifactId, responseFormat, componentType, null);
3057                 resultOp = Either.right(responseFormat);
3058             }
3059         } else {
3060             return updateArtifactsFlowForInterfaceOperations(parent, parentId, artifactId, artifactInfo, user,
3061                     decodedPayload, componentType, auditingAction, operationUuid, artifactData, prevArtifactId,
3062                     currArtifactId, artifactDefinition);
3063         }
3064
3065         return resultOp;
3066     }
3067
3068     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateArtifactsFlowForInterfaceOperations(
3069             Component parent, String parentId, String artifactId, ArtifactDefinition artifactInfo, User user,
3070             byte[] decodedPayload, ComponentTypeEnum componentType, AuditingActionEnum auditingAction,
3071             String operationUuid, ESArtifactData artifactData, String prevArtifactId, String currArtifactId,
3072             ArtifactDefinition artifactDefinition) {
3073         StorageOperationStatus error;
3074         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp;
3075         if (decodedPayload == null) {
3076             if (!artifactDefinition.getMandatory() || artifactDefinition.getEsId() != null) {
3077                 Either<ESArtifactData, CassandraOperationStatus> artifactFromCassandra = artifactCassandraDao.getArtifact(artifactDefinition
3078                         .getEsId());
3079                 if (artifactFromCassandra.isRight()) {
3080                     log.debug("Failed to get artifact data from ES for artifact id  {}", artifactId);
3081                     error = DaoStatusConverter.convertCassandraStatusToStorageStatus(artifactFromCassandra.right()
3082                             .value());
3083                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
3084                     handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId, currArtifactId, responseFormat, componentType, null);
3085                     resultOp = Either.right(responseFormat);
3086                     return resultOp;
3087                 }
3088                 // clone data to new artifact
3089                 artifactData.setData(artifactFromCassandra.left().value().getData());
3090                 artifactData.setId(artifactFromCassandra.left().value().getId());
3091             } else {
3092                 // todo if not exist(first time)
3093             }
3094
3095         } else {
3096             if (artifactDefinition.getEsId() == null) {
3097                 artifactDefinition.setEsId(artifactDefinition.getUniqueId());
3098                 artifactData.setId(artifactDefinition.getUniqueId());
3099             }
3100         }
3101         NodeTypeEnum convertParentType = convertParentType(componentType);
3102         // fetch the resource from storage
3103         Either<Component, StorageOperationStatus> componentStorageOperationStatusEither =
3104                 toscaOperationFacade.getToscaElement(parentId);
3105         if (componentStorageOperationStatusEither.isRight()) {
3106             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
3107             log.debug("Failed to fetch resource information by resource id, error {}", errorStatus);
3108             return Either.right(componentsUtils
3109                     .getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
3110         }
3111         Component storedComponent = componentStorageOperationStatusEither.left().value();
3112
3113         String interfaceToscaName = InterfaceUtils.createInterfaceToscaResourceName(
3114                 storedComponent.getName());
3115         //fetch the interface from storage
3116         Optional<InterfaceDefinition> interfaceDefinition =
3117                 storedComponent.getInterfaces().values().stream()
3118                         .filter(interfaceDef -> interfaceDef.getToscaResourceName()
3119                         .equals(interfaceToscaName)).findFirst();
3120         if (!interfaceDefinition.isPresent()) {
3121             log.debug("Failed to get resource interface for resource Id {}", parentId);
3122             ResponseFormat responseFormat = componentsUtils.getResponseFormat(
3123                     ActionStatus.INTERFACE_OPERATION_NOT_FOUND, parentId);
3124             handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId,
3125                     currArtifactId, responseFormat, componentType, null);
3126             return Either.right(responseFormat);
3127         }
3128
3129         //fetch the operation from storage
3130         InterfaceDefinition gotInterface = interfaceDefinition.get();
3131         Map<String, Operation> operationsMap = gotInterface.getOperationsMap();
3132         Optional<Operation> optionalOperation = operationsMap.values()
3133                 .stream()
3134                 .filter(o -> o.getUniqueId().equals(operationUuid))
3135                 .findFirst();
3136         if (!optionalOperation.isPresent()) {
3137             log.debug("Failed to get resource interface operation for resource Id {} " +
3138                     " and operationId {}", parentId, operationUuid);
3139             ResponseFormat responseFormat = componentsUtils.getResponseFormat(
3140                     ActionStatus.INTERFACE_OPERATION_NOT_FOUND, parentId);
3141             handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId,
3142                     currArtifactId, responseFormat, componentType, null);
3143             return Either.right(responseFormat);
3144         }
3145
3146         Operation operation = optionalOperation.get();
3147         ArtifactDefinition implementationArtifact =  operation.getImplementationArtifact();
3148         implementationArtifact.setArtifactName(artifactInfo.getArtifactName());
3149         implementationArtifact.setDescription(artifactInfo.getDescription());
3150         implementationArtifact.setArtifactType(artifactInfo.getArtifactType());
3151         implementationArtifact.setArtifactLabel(artifactInfo.getUniqueId());
3152         implementationArtifact.setEsId(artifactInfo.getEsId());
3153         operation.setImplementation(implementationArtifact);
3154         gotInterface.setOperationsMap(operationsMap);
3155         Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
3156                 interfaceOperation.updateInterface(storedComponent.getUniqueId(), gotInterface);
3157         if (interfaceDefinitionStorageOperationStatusEither.isRight()){
3158             StorageOperationStatus storageOperationStatus = interfaceDefinitionStorageOperationStatusEither.right().value();
3159             ActionStatus actionStatus =
3160                     componentsUtils.convertFromStorageResponseForDataType(storageOperationStatus);
3161             return Either.right(componentsUtils.getResponseFormat(actionStatus));
3162         }
3163
3164         String uniqueId = implementationArtifact.getUniqueId();
3165         artifactData.setId(uniqueId);
3166         CassandraOperationStatus cassandraOperationStatus = artifactCassandraDao.saveArtifact(artifactData);
3167         if(cassandraOperationStatus != CassandraOperationStatus.OK){
3168             log.debug("Failed to persist operation {} artifact, error is {}",operation.getName(),cassandraOperationStatus);
3169             StorageOperationStatus storageStatus = DaoStatusConverter.convertCassandraStatusToStorageStatus(cassandraOperationStatus);
3170             ActionStatus convertedFromStorageResponse = componentsUtils.convertFromStorageResponse(storageStatus);
3171             return Either.right(componentsUtils.getResponseFormat(convertedFromStorageResponse));
3172         }
3173         return Either.left(Either.left(implementationArtifact));
3174     }
3175
3176     private Either<byte[], ResponseFormat> handlePayload(ArtifactDefinition artifactInfo, boolean isArtifactMetadataUpdate) {
3177         log.trace("Starting payload handling");
3178         byte[] payload = artifactInfo.getPayloadData();
3179         byte[] decodedPayload = null;
3180
3181         if (payload != null && payload.length != 0) {
3182             // the generated artifacts were already decoded by the handler
3183             decodedPayload = artifactInfo.getGenerated() ? payload : Base64.decodeBase64(payload);
3184             if (decodedPayload.length == 0) {
3185                 log.debug("Failed to decode the payload.");
3186                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
3187                 return Either.right(responseFormat);
3188             }
3189
3190             String checkSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(decodedPayload);
3191             artifactInfo.setArtifactChecksum(checkSum);
3192             log.trace("Calculated checksum, base64 payload: {},  checksum: {}", payload, checkSum);
3193
3194             // Specific payload validations of different types
3195             Either<Boolean, ResponseFormat> isValidPayload = Either.left(true);
3196             if (isDeploymentArtifact(artifactInfo)) {
3197                 log.trace("Starting deployment artifacts payload validation");
3198                 String artifactType = artifactInfo.getArtifactType();
3199                 if (ArtifactTypeEnum.HEAT.getType()
3200                                          .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.HEAT_VOL.getType()
3201                                                                                                      .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.HEAT_NET
3202                         .getType()
3203                         .equalsIgnoreCase(artifactType)
3204                         || ArtifactTypeEnum.HEAT_ENV.getType().equalsIgnoreCase(artifactType)) {
3205                     isValidPayload = validateDeploymentHeatPayload(decodedPayload, artifactType);
3206                     if (isValidPayload.isLeft()) {
3207                         isValidPayload = extractHeatParameters(artifactInfo);
3208                     }
3209                 }
3210                 else if (ArtifactTypeEnum.YANG_XML.getType()
3211                                                   .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.VNF_CATALOG.getType()
3212                                                                                                                  .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.VF_LICENSE
3213                         .getType()
3214                         .equalsIgnoreCase(artifactType)
3215                         || ArtifactTypeEnum.VENDOR_LICENSE.getType()
3216                                                           .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.MODEL_INVENTORY_PROFILE
3217                         .getType()
3218                         .equalsIgnoreCase(artifactType)
3219                         || ArtifactTypeEnum.MODEL_QUERY_SPEC.getType()
3220                                                             .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.UCPE_LAYER_2_CONFIGURATION
3221                         .getType()
3222                         .equalsIgnoreCase(artifactType)) {
3223                     isValidPayload = validateXmlPayload(decodedPayload, artifactType);
3224                 }
3225                 else if (ArtifactTypeEnum.DCAE_INVENTORY_JSON.getType()
3226                                                              .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.DCAE_INVENTORY_TOSCA
3227                         .getType()
3228                         .equalsIgnoreCase(artifactType)
3229                         || ArtifactTypeEnum.VES_EVENTS.getType()
3230                                                       .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.LIFECYCLE_OPERATIONS
3231                         .getType()
3232                         .equalsIgnoreCase(artifactType)) {
3233                     String artifactFileName = artifactInfo.getArtifactName();
3234                     String fileExtension = GeneralUtility.getFilenameExtension(artifactFileName).toLowerCase();
3235                     switch (fileExtension) {
3236                         case "xml":
3237                             isValidPayload = validateXmlPayload(decodedPayload, artifactType);
3238                             break;
3239                         case "json":
3240                             isValidPayload = validateJsonPayload(decodedPayload, artifactType);
3241                             break;
3242                         case "yml":
3243                         case "yaml":
3244                             isValidPayload = validateYmlPayload(decodedPayload, artifactType);
3245                             break;
3246                         default:
3247                             break;
3248                     }
3249                 }
3250             }
3251             if (isValidPayload.isRight()) {
3252                 ResponseFormat responseFormat = isValidPayload.right().value();
3253                 return Either.right(responseFormat);
3254             }
3255
3256         } // null/empty payload is normal if called from metadata update ONLY.
3257         // The validation of whether this is metadata/payload update case is
3258         // currently done separately
3259         else {
3260             if (!isArtifactMetadataUpdate) {
3261                 log.debug("In artifact: {} Payload is missing.",artifactInfo.getArtifactName());
3262                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD);
3263                 return Either.right(responseFormat);
3264             }
3265         }
3266         log.trace("Ended payload handling");
3267         return Either.left(decodedPayload);
3268     }
3269
3270     private Either<Boolean, ResponseFormat> validateDeploymentHeatPayload(byte[] decodedPayload, String artifactType) {
3271         // Basic YAML validation
3272         YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
3273         if (!yamlToObjectConverter.isValidYaml(decodedPayload)) {
3274             log.debug("Invalid YAML format");
3275             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, artifactType);
3276             return Either.right(responseFormat);
3277         }
3278         if (!ArtifactTypeEnum.HEAT_ENV.getType().equalsIgnoreCase(artifactType)) {
3279             // HEAT specific YAML validation
3280             DeploymentArtifactHeatConfiguration heatConfiguration = yamlToObjectConverter.convert(decodedPayload, DeploymentArtifactHeatConfiguration.class);
3281             if (heatConfiguration == null || heatConfiguration.getHeat_template_version() == null) {
3282                 log.debug("HEAT doesn't contain required \"heat_template_version\" section.");
3283                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, artifactType);
3284                 return Either.right(responseFormat);
3285             }
3286         }
3287
3288         return Either.left(true);
3289     }
3290
3291     private Either<Boolean, ResponseFormat> validateYmlPayload(byte[] decodedPayload, String artifactType) {
3292         Either<Boolean, ResponseFormat> res = Either.left(true);
3293         YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
3294         if (!yamlToObjectConverter.isValidYaml(decodedPayload)) {
3295             log.debug("Invalid YAML format");
3296             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, artifactType);
3297             res = Either.right(responseFormat);
3298         }
3299
3300         return res;
3301     }
3302
3303     private Either<Boolean, ResponseFormat> validateXmlPayload(byte[] payload, String artifactType) {
3304         boolean isXmlValid = isValidXml(payload);
3305         if (!isXmlValid) {
3306             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
3307                                                                  .getResponseFormat(ActionStatus.INVALID_XML, artifactType);
3308             log.debug("Invalid XML content");
3309             return Either.right(responseFormat);
3310         }
3311         return Either.left(true);
3312     }
3313
3314     private Either<Boolean, ResponseFormat> validateJsonPayload(byte[] payload, String type) {
3315         boolean isJsonValid = isValidJson(payload);
3316         if (!isJsonValid) {
3317             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
3318                                                                  .getResponseFormat(ActionStatus.INVALID_JSON, type);
3319             log.debug("Invalid JSON content");
3320             return Either.right(responseFormat);
3321         }
3322         return Either.left(true);
3323     }
3324
3325     public Either<Operation, ResponseFormat> deleteArtifactByInterface(String resourceId, String userUserId, String artifactId,
3326                                                                        boolean inTransaction) {
3327         User user = new User();
3328         user.setUserId(userUserId);
3329         Either<Resource, StorageOperationStatus> parent = toscaOperationFacade.getToscaElement(resourceId, JsonParseFlagEnum.ParseMetadata);
3330         if (parent.isRight()) {
3331             ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(parent
3332                     .right()
3333                     .value()));
3334             return Either.right(responseFormat);
3335         }
3336         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = handleDelete(resourceId, artifactId, user, AuditingActionEnum.ARTIFACT_DELETE, ComponentTypeEnum.RESOURCE, parent
3337                         .left()
3338                         .value(),
3339                 false, inTransaction);
3340         if (handleDelete.isRight()) {
3341             return Either.right(handleDelete.right().value());
3342         }
3343         Either<ArtifactDefinition, Operation> result = handleDelete.left().value();
3344         return Either.left(result.right().value());
3345
3346     }
3347
3348     private Operation convertToOperation(ArtifactDefinition artifactInfo, String operationName) {
3349         Operation op = new Operation();
3350         long time = System.currentTimeMillis();
3351         op.setCreationDate(time);
3352
3353         String artifactName = artifactInfo.getArtifactName();
3354         artifactInfo.setArtifactName(createInterfaceArtifactNameFromOperation(operationName, artifactName));
3355
3356         op.setImplementation(artifactInfo);
3357         op.setLastUpdateDate(time);
3358         return op;
3359     }
3360
3361     private String createInterfaceArtifactNameFromOperation(String operationName, String artifactName) {
3362         String newArtifactName = operationName + "_" + artifactName;
3363         log.trace("converting artifact name {} to {}", artifactName, newArtifactName);
3364         return newArtifactName;
3365     }
3366
3367     // download by MSO
3368     public Either<byte[], ResponseFormat> downloadRsrcArtifactByNames(String serviceName, String serviceVersion, String resourceName, String resourceVersion, String artifactName) {
3369
3370         // General validation
3371         if (serviceName == null || serviceVersion == null || resourceName == null || resourceVersion == null || artifactName == null) {
3372             log.debug(NULL_PARAMETER);
3373             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3374         }
3375
3376         // Normalizing artifact name
3377         artifactName = ValidationUtils.normalizeFileName(artifactName);
3378
3379         // Resource validation
3380         Either<Resource, ResponseFormat> validateResourceNameAndVersion = validateResourceNameAndVersion(resourceName, resourceVersion);
3381         if (validateResourceNameAndVersion.isRight()) {
3382             return Either.right(validateResourceNameAndVersion.right().value());
3383         }
3384
3385         Resource resource = validateResourceNameAndVersion.left().value();
3386         String resourceId = resource.getUniqueId();
3387
3388         // Service validation
3389         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3390         if (validateServiceNameAndVersion.isRight()) {
3391             return Either.right(validateServiceNameAndVersion.right().value());
3392         }
3393
3394         Map<String, ArtifactDefinition> artifacts = resource.getDeploymentArtifacts();
3395         if (artifacts == null || artifacts.isEmpty()) {
3396             log.debug("Deployment artifacts of resource {} are not found", resourceId);
3397             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3398         }
3399
3400         ArtifactDefinition deploymentArtifact = null;
3401
3402         for (ArtifactDefinition artifactDefinition : artifacts.values()) {
3403             if (artifactDefinition.getArtifactName() != null && artifactDefinition.getArtifactName()
3404                                                                                   .equals(artifactName)) {
3405                 log.debug(FOUND_DEPLOYMENT_ARTIFACT, artifactName);
3406                 deploymentArtifact = artifactDefinition;
3407                 break;
3408             }
3409         }
3410
3411         if (deploymentArtifact == null) {
3412             log.debug("No deployment artifact {} was found for resource {}", artifactName, resourceId);
3413             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3414         }
3415
3416         // Downloading the artifact
3417         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(deploymentArtifact);
3418         if (downloadArtifactEither.isRight()) {
3419             log.debug(FAILED_DOWNLOAD_ARTIFACT, artifactName);
3420             return Either.right(downloadArtifactEither.right().value());
3421         }
3422         log.trace("Download of resource artifact succeeded, uniqueId {}", deploymentArtifact.getUniqueId());
3423         return Either.left(downloadArtifactEither.left().value().getRight());
3424     }
3425
3426     // download by MSO
3427     public Either<byte[], ResponseFormat> downloadRsrcInstArtifactByNames(String serviceName, String serviceVersion, String resourceInstanceName, String artifactName) {
3428
3429         // General validation
3430         if (serviceName == null || serviceVersion == null || resourceInstanceName == null || artifactName == null) {
3431             log.debug(NULL_PARAMETER);
3432             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3433         }
3434
3435         // Normalizing artifact name
3436         artifactName = ValidationUtils.normalizeFileName(artifactName);
3437
3438         // Service validation
3439         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3440         if (validateServiceNameAndVersion.isRight()) {
3441             return Either.right(validateServiceNameAndVersion.right().value());
3442         }
3443
3444         Service service = validateServiceNameAndVersion.left().value();
3445
3446         // ResourceInstance validation
3447         Either<ComponentInstance, ResponseFormat> validateResourceInstance = validateResourceInstance(service, resourceInstanceName);
3448         if (validateResourceInstance.isRight()) {
3449             return Either.right(validateResourceInstance.right().value());
3450         }
3451
3452         ComponentInstance resourceInstance = validateResourceInstance.left().value();
3453
3454         Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
3455
3456         final String finalArtifactName = artifactName;
3457         Predicate<ArtifactDefinition> filterArtifactByName = p -> p.getArtifactName().equals(finalArtifactName);
3458
3459         boolean hasDeploymentArtifacts = artifacts != null && artifacts.values()
3460                                                                        .stream()
3461                                                                        .anyMatch(filterArtifactByName);
3462         ArtifactDefinition deployableArtifact;
3463
3464         if (!hasDeploymentArtifacts) {
3465             log.debug("Deployment artifact with name {} not found", artifactName);
3466             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3467         }
3468
3469         log.debug(FOUND_DEPLOYMENT_ARTIFACT, artifactName);
3470         deployableArtifact = artifacts.values().stream().filter(filterArtifactByName).findFirst().get();
3471         // Downloading the artifact
3472         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(deployableArtifact);
3473
3474         if (downloadArtifactEither.isRight()) {
3475             log.debug(FAILED_DOWNLOAD_ARTIFACT, artifactName);
3476             return Either.right(downloadArtifactEither.right().value());
3477         }
3478         log.trace("Download of resource artifact succeeded, uniqueId {}", deployableArtifact.getUniqueId());
3479         return Either.left(downloadArtifactEither.left().value().getRight());
3480     }
3481
3482     private Either<ComponentInstance, ResponseFormat> validateResourceInstance(Service service, String resourceInstanceName) {
3483
3484         List<ComponentInstance> riList = service.getComponentInstances();
3485         for (ComponentInstance ri : riList) {
3486             if (ri.getNormalizedName().equals(resourceInstanceName)) {
3487                 return Either.left(ri);
3488             }
3489         }
3490
3491         return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND, resourceInstanceName));
3492     }
3493
3494     private Either<Service, ResponseFormat> validateServiceNameAndVersion(String serviceName, String serviceVersion) {
3495
3496         Either<List<Service>, StorageOperationStatus> serviceListBySystemName = toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName);
3497         if (serviceListBySystemName.isRight()) {
3498             log.debug("Couldn't fetch any service with name {}", serviceName);
3499             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceListBySystemName
3500                     .right()
3501                     .value(), ComponentTypeEnum.SERVICE), serviceName));
3502         }
3503         List<Service> serviceList = serviceListBySystemName.left().value();
3504         if (serviceList == null || serviceList.isEmpty()) {
3505             log.debug("Couldn't fetch any service with name {}", serviceName);
3506             return Either.right(componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceName));
3507         }
3508
3509         Service foundService = null;
3510         for (Service service : serviceList) {
3511             if (service.getVersion().equals(serviceVersion)) {
3512                 log.trace("Found service with version {}", serviceVersion);
3513                 foundService = service;
3514                 break;
3515             }
3516         }
3517
3518         if (foundService == null) {
3519             log.debug("Couldn't find version {} for service {}", serviceVersion, serviceName);
3520             return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_VERSION_NOT_FOUND, ComponentTypeEnum.SERVICE
3521                     .getValue(), serviceVersion));
3522         }
3523         return Either.left(foundService);
3524     }
3525
3526     private Either<Resource, ResponseFormat> validateResourceNameAndVersion(String resourceName, String resourceVersion) {
3527
3528         Either<Resource, StorageOperationStatus> resourceListBySystemName = toscaOperationFacade.getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion, JsonParseFlagEnum.ParseMetadata);
3529         if (resourceListBySystemName.isRight()) {
3530             log.debug("Couldn't fetch any resource with name {} and version {}. ", resourceName, resourceVersion);
3531             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceListBySystemName
3532                     .right()
3533                     .value()), resourceName));
3534         }
3535         return Either.left(resourceListBySystemName.left().value());
3536     }
3537
3538     public Either<byte[], ResponseFormat> downloadServiceArtifactByNames(String serviceName, String serviceVersion, String artifactName) {
3539         // Validation
3540         log.trace("Starting download of service interface artifact, serviceName {}, serviceVersion {}, artifact name {}", serviceName, serviceVersion, artifactName);
3541         if (serviceName == null || serviceVersion == null || artifactName == null) {
3542             log.debug(NULL_PARAMETER);
3543             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3544         }
3545
3546         // Normalizing artifact name
3547         final String normalizedArtifactName = ValidationUtils.normalizeFileName(artifactName);
3548
3549         // Service validation
3550         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3551         if (validateServiceNameAndVersion.isRight()) {
3552             return Either.right(validateServiceNameAndVersion.right().value());
3553         }
3554
3555         String serviceId = validateServiceNameAndVersion.left().value().getUniqueId();
3556
3557         // Looking for deployment or tosca artifacts
3558         Service service = validateServiceNameAndVersion.left().value();
3559
3560         if (MapUtils.isEmpty(service.getDeploymentArtifacts()) && MapUtils.isEmpty(service.getToscaArtifacts())) {
3561             log.debug("Neither Deployment nor Tosca artifacts of service {} are found", serviceId);
3562             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, normalizedArtifactName));
3563         }
3564
3565         Optional<ArtifactDefinition> foundArtifactOptl = null;
3566
3567         if (!MapUtils.isEmpty(service.getDeploymentArtifacts())) {
3568             foundArtifactOptl = service.getDeploymentArtifacts().values().stream()
3569                                        // filters artifact by name
3570                                        .filter(a -> a.getArtifactName().equals(normalizedArtifactName)).findAny();
3571         }
3572         if ((foundArtifactOptl == null || !foundArtifactOptl.isPresent()) && !MapUtils.isEmpty(service.getToscaArtifacts())) {
3573             foundArtifactOptl = service.getToscaArtifacts().values().stream()
3574                                        // filters TOSCA artifact by name
3575                                        .filter(a -> a.getArtifactName().equals(normalizedArtifactName)).findAny();
3576         }
3577         if (!foundArtifactOptl.isPresent()) {
3578             log.debug("The artifact {} was not found for service {}", normalizedArtifactName, serviceId);
3579             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, normalizedArtifactName));
3580         }
3581         log.debug(FOUND_DEPLOYMENT_ARTIFACT, normalizedArtifactName);
3582         // Downloading the artifact
3583         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(foundArtifactOptl
3584                 .get());
3585         if (downloadArtifactEither.isRight()) {
3586             log.debug(FAILED_DOWNLOAD_ARTIFACT, normalizedArtifactName);
3587             return Either.right(downloadArtifactEither.right().value());
3588         }
3589         log.trace("Download of service artifact succeeded, uniqueId {}", foundArtifactOptl.get().getUniqueId());
3590         return Either.left(downloadArtifactEither.left().value().getRight());
3591     }
3592
3593     public Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifact(String parentId, String artifactUniqueId) {
3594         log.trace("Starting download of artifact, uniqueId {}", artifactUniqueId);
3595         Either<ArtifactDefinition, StorageOperationStatus> artifactById = artifactToscaOperation.getArtifactById(parentId, artifactUniqueId);
3596         if (artifactById.isRight()) {
3597             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(artifactById.right().value());
3598             log.debug("Error when getting artifact info by id{}, error: {}", artifactUniqueId, actionStatus);
3599             return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, ""));
3600         }
3601         ArtifactDefinition artifactDefinition = artifactById.left().value();
3602         if (artifactDefinition == null) {
3603             log.debug("Empty artifact definition returned from DB by artifact id {}", artifactUniqueId);
3604             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, ""));
3605         }
3606
3607         return downloadArtifact(artifactDefinition);
3608     }
3609
3610     private boolean checkArtifactInComponent(org.openecomp.sdc.be.model.Component component, String artifactId) {
3611         boolean found = false;
3612         Map<String, ArtifactDefinition> artifactsS = component.getArtifacts();
3613         if (artifactsS != null) {
3614             for (Map.Entry<String, ArtifactDefinition> entry : artifactsS.entrySet()) {
3615                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3616                     found = true;
3617                     break;
3618                 }
3619             }
3620         }
3621         Map<String, ArtifactDefinition> deploymentArtifactsS = component.getDeploymentArtifacts();
3622         if (!found && deploymentArtifactsS != null) {
3623             for (Map.Entry<String, ArtifactDefinition> entry : deploymentArtifactsS.entrySet()) {
3624                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3625                     found = true;
3626                     break;
3627                 }
3628             }
3629         }
3630         Map<String, ArtifactDefinition> toscaArtifactsS = component.getToscaArtifacts();
3631         if (!found && toscaArtifactsS != null) {
3632             for (Map.Entry<String, ArtifactDefinition> entry : toscaArtifactsS.entrySet()) {
3633                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3634                     found = true;
3635                     break;
3636                 }
3637             }
3638         }
3639
3640         Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
3641         if (!found && interfaces != null) {
3642             for (Map.Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
3643                 Map<String, Operation> operations = entry.getValue().getOperationsMap();
3644                 for (Map.Entry<String, Operation> entryOp : operations.entrySet()) {
3645                     if (entryOp.getValue().getImplementation() != null && entryOp.getValue()
3646                             .getImplementation()
3647                             .getUniqueId()
3648                             .equals(artifactId)) {
3649                         found = true;
3650                         break;
3651                     }
3652                 }
3653             }
3654         }
3655
3656         switch (component.getComponentType()) {
3657             case RESOURCE:
3658                 break;
3659             case SERVICE:
3660                 Map<String, ArtifactDefinition> apiArtifacts = ((Service) component).getServiceApiArtifacts();
3661                 if (!found && apiArtifacts != null) {
3662                     for (Map.Entry<String, ArtifactDefinition> entry : apiArtifacts.entrySet()) {
3663                         if (entry.getValue().getUniqueId().equals(artifactId)) {
3664                             found = true;
3665                             break;
3666                         }
3667                     }
3668                 }
3669                 break;
3670             default:
3671
3672         }
3673
3674         return found;
3675     }
3676
3677     private boolean checkArtifactInResourceInstance(Component component, String resourceInstanceId, String artifactId) {
3678
3679         boolean found = false;
3680         List<ComponentInstance> resourceInstances = component.getComponentInstances();
3681         ComponentInstance resourceInstance = null;
3682         for (ComponentInstance ri : resourceInstances) {
3683             if (ri.getUniqueId().equals(resourceInstanceId)) {
3684                 resourceInstance = ri;
3685                 break;
3686             }
3687         }
3688         if (resourceInstance != null) {
3689             Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
3690             if (artifacts != null) {
3691                 for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
3692                     if (entry.getValue().getUniqueId().equals(artifactId)) {
3693                         found = true;
3694                         break;
3695                     }
3696                 }
3697             }
3698             if (!found) {
3699                 artifacts = resourceInstance.getArtifacts();
3700                 if (artifacts != null) {
3701                     for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
3702                         if (entry.getValue().getUniqueId().equals(artifactId)) {
3703                             found = true;
3704                             break;
3705                         }
3706                     }
3707                 }
3708             }
3709         }
3710         return found;
3711     }
3712
3713     private Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists(String componentId, AuditingActionEnum auditingAction, User user, String artifactId, ComponentTypeEnum componentType,
3714                                                                                                            String containerComponentType) {
3715
3716         ComponentTypeEnum componentForAudit = null == containerComponentType ? componentType : ComponentTypeEnum.findByParamName(containerComponentType);
3717         componentForAudit.getNodeType();
3718
3719         Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentResult = toscaOperationFacade
3720                 .getToscaFullElement(componentId);
3721
3722         if (componentResult.isRight()) {
3723             ActionStatus status = componentForAudit == ComponentTypeEnum.RESOURCE ? ActionStatus.RESOURCE_NOT_FOUND : componentType == ComponentTypeEnum.SERVICE ? ActionStatus.SERVICE_NOT_FOUND : ActionStatus.PRODUCT_NOT_FOUND;
3724             ResponseFormat responseFormat = componentsUtils.getResponseFormat(status, componentId);
3725             log.debug("Service not found, serviceId {}", componentId);
3726             handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentForAudit, null);
3727             return Either.right(responseFormat);
3728         }
3729         return Either.left(componentResult.left().value());
3730     }
3731
3732     private Either<Boolean, ResponseFormat> validateWorkOnComponent(Component component, String userId, AuditingActionEnum auditingAction, User user, String artifactId, ArtifactOperationInfo operation) {
3733         if (operation.getArtifactOperationEnum() != ArtifactOperationEnum.DOWNLOAD && !operation.ignoreLifecycleState()) {
3734             Either<Boolean, ResponseFormat> canWork = validateCanWorkOnComponent(component, userId);
3735             if (canWork.isRight()) {
3736                 String uniqueId = component.getUniqueId();
3737                 log.debug("Service status isn't  CHECKOUT or user isn't owner, serviceId {}", uniqueId);
3738                 handleAuditing(auditingAction, component, uniqueId, user, null, null, artifactId, canWork.right()
3739                                                                                                          .value(), component
3740                         .getComponentType(), null);
3741                 return Either.right(canWork.right().value());
3742             }
3743         }
3744         return Either.left(true);
3745     }
3746
3747     private Either<Boolean, ResponseFormat> validateUserRole(User user, AuditingActionEnum auditingAction, String componentId, String artifactId, ComponentTypeEnum componentType, ArtifactOperationInfo operation) {
3748
3749         if (operation.getArtifactOperationEnum() != ArtifactOperationEnum.DOWNLOAD) {
3750             String role = user.getRole();
3751             if (!role.equals(Role.ADMIN.name()) && !role.equals(Role.DESIGNER.name())) {
3752                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
3753                 log.debug("addArtifact - user isn't permitted to perform operation, userId {}, role {}", user.getUserId(), role);
3754                 handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentType, null);
3755                 return Either.right(responseFormat);
3756             }
3757         }
3758         return Either.left(true);
3759     }
3760
3761     private Either<User, ResponseFormat> validateUserExists(String userId, AuditingActionEnum auditingAction, String componentId, String artifactId, ComponentTypeEnum componentType, boolean inTransaction) {
3762         User user;
3763         try{
3764             user = validateUserExists(userId, auditingAction.getName(), inTransaction);
3765         } catch(ComponentException e){
3766             user = new User();
3767             user.setUserId(userId);
3768             ResponseFormat responseFormat = e.getResponseFormat() != null ? e.getResponseFormat() :
3769                     componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
3770             handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentType, null);
3771             throw e;
3772         }
3773         return Either.left(user);
3774     }
3775
3776     protected AuditingActionEnum detectAuditingType(ArtifactOperationInfo operation, String origMd5) {
3777         AuditingActionEnum auditingAction = null;
3778         switch (operation.getArtifactOperationEnum()) {
3779             case CREATE:
3780                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_UPLOAD_BY_API : AuditingActionEnum.ARTIFACT_UPLOAD;
3781                 break;
3782             case UPDATE:
3783                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_UPLOAD_BY_API : origMd5 == null ? AuditingActionEnum.ARTIFACT_METADATA_UPDATE : AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE;
3784                 break;
3785             case DELETE:
3786                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_DELETE_BY_API : AuditingActionEnum.ARTIFACT_DELETE;
3787                 break;
3788             case DOWNLOAD:
3789                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.DOWNLOAD_ARTIFACT : AuditingActionEnum.ARTIFACT_DOWNLOAD;
3790                 break;
3791             default:
3792                 break;
3793         }
3794         return auditingAction;
3795     }
3796
3797     private Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifact(ArtifactDefinition artifactDefinition) {
3798         String esArtifactId = artifactDefinition.getEsId();
3799         Either<ESArtifactData, CassandraOperationStatus> artifactfromES = artifactCassandraDao.getArtifact(esArtifactId);
3800         if (artifactfromES.isRight()) {
3801             CassandraOperationStatus resourceUploadStatus = artifactfromES.right().value();
3802             StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
3803             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
3804             log.debug("Error when getting artifact from ES, error: {}", actionStatus);
3805             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(actionStatus, artifactDefinition
3806                     .getArtifactDisplayName());
3807
3808             return Either.right(responseFormat);
3809         }
3810
3811         ESArtifactData esArtifactData = artifactfromES.left().value();
3812         byte[] data = esArtifactData.getDataAsArray();
3813         if (data == null) {
3814             log.debug("Artifact data from ES is null");
3815             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactDefinition.getArtifactDisplayName()));
3816         }
3817         String artifactName = artifactDefinition.getArtifactName();
3818         log.trace("Download of artifact succeeded, uniqueId {}, artifact file name {}", artifactDefinition.getUniqueId(), artifactName);
3819         return Either.left(new ImmutablePair<String, byte[]>(artifactName, data));
3820     }
3821
3822     public ESArtifactData createEsArtifactData(ArtifactDataDefinition artifactInfo, byte[] artifactPayload) {
3823         return new ESArtifactData(artifactInfo.getEsId(), artifactPayload);
3824     }
3825
3826     private boolean saveArtifacts(ESArtifactData artifactData, String resourceId) {
3827         CassandraOperationStatus resourceUploadStatus = artifactCassandraDao.saveArtifact(artifactData);
3828
3829         if (resourceUploadStatus.equals(CassandraOperationStatus.OK)) {
3830             log.debug("Artifact {} was saved in component .", artifactData.getId(), resourceId);
3831         }
3832         else {
3833             log.info("Failed to save artifact {}.", artifactData.getId());
3834             return false;
3835         }
3836         return true;
3837     }
3838
3839     private boolean isArtifactMetadataUpdate(AuditingActionEnum auditingActionEnum) {
3840         return auditingActionEnum.equals(AuditingActionEnum.ARTIFACT_METADATA_UPDATE);
3841     }
3842
3843     private boolean isDeploymentArtifact(ArtifactDefinition artifactInfo) {
3844         return ArtifactGroupTypeEnum.DEPLOYMENT.equals(artifactInfo.getArtifactGroupType());
3845     }
3846
3847     public Either<ArtifactDefinition, ResponseFormat> createArtifactPlaceHolderInfo(String resourceId, String logicalName, Map<String, Object> artifactInfoMap, String userUserId, ArtifactGroupTypeEnum groupType, boolean inTransaction) {
3848         Either<User, ActionStatus> user = userAdminManager.getUser(userUserId, inTransaction);
3849         if (user.isRight()) {
3850             ResponseFormat responseFormat;
3851             if (user.right().value().equals(ActionStatus.USER_NOT_FOUND)) {
3852                 log.debug("create artifact placeholder - not authorized user, userId {}", userUserId);
3853                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
3854             }
3855             else {
3856                 log.debug("create artifact placeholder - failed to authorize user, userId {}", userUserId);
3857                 responseFormat = componentsUtils.getResponseFormat(user.right().value());
3858             }
3859             return Either.right(responseFormat);
3860         }
3861
3862         ArtifactDefinition artifactDefinition = createArtifactPlaceHolderInfo(resourceId, logicalName, artifactInfoMap, user
3863                 .left()
3864                 .value(), groupType);
3865         return Either.left(artifactDefinition);
3866     }
3867
3868     public ArtifactDefinition createArtifactPlaceHolderInfo(String resourceId, String logicalName, Map<String, Object> artifactInfoMap, User user, ArtifactGroupTypeEnum groupType) {
3869         ArtifactDefinition artifactInfo = new ArtifactDefinition();
3870
3871         String artifactName = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_DISPLAY_NAME);
3872         String artifactType = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_TYPE);
3873         String artifactDescription = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_DESCRIPTION);
3874
3875         artifactInfo.setArtifactDisplayName(artifactName);
3876         artifactInfo.setArtifactLabel(logicalName.toLowerCase());
3877         artifactInfo.setArtifactType(artifactType);
3878         artifactInfo.setDescription(artifactDescription);
3879         artifactInfo.setArtifactGroupType(groupType);
3880         nodeTemplateOperation.setDefaultArtifactTimeout(groupType, artifactInfo);
3881
3882         setArtifactPlaceholderCommonFields(resourceId, user, artifactInfo);
3883
3884         return artifactInfo;
3885     }
3886
3887     private void setArtifactPlaceholderCommonFields(String resourceId, User user, ArtifactDefinition artifactInfo) {
3888         String uniqueId = null;
3889
3890         if (resourceId != null) {
3891             uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId.toLowerCase(), artifactInfo.getArtifactLabel()
3892                                                                                                    .toLowerCase());
3893             artifactInfo.setUniqueId(uniqueId);
3894         }
3895         artifactInfo.setUserIdCreator(user.getUserId());
3896         String fullName = user.getFullName();
3897         artifactInfo.setUpdaterFullName(fullName);
3898
3899         long time = System.currentTimeMillis();
3900
3901         artifactInfo.setCreatorFullName(fullName);
3902         artifactInfo.setCreationDate(time);
3903
3904         artifactInfo.setLastUpdateDate(time);
3905         artifactInfo.setUserIdLastUpdater(user.getUserId());
3906
3907         artifactInfo.setMandatory(true);
3908     }
3909
3910     public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) {
3911         return artifactToscaOperation.getArtifacts(parentId, parentType, groupType, instanceId);
3912     }
3913
3914     public Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifact, String componentId, NodeTypeEnum parentType, String instanceId) {
3915         return artifactToscaOperation.addHeatEnvArtifact(artifactHeatEnv, artifact, componentId, parentType, true, instanceId);
3916     }
3917
3918     private Either<ESArtifactData, ResponseFormat> createEsHeatEnvArtifactDataFromString(ArtifactDefinition artifactDefinition, String payloadStr) {
3919
3920         byte[] payload = payloadStr.getBytes();
3921
3922         ESArtifactData artifactData = createEsArtifactData(artifactDefinition, payload);
3923         return Either.left(artifactData);
3924     }
3925
3926     /**
3927      * @param artifactDefinition
3928      * @return
3929      */
3930     public Either<ArtifactDefinition, ResponseFormat> generateHeatEnvArtifact(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
3931                                                                               String instanceId, boolean shouldLock, boolean inTransaction) {
3932         String payload = generateHeatEnvPayload(artifactDefinition);
3933         String prevUUID = artifactDefinition.getArtifactUUID();
3934         ArtifactDefinition clonedBeforeGenerate = new ArtifactDefinition(artifactDefinition);
3935         return generateAndSaveHeatEnvArtifact(artifactDefinition, payload, componentType, component, resourceInstanceName, modifier, instanceId, shouldLock, inTransaction)
3936                 .left()
3937                 .bind(artifactDef -> updateArtifactOnGroupInstance(componentType, component, instanceId, prevUUID, clonedBeforeGenerate, artifactDef));
3938     }
3939
3940     public Either<ArtifactDefinition, ResponseFormat> forceGenerateHeatEnvArtifact(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
3941                                                                                    boolean shouldLock, boolean inTransaction, String instanceId) {
3942         String payload = generateHeatEnvPayload(artifactDefinition);
3943         String prevUUID = artifactDefinition.getArtifactUUID();
3944         ArtifactDefinition clonedBeforeGenerate = new ArtifactDefinition(artifactDefinition);
3945         return forceGenerateAndSaveHeatEnvArtifact(artifactDefinition, payload, componentType, component, resourceInstanceName, modifier, instanceId, shouldLock, inTransaction)
3946                 .left()
3947                 .bind(artifactDef -> updateArtifactOnGroupInstance(componentType, component, instanceId, prevUUID, clonedBeforeGenerate, artifactDef));
3948     }
3949
3950     private Either<ArtifactDefinition, ResponseFormat> updateArtifactOnGroupInstance(ComponentTypeEnum componentType, Component component, String instanceId, String prevUUID, ArtifactDefinition clonedBeforeGenerate, ArtifactDefinition updatedArtDef) {
3951         if (prevUUID == null || !prevUUID.equals(updatedArtDef.getArtifactUUID())) {
3952             List<ComponentInstance> componentInstances = component.getComponentInstances();
3953             if (componentInstances != null) {
3954                 Optional<ComponentInstance> findFirst = componentInstances.stream()
3955                                                                           .filter(ci -> ci.getUniqueId()
3956                                                                                           .equals(instanceId))
3957                                                                           .findFirst();
3958                 if (findFirst.isPresent()) {
3959                     ComponentInstance relevantInst = findFirst.get();
3960                     List<GroupInstance> updatedGroupInstances = getUpdatedGroupInstances(updatedArtDef.getUniqueId(), clonedBeforeGenerate, relevantInst
3961                             .getGroupInstances());
3962
3963                     if (CollectionUtils.isNotEmpty(updatedGroupInstances)) {
3964                         updatedGroupInstances.forEach(gi -> {
3965                             gi.getGroupInstanceArtifacts().add(updatedArtDef.getUniqueId());
3966                             gi.getGroupInstanceArtifactsUuid().add(updatedArtDef.getArtifactUUID());
3967                         });
3968                         Either<List<GroupInstance>, StorageOperationStatus> status = toscaOperationFacade.updateGroupInstancesOnComponent(component, instanceId, updatedGroupInstances);
3969                         if (status.isRight()) {
3970                             log.debug(FAILED_UPDATE_GROUPS, component.getUniqueId());
3971                             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils
3972                                     .convertFromStorageResponse(status.right()
3973                                                                       .value()), clonedBeforeGenerate.getArtifactDisplayName());
3974                             return Either.right(responseFormat);
3975                         }
3976                     }
3977                 }
3978             }
3979         }
3980         return Either.left(updatedArtDef);
3981     }
3982
3983     private String generateHeatEnvPayload(ArtifactDefinition artifactDefinition) {
3984         List<HeatParameterDefinition> heatParameters = artifactDefinition.getListHeatParameters();
3985         StringBuilder sb = new StringBuilder();
3986         sb.append(ConfigurationManager.getConfigurationManager().getConfiguration().getHeatEnvArtifactHeader());
3987         sb.append("parameters:\n");
3988         if (heatParameters != null) {
3989             heatParameters.sort(Comparator.comparing(e -> e.getName()));
3990
3991             List<HeatParameterDefinition> empltyHeatValues = new ArrayList<>();
3992
3993             for (HeatParameterDefinition heatParameterDefinition : heatParameters) {
3994
3995                 String heatValue = heatParameterDefinition.getCurrentValue();
3996                 if (!ValidationUtils.validateStringNotEmpty(heatValue)) {
3997                     heatValue = heatParameterDefinition.getDefaultValue();
3998                     if (!ValidationUtils.validateStringNotEmpty(heatValue)) {
3999                         empltyHeatValues.add(heatParameterDefinition);
4000                         continue;
4001                     }
4002                 }
4003                 HeatParameterType type = HeatParameterType.isValidType(heatParameterDefinition.getType());
4004                 if (type != null) {
4005                     switch (type) {
4006                         case BOOLEAN:
4007                             sb.append("  ")
4008                               .append(heatParameterDefinition.getName())
4009                               .append(":")
4010                               .append(" ")
4011                               .append(Boolean.parseBoolean(heatValue))
4012                               .append("\n");
4013                             break;
4014                         case NUMBER:
4015                             sb.append("  ")
4016                               .append(heatParameterDefinition.getName())
4017                               .append(":")
4018                               .append(" ")
4019                               .append(new BigDecimal(heatValue).toPlainString())
4020                               .append("\n");
4021                             break;
4022                         case COMMA_DELIMITED_LIST:
4023                         case JSON:
4024                             sb.append("  ")
4025                               .append(heatParameterDefinition.getName())
4026                               .append(":")
4027                               .append(" ")
4028                               .append(heatValue)
4029                               .append("\n");
4030                             break;
4031                         default:
4032                             String value = heatValue;
4033                             boolean starts = value.startsWith("\"");
4034                             boolean ends = value.endsWith("\"");
4035                             if (!(starts && ends)) {
4036                                 starts = value.startsWith("'");
4037                                 ends = value.endsWith("'");
4038                                 if (!(starts && ends)) {
4039                                     value = "\"" + value + "\"";
4040                                 }
4041                             }
4042                             sb.append("  ")
4043                               .append(heatParameterDefinition.getName())
4044                               .append(":")
4045                               .append(" ")
4046                               .append(value);
4047                             sb.append("\n");
4048                             break;
4049
4050                     }
4051                 }
4052             }
4053             if (!empltyHeatValues.isEmpty()) {
4054                 empltyHeatValues.sort(Comparator.comparing(e -> e.getName()));
4055                 empltyHeatValues.forEach(hv -> {
4056                     sb.append("  ").append(hv.getName()).append(":");
4057                     HeatParameterType type = HeatParameterType.isValidType(hv.getType());
4058                     if (type != null && type == HeatParameterType.STRING && (hv.getCurrentValue() != null && "".equals(hv
4059                             .getCurrentValue()) || hv.getDefaultValue() != null && "".equals(hv.getDefaultValue()))) {
4060                         sb.append(" \"\"").append("\n");
4061                     }
4062                     else {
4063                         sb.append(" ").append("\n");
4064                     }
4065                 });
4066             }
4067         }
4068         sb.append(ConfigurationManager.getConfigurationManager().getConfiguration().getHeatEnvArtifactFooter());
4069
4070         // DE265919 fix
4071         return sb.toString().replaceAll("\\\\n", "\n");
4072     }
4073
4074     /**
4075      * @param artifactDefinition
4076      * @param payload
4077      * @return
4078      */
4079     public Either<ArtifactDefinition, ResponseFormat> generateAndSaveHeatEnvArtifact(ArtifactDefinition artifactDefinition, String payload, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName,
4080                                                                                      User modifier, String instanceId, boolean shouldLock, boolean inTransaction) {
4081         return generateArtifactPayload(artifactDefinition, componentType, component, resourceInstanceName, modifier, shouldLock, inTransaction, () -> artifactDefinition
4082                         .getHeatParamsUpdateDate(),
4083                 () -> createEsHeatEnvArtifactDataFromString(artifactDefinition, payload), instanceId);
4084
4085     }
4086
4087     public Either<ArtifactDefinition, ResponseFormat> forceGenerateAndSaveHeatEnvArtifact(ArtifactDefinition artifactDefinition, String payload, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName,
4088                                                                                           User modifier, String instanceId, boolean shouldLock, boolean inTransaction) {
4089         return generateArtifactPayload(artifactDefinition, componentType, component, resourceInstanceName, modifier, shouldLock, inTransaction, System::currentTimeMillis,
4090                 () -> createEsHeatEnvArtifactDataFromString(artifactDefinition, payload), instanceId);
4091
4092     }
4093
4094     protected Either<ArtifactDefinition, ResponseFormat> generateArtifactPayload(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
4095                                                                                  boolean shouldLock, boolean inTransaction, Supplier<Long> payloadUpdateDateGen, Supplier<Either<ESArtifactData, ResponseFormat>> esDataCreator, String instanceId) {
4096
4097         log.trace("Start generating payload for {} artifact {}", artifactDefinition.getArtifactType(), artifactDefinition
4098                 .getEsId());
4099         if (artifactDefinition.getPayloadUpdateDate() == null || artifactDefinition.getPayloadUpdateDate() == 0 || artifactDefinition
4100                 .getPayloadUpdateDate() <= payloadUpdateDateGen.get()) {
4101
4102             log.trace("Generating payload for {} artifact {}", artifactDefinition.getArtifactType(), artifactDefinition.getEsId());
4103             Either<ESArtifactData, ResponseFormat> artifactDataRes = esDataCreator.get();
4104             ESArtifactData artifactData = null;
4105
4106             if (artifactDataRes.isLeft()) {
4107                 artifactData = artifactDataRes.left().value();
4108             }
4109             else {
4110                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4111                 handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4112                                 .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4113                         ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4114
4115                 return Either.right(artifactDataRes.right().value());
4116             }
4117             String newCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(artifactData.getDataAsArray());
4118             String oldCheckSum;
4119             String esArtifactId = artifactDefinition.getEsId();
4120             Either<ESArtifactData, CassandraOperationStatus> artifactfromES;
4121             ESArtifactData esArtifactData;
4122             if (esArtifactId != null && !esArtifactId.isEmpty() && artifactDefinition.getPayloadData() == null) {
4123                 log.debug("Try to fetch artifact from cassandra with id : {}", esArtifactId);
4124                 artifactfromES = artifactCassandraDao.getArtifact(esArtifactId);
4125                 if (artifactfromES.isRight()) {
4126                     CassandraOperationStatus resourceUploadStatus = artifactfromES.right().value();
4127                     StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
4128                     ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
4129                     log.debug("Error when getting artifact from ES, error: {} esid : {}", actionStatus, esArtifactId);
4130                     return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, artifactDefinition.getArtifactDisplayName()));
4131                 }
4132                 esArtifactData = artifactfromES.left().value();
4133                 oldCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(esArtifactData.getDataAsArray());
4134             }
4135             else {
4136                 oldCheckSum = artifactDefinition.getArtifactChecksum();
4137
4138             }
4139             Either<ArtifactDefinition, StorageOperationStatus> updateArifactDefinitionStatus = null;
4140
4141             if (shouldLock) {
4142                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(component, "Update Artifact - lock resource: ");
4143                 if (lockComponent.isRight()) {
4144                     handleAuditing(AuditingActionEnum.ARTIFACT_METADATA_UPDATE, component, component.getUniqueId(), modifier, null, null, artifactDefinition
4145                             .getUniqueId(), lockComponent.right().value(), component.getComponentType(), null);
4146                     return Either.right(lockComponent.right().value());
4147                 }
4148             }
4149             try {
4150                 if (oldCheckSum != null && oldCheckSum.equals(newCheckSum)) {
4151
4152                     artifactDefinition.setPayloadUpdateDate(payloadUpdateDateGen.get());
4153                     updateArifactDefinitionStatus = artifactToscaOperation.updateArtifactOnResource(artifactDefinition, component
4154                             .getUniqueId(), artifactDefinition.getUniqueId(), componentType.getNodeType(), instanceId);
4155                     log.trace("No real update done in payload for {} artifact, updating payloadUpdateDate {}", artifactDefinition
4156                             .getArtifactType(), artifactDefinition.getEsId());
4157                     if (updateArifactDefinitionStatus.isRight()) {
4158                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(updateArifactDefinitionStatus
4159                                 .right()
4160                                 .value()), artifactDefinition.getArtifactDisplayName());
4161                         log.trace("Failed to update payloadUpdateDate {}", artifactDefinition.getEsId());
4162                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4163                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4164                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4165
4166                         return Either.right(responseFormat);
4167                     }
4168                 }
4169                 else {
4170
4171                     oldCheckSum = artifactDefinition.getArtifactChecksum();
4172                     artifactDefinition.setArtifactChecksum(newCheckSum);
4173                     artifactDefinition.setEsId(artifactDefinition.getUniqueId());
4174                     log.trace("No real update done in payload for {} artifact, updating payloadUpdateDate {}", artifactDefinition
4175                             .getArtifactType(), artifactDefinition.getEsId());
4176                     updateArifactDefinitionStatus = artifactToscaOperation.updateArtifactOnResource(artifactDefinition, component
4177                             .getUniqueId(), artifactDefinition.getUniqueId(), componentType.getNodeType(), instanceId);
4178
4179                     log.trace("Update Payload  ", artifactDefinition.getEsId());
4180                 }
4181                 if (updateArifactDefinitionStatus != null && updateArifactDefinitionStatus.isLeft()) {
4182
4183                     artifactDefinition = updateArifactDefinitionStatus.left().value();
4184                     artifactData.setId(artifactDefinition.getUniqueId());
4185                     CassandraOperationStatus saveArtifactStatus = artifactCassandraDao.saveArtifact(artifactData);
4186
4187                     if (saveArtifactStatus.equals(CassandraOperationStatus.OK)) {
4188                         if (!inTransaction) {
4189                             titanDao.commit();
4190                         }
4191                         log.debug("Artifact Saved In ES {}", artifactData.getId());
4192                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4193                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4194                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4195                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4196
4197                     }
4198                     else {
4199                         if (!inTransaction) {
4200                             titanDao.rollback();
4201                         }
4202                         log.info("Failed to save artifact {}.", artifactData.getId());
4203                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4204                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4205                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4206                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4207
4208                         return Either.right(responseFormat);
4209                     }
4210                 }
4211                 else {
4212                     ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(updateArifactDefinitionStatus
4213                             .right()
4214                             .value()), artifactDefinition.getArtifactDisplayName());
4215                     log.debug("Failed To update artifact {}", artifactData.getId());
4216                     handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4217                                     .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4218                             ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4219
4220                     return Either.right(responseFormat);
4221
4222                 }
4223             }
4224             finally {
4225                 if (shouldLock) {
4226                     graphLockOperation.unlockComponent(component.getUniqueId(), component.getComponentType()
4227                                                                                          .getNodeType());
4228                 }
4229             }
4230         }
4231
4232         return Either.left(artifactDefinition);
4233     }
4234
4235
4236     public Map<String, Object> buildJsonForUpdateArtifact(ArtifactDefinition artifactDef, ArtifactGroupTypeEnum artifactGroupType, List<ArtifactTemplateInfo> updatedRequiredArtifacts) {
4237         return this.buildJsonForUpdateArtifact(artifactDef.getUniqueId(), artifactDef.getArtifactName(), artifactDef.getArtifactType(), artifactGroupType, artifactDef
4238                         .getArtifactLabel(), artifactDef.getArtifactDisplayName(),
4239                 artifactDef.getDescription(), artifactDef.getPayloadData(), updatedRequiredArtifacts, artifactDef.getListHeatParameters());
4240
4241     }
4242
4243     public Map<String, Object> buildJsonForUpdateArtifact(String artifactId, String artifactName, String artifactType, ArtifactGroupTypeEnum artifactGroupType, String label, String displayName, String description, byte[] artifactContent,
4244                                                           List<ArtifactTemplateInfo> updatedRequiredArtifacts, List<HeatParameterDefinition> heatParameters) {
4245
4246         Map<String, Object> json = new HashMap<>();
4247         if (artifactId != null && !artifactId.isEmpty()) {
4248             json.put(Constants.ARTIFACT_ID, artifactId);
4249         }
4250
4251         json.put(Constants.ARTIFACT_NAME, artifactName);
4252         json.put(Constants.ARTIFACT_TYPE, artifactType);
4253         json.put(Constants.ARTIFACT_DESCRIPTION, description);
4254
4255         if (artifactContent != null) {
4256             log.debug("payload is encoded. perform decode");
4257             String encodedPayload = Base64.encodeBase64String(artifactContent);
4258             json.put(Constants.ARTIFACT_PAYLOAD_DATA, encodedPayload);
4259         }
4260         json.put(Constants.ARTIFACT_DISPLAY_NAME, displayName);
4261         json.put(Constants.ARTIFACT_LABEL, label);
4262         json.put(Constants.ARTIFACT_GROUP_TYPE, artifactGroupType.getType());
4263         json.put(Constants.REQUIRED_ARTIFACTS, (updatedRequiredArtifacts == null || updatedRequiredArtifacts.isEmpty()) ? new ArrayList<>()
4264                 : updatedRequiredArtifacts.stream()
4265                                           .filter(e -> e.getType().equals(ArtifactTypeEnum.HEAT_ARTIFACT.getType()) || e
4266                                                   .getType()
4267                                                   .equals(ArtifactTypeEnum.HEAT_NESTED.getType()))
4268                                           .map(e -> e.getFileName())
4269                                           .collect(Collectors.toList()));
4270         json.put(Constants.ARTIFACT_HEAT_PARAMS, (heatParameters == null || heatParameters.isEmpty()) ? new ArrayList<>()
4271                 : heatParameters);
4272         return json;
4273     }
4274
4275     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateResourceInstanceArtifactNoContent(String resourceId, Component containerComponent, User user, Map<String, Object> json, ArtifactOperationInfo operation, ArtifactDefinition artifactInfo) {
4276
4277         String jsonStr = gson.toJson(json);
4278         ArtifactDefinition artifactDefinitionFromJson = artifactInfo == null ? RepresentationUtils.convertJsonToArtifactDefinition(jsonStr, ArtifactDefinition.class) : artifactInfo;
4279         String artifactUniqueId = artifactDefinitionFromJson == null ? null : artifactDefinitionFromJson.getUniqueId();
4280         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = validateAndHandleArtifact(resourceId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactUniqueId,
4281                 artifactDefinitionFromJson, null, jsonStr, null, null, user, containerComponent, false, false, true);
4282         if (uploadArtifactToService.isRight()) {
4283             return Either.right(uploadArtifactToService.right().value());
4284         }
4285
4286         return Either.left(uploadArtifactToService.left().value());
4287     }
4288
4289     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleUpdateHeatEnv(String componentId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, String artifactId, User user, ComponentTypeEnum componentType,
4290                                                                                               org.openecomp.sdc.be.model.Component parent, String originData, String origMd5, ArtifactOperationInfo operation, boolean shouldLock, boolean inTransaction) {
4291         convertParentType(componentType);
4292         String parentId = parent.getUniqueId();
4293         ArtifactDefinition currArtifact = artifactInfo;
4294
4295         if (origMd5 != null) {
4296             Either<Boolean, ResponseFormat> validateMd5 = validateMd5(origMd5, originData, artifactInfo.getPayloadData(), operation);
4297             if (validateMd5.isRight()) {
4298                 ResponseFormat responseFormat = validateMd5.right().value();
4299                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4300                 return Either.right(responseFormat);
4301             }
4302
4303             if (artifactInfo.getPayloadData() != null && artifactInfo.getPayloadData().length != 0) {
4304                 Either<Boolean, ResponseFormat> deploymentValidationResult = validateDeploymentArtifact(parent, componentId, false, artifactInfo, currArtifact, NodeTypeEnum.ResourceInstance);
4305                 if (deploymentValidationResult.isRight()) {
4306                     ResponseFormat responseFormat = deploymentValidationResult.right().value();
4307                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4308                     return Either.right(responseFormat);
4309                 }
4310
4311                 Either<byte[], ResponseFormat> payloadEither = handlePayload(artifactInfo, isArtifactMetadataUpdate(auditingAction));
4312                 if (payloadEither.isRight()) {
4313                     ResponseFormat responseFormat = payloadEither.right().value();
4314                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4315                     return Either.right(responseFormat);
4316                 }
4317             }
4318             else { // duplicate
4319                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD);
4320                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4321                 return Either.right(responseFormat);
4322             }
4323         }
4324
4325         // lock resource
4326         if (shouldLock) {
4327             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, UPDATE_ARTIFACT_LOCK);
4328             if (lockComponent.isRight()) {
4329                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, lockComponent.right()
4330                                                                                                             .value(), componentType, null);
4331                 return Either.right(lockComponent.right().value());
4332             }
4333         }
4334         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
4335         try {
4336             resultOp = updateHeatEnvParams(componentId, artifactId, artifactInfo, user, auditingAction, parent, componentType, origMd5);
4337             return resultOp;
4338
4339         }
4340         finally {
4341             // unlock resource
4342             if (resultOp == null || resultOp.isRight()) {
4343                 log.debug(ROLLBACK);
4344                 if (!inTransaction) {
4345                     titanDao.rollback();
4346                 }
4347             }
4348             else {
4349                 log.debug(COMMIT);
4350                 if (!inTransaction) {
4351                     titanDao.commit();
4352                 }
4353             }
4354             if (shouldLock) {
4355                 componentType = parent.getComponentType();
4356             }
4357             NodeTypeEnum nodeType = componentType.getNodeType();
4358             graphLockOperation.unlockComponent(parent.getUniqueId(), nodeType);
4359         }
4360     }
4361
4362     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateHeatEnvParams(String componentId, String artifactId, ArtifactDefinition artifactInfo, User user, AuditingActionEnum auditingAction, Component parent,
4363                                                                                               ComponentTypeEnum componentType, String origMd5) {
4364
4365         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
4366         Either<ArtifactDefinition, Operation> insideEither = null;
4367         Either<ComponentInstance, ResponseFormat> getRI = getRIFromComponent(parent, componentId, artifactId, auditingAction, user);
4368         if (getRI.isRight()) {
4369             return Either.right(getRI.right().value());
4370         }
4371         ComponentInstance ri = getRI.left().value();
4372         Either<ArtifactDefinition, ResponseFormat> getArtifactRes = getArtifactFromRI(parent, ri, componentId, artifactId, auditingAction, user);
4373         if (getArtifactRes.isRight()) {
4374             return Either.right(getArtifactRes.right().value());
4375         }
4376         ArtifactDefinition currArtifact = getArtifactRes.left().value();
4377
4378         if (currArtifact.getArtifactType().equals(ArtifactTypeEnum.HEAT.getType()) || currArtifact.getArtifactType()
4379                                                                                                   .equals(ArtifactTypeEnum.HEAT_VOL
4380                                                                                                           .getType()) || currArtifact
4381                 .getArtifactType()
4382                 .equals(ArtifactTypeEnum.HEAT_NET.getType())) {
4383             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
4384             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4385                     .getName());
4386             return Either.right(responseFormat);
4387         }
4388         List<HeatParameterDefinition> currentHeatEnvParams = currArtifact.getListHeatParameters();
4389         List<HeatParameterDefinition> updatedHeatEnvParams = artifactInfo.getListHeatParameters();
4390         new ArrayList<HeatParameterDefinition>();
4391
4392         // upload
4393         if (origMd5 != null) {
4394             Either<List<HeatParameterDefinition>, ResponseFormat> uploadParamsValidationResult = validateUploadParamsFromEnvFile(auditingAction, parent, user, artifactInfo, artifactId, componentType, ri
4395                             .getName(), currentHeatEnvParams,
4396                     updatedHeatEnvParams, currArtifact.getArtifactName());
4397             if (uploadParamsValidationResult.isRight()) {
4398                 ResponseFormat responseFormat = uploadParamsValidationResult.right().value();
4399                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4400                         .getName());
4401                 return Either.right(responseFormat);
4402             }
4403             artifactInfo.setListHeatParameters(updatedHeatEnvParams);
4404         }
4405
4406         Either<ArtifactDefinition, ResponseFormat> validateAndConvertHeatParamers = validateAndConvertHeatParamers(artifactInfo, ArtifactTypeEnum.HEAT_ENV
4407                 .getType());
4408         if (validateAndConvertHeatParamers.isRight()) {
4409             ResponseFormat responseFormat = validateAndConvertHeatParamers.right().value();
4410             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4411                     .getName());
4412             return Either.right(responseFormat);
4413         }
4414
4415         if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty()) {
4416             // fill reduced heat env parameters List for updating
4417             replaceCurrHeatValueWithUpdatedValue(currentHeatEnvParams, updatedHeatEnvParams);
4418             currArtifact.setHeatParamsUpdateDate(System.currentTimeMillis());
4419             currArtifact.setListHeatParameters(currentHeatEnvParams);
4420
4421             Either<ArtifactDefinition, StorageOperationStatus> updateArifactRes = artifactToscaOperation.updateArtifactOnResource(currArtifact, parent
4422                     .getUniqueId(), currArtifact.getUniqueId(), componentType.getNodeType(), componentId);
4423             if (updateArifactRes.isRight()) {
4424                 log.debug("Failed to update artifact on graph  - {}", artifactId);
4425                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateArifactRes
4426                         .right()
4427                         .value()));
4428                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4429                         .getName());
4430                 return Either.right(responseFormat);
4431             }
4432             StorageOperationStatus error = generateCustomizationUUIDOnInstance(parent.getUniqueId(), ri.getUniqueId(), componentType);
4433             if (error != StorageOperationStatus.OK) {
4434                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
4435                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4436                         .getName());
4437                 return Either.right(responseFormat);
4438             }
4439
4440             error = generateCustomizationUUIDOnGroupInstance(ri, updateArifactRes.left()
4441                                                                                  .value()
4442                                                                                  .getUniqueId(), parent.getUniqueId());
4443             if (error != StorageOperationStatus.OK) {
4444                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
4445                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4446                         .getName());
4447                 return Either.right(responseFormat);
4448             }
4449
4450         }
4451         insideEither = Either.left(currArtifact);
4452         resultOp = Either.left(insideEither);
4453         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4454         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currArtifact, null, artifactId, responseFormat, componentType, ri
4455                 .getName());
4456         return resultOp;
4457     }
4458
4459     private void replaceCurrHeatValueWithUpdatedValue(List<HeatParameterDefinition> currentHeatEnvParams, List<HeatParameterDefinition> updatedHeatEnvParams) {
4460         for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
4461             String paramName = heatEnvParam.getName();
4462             for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4463                 if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4464                     String updatedParamValue = heatEnvParam.getCurrentValue();
4465                     currHeatParam.setCurrentValue(updatedParamValue);
4466                 }
4467             }
4468         }
4469     }
4470
4471     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateHeatParams(String componentId, String artifactId, ArtifactDefinition artifactEnvInfo, User user, AuditingActionEnum auditingAction, Component parent,
4472                                                                                            ComponentTypeEnum componentType, ArtifactDefinition currHeatArtifact, boolean needToUpdateGroup) {
4473
4474         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp;
4475         Either<ArtifactDefinition, Operation> insideEither = null;
4476         String currentHeatId = currHeatArtifact.getUniqueId();
4477
4478         String esArtifactId = currHeatArtifact.getEsId();
4479         Either<ESArtifactData, CassandraOperationStatus> artifactFromES = artifactCassandraDao.getArtifact(esArtifactId);
4480         if (artifactFromES.isRight()) {
4481             CassandraOperationStatus resourceUploadStatus = artifactFromES.right().value();
4482             StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
4483             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
4484             log.debug("Error when getting artifact from ES, error: {}", actionStatus);
4485             return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, currHeatArtifact.getArtifactDisplayName()));
4486         }
4487
4488         ESArtifactData esArtifactData = artifactFromES.left().value();
4489
4490         ArtifactDefinition updatedHeatArt = currHeatArtifact;
4491
4492         List<HeatParameterDefinition> updatedHeatEnvParams = artifactEnvInfo.getListHeatParameters();
4493         List<HeatParameterDefinition> currentHeatEnvParams = currHeatArtifact.getListHeatParameters();
4494         List<HeatParameterDefinition> newHeatEnvParams = new ArrayList<HeatParameterDefinition>();
4495
4496         if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty() && currentHeatEnvParams != null && !currentHeatEnvParams
4497                 .isEmpty()) {
4498
4499             String paramName;
4500             for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
4501
4502                 paramName = heatEnvParam.getName();
4503                 for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4504                     if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4505
4506                         String updatedParamValue = heatEnvParam.getCurrentValue();
4507                         if (updatedParamValue == null) {
4508                             updatedParamValue = heatEnvParam.getDefaultValue();
4509                         }
4510                         HeatParameterType paramType = HeatParameterType.isValidType(currHeatParam.getType());
4511                         if (!paramType.getValidator().isValid(updatedParamValue, null)) {
4512                             ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
4513                             ResponseFormat responseFormat = componentsUtils.getResponseFormat(status, ArtifactTypeEnum.HEAT_ENV
4514                                     .getType(), paramType.getType(), paramName);
4515                             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactEnvInfo, null, artifactId, responseFormat, componentType, "");
4516                             return Either.right(responseFormat);
4517
4518                         }
4519                         currHeatParam.setCurrentValue(paramType.getConverter().convert(updatedParamValue, null, null));
4520                         newHeatEnvParams.add(currHeatParam);
4521                         break;
4522                     }
4523                 }
4524             }
4525             if (!newHeatEnvParams.isEmpty()) {
4526                 currHeatArtifact.setListHeatParameters(currentHeatEnvParams);
4527                 Either<ArtifactDefinition, StorageOperationStatus> operationStatus = artifactToscaOperation.updateArtifactOnResource(currHeatArtifact, parent
4528                         .getUniqueId(), currHeatArtifact.getUniqueId(), componentType.getNodeType(), componentId);
4529
4530                 if (operationStatus.isRight()) {
4531                     log.debug("Failed to update artifact on graph  - {}", currHeatArtifact.getUniqueId());
4532
4533                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(operationStatus
4534                             .right()
4535                             .value()));
4536                     return Either.right(responseFormat);
4537
4538                 }
4539                 updatedHeatArt = operationStatus.left().value();
4540                 boolean res = true;
4541                 if (!updatedHeatArt.getDuplicated() || esArtifactData.getId() == null) {
4542                     esArtifactData.setId(updatedHeatArt.getEsId());
4543                 }
4544                 res = saveArtifacts(esArtifactData, parent.getUniqueId());
4545
4546                 if (res) {
4547                     log.debug(ARTIFACT_SAVED, updatedHeatArt.getUniqueId());
4548                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4549                     handleAuditing(auditingAction, parent, parent.getUniqueId(), user, updatedHeatArt, currentHeatId, updatedHeatArt
4550                             .getUniqueId(), responseFormat, componentType, null);
4551                 }
4552                 else {
4553                     BeEcompErrorManager.getInstance().logBeDaoSystemError(UPDATE_ARTIFACT);
4554                     log.debug(FAILED_SAVE_ARTIFACT);
4555                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4556                     handleAuditing(auditingAction, parent, parent.getUniqueId(), user, updatedHeatArt, currentHeatId, updatedHeatArt
4557                             .getUniqueId(), responseFormat, componentType, null);
4558                     resultOp = Either.right(responseFormat);
4559                 }
4560
4561                 insideEither = Either.left(updatedHeatArt);
4562             }
4563         }
4564         Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvArtifact;
4565         if (!currentHeatId.equals(updatedHeatArt.getUniqueId())) {
4566             artifactEnvInfo.setArtifactChecksum(null);
4567             updateHeatEnvArtifact = artifactToscaOperation.updateHeatEnvArtifact(parent.getUniqueId(), artifactEnvInfo, currentHeatId, updatedHeatArt
4568                     .getUniqueId(), componentType.getNodeType(), componentId);
4569         }
4570         else {
4571             updateHeatEnvArtifact = artifactToscaOperation.updateHeatEnvPlaceholder(artifactEnvInfo, componentId, componentType
4572                     .getNodeType());
4573
4574         }
4575         if (needToUpdateGroup && updateHeatEnvArtifact.isLeft()) {
4576             ActionStatus result = updateGroupForHeat(currHeatArtifact, updatedHeatArt, artifactEnvInfo, updateHeatEnvArtifact
4577                     .left()
4578                     .value(), parent, componentType);
4579             if (result != ActionStatus.OK) {
4580                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(result);
4581                 return Either.right(responseFormat);
4582             }
4583         }
4584
4585         if (updatedHeatEnvParams.isEmpty()) {
4586             return getResponseAndAuditInvalidEmptyHeatEnvFile(auditingAction, parent, user, currHeatArtifact, artifactId, componentType);
4587         }
4588         resultOp = Either.left(insideEither);
4589         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4590         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currHeatArtifact, null, artifactId, responseFormat, componentType, "");
4591         return resultOp;
4592
4593     }
4594
4595     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> getResponseAndAuditInvalidEmptyHeatEnvFile(AuditingActionEnum auditingAction, Component parent, User user, ArtifactDefinition currHeatArtifact, String artifactId, ComponentTypeEnum componentType) {
4596         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, currHeatArtifact.getArtifactName());
4597         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currHeatArtifact, null, artifactId, responseFormat, componentType, "");
4598         return Either.right(responseFormat);
4599     }
4600
4601
4602     private StorageOperationStatus generateCustomizationUUIDOnGroupInstance(ComponentInstance ri, String artifactId, String componentId) {
4603         StorageOperationStatus error = StorageOperationStatus.OK;
4604         log.debug("Need to re-generate  customization UUID for group instance on component instance  {}", ri.getUniqueId());
4605         List<GroupInstance> groupsInstances = ri.getGroupInstances();
4606         List<String> groupInstancesId = null;
4607         if (groupsInstances != null && !groupsInstances.isEmpty()) {
4608             groupInstancesId = groupsInstances.stream()
4609                                               .filter(p -> p.getGroupInstanceArtifacts() != null && p.getGroupInstanceArtifacts()
4610                                                                                                      .contains(artifactId))
4611                                               .map(GroupInstanceDataDefinition::getUniqueId)
4612                                               .collect(Collectors.toList());
4613         }
4614         if (groupInstancesId != null && !groupInstancesId.isEmpty()) {
4615             toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(componentId, ri.getUniqueId(), groupInstancesId);
4616         }
4617         return error;
4618
4619     }
4620
4621     public Either<List<HeatParameterDefinition>, ResponseFormat> validateUploadParamsFromEnvFile(AuditingActionEnum auditingAction, Component parent, User user, ArtifactDefinition artifactInfo, String artifactId, ComponentTypeEnum componentType,
4622                                                                                                  String riName, List<HeatParameterDefinition> currentHeatEnvParams, List<HeatParameterDefinition> updatedHeatEnvParams, String currArtifactName) {
4623
4624         if (updatedHeatEnvParams == null || updatedHeatEnvParams.isEmpty()) {
4625             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, artifactInfo
4626                     .getArtifactName(), currArtifactName);
4627             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, riName);
4628             return Either.right(responseFormat);
4629         }
4630
4631         for (HeatParameterDefinition uploadedHeatParam : updatedHeatEnvParams) {
4632             String paramName = uploadedHeatParam.getName();
4633             boolean isExistsInHeat = false;
4634             for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4635                 if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4636
4637                     isExistsInHeat = true;
4638                     uploadedHeatParam.setType(currHeatParam.getType());
4639                     uploadedHeatParam.setCurrentValue(uploadedHeatParam.getDefaultValue());
4640                     uploadedHeatParam.setDefaultValue(currHeatParam.getDefaultValue());
4641                     uploadedHeatParam.setUniqueId(currHeatParam.getUniqueId());
4642                     break;
4643                 }
4644             }
4645             if (!isExistsInHeat) {
4646                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISMATCH_HEAT_VS_HEAT_ENV, currArtifactName);
4647                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, riName);
4648                 return Either.right(responseFormat);
4649             }
4650         }
4651         return Either.left(updatedHeatEnvParams);
4652     }
4653
4654     private Either<ComponentInstance, ResponseFormat> getRIFromComponent(Component component, String riID, String artifactId, AuditingActionEnum auditingAction, User user) {
4655         ResponseFormat responseFormat = null;
4656         List<ComponentInstance> ris = component.getComponentInstances();
4657         for (ComponentInstance ri : ris) {
4658             if (riID.equals(ri.getUniqueId())) {
4659                 return Either.left(ri);
4660             }
4661         }
4662         responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, riID);
4663         log.debug("Resource Instance not found, resourceInstanceId {}", riID);
4664         handleAuditing(auditingAction, null, riID, user, null, null, artifactId, responseFormat, ComponentTypeEnum.RESOURCE_INSTANCE, null);
4665         return Either.right(responseFormat);
4666     }
4667
4668     private Either<ArtifactDefinition, ResponseFormat> getArtifactFromRI(Component component, ComponentInstance ri, String riID, String artifactId, AuditingActionEnum auditingAction, User user) {
4669         ResponseFormat responseFormat = null;
4670         Map<String, ArtifactDefinition> rtifactsMap = ri.getDeploymentArtifacts();
4671         for (ArtifactDefinition artifact : rtifactsMap.values()) {
4672             if (artifactId.equals(artifact.getUniqueId())) {
4673                 return Either.left(artifact);
4674             }
4675         }
4676         responseFormat = componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, riID, component.getUniqueId());
4677         handleAuditing(auditingAction, component, riID, user, null, null, artifactId, responseFormat, ComponentTypeEnum.RESOURCE_INSTANCE, ri
4678                 .getName());
4679         return Either.right(responseFormat);
4680     }
4681
4682     public ArtifactDefinition extractArtifactDefinition(Either<ArtifactDefinition, Operation> eitherArtifact) {
4683         ArtifactDefinition ret;
4684         if (eitherArtifact.isLeft()) {
4685             ret = eitherArtifact.left().value();
4686         }
4687         else {
4688             ret = eitherArtifact.right().value().getImplementationArtifact();
4689         }
4690         return ret;
4691     }
4692
4693     /**
4694      * downloads artifact of component by UUIDs
4695      *
4696      * @param componentType
4697      * @param componentUuid
4698      * @param artifactUUID
4699      * @param resourceCommonInfo
4700      * @return
4701      */
4702     public Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDs(ComponentTypeEnum componentType, String componentUuid, String artifactUUID, ResourceCommonInfo resourceCommonInfo) {
4703         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4704         Either<byte[], ResponseFormat> result;
4705         byte[] downloadedArtifact = null;
4706         Component component = getComponentByUuid(componentType, componentUuid, errorWrapper);
4707         if (errorWrapper.isEmpty() && component != null) {
4708             resourceCommonInfo.setResourceName(component.getName());
4709             downloadedArtifact = downloadArtifact(component.getAllArtifacts(), artifactUUID, errorWrapper, component.getName());
4710         }
4711         if (errorWrapper.isEmpty()) {
4712             result = Either.left(downloadedArtifact);
4713         }
4714         else {
4715             result = Either.right(errorWrapper.getInnerElement());
4716         }
4717         return result;
4718     }
4719
4720     /**
4721      * downloads an artifact of resource instance of component by UUIDs
4722      *
4723      * @param componentType
4724      * @param componentUuid
4725      * @param resourceInstanceName
4726      * @param artifactUUID
4727      * @return
4728      */
4729     public Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDs(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID) {
4730         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4731         Either<byte[], ResponseFormat> result;
4732         byte[] downloadedArtifact = null;
4733         ComponentInstance resourceInstance = getRelatedComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4734         if (errorWrapper.isEmpty()) {
4735             downloadedArtifact = downloadArtifact(resourceInstance.getDeploymentArtifacts(), artifactUUID, errorWrapper, resourceInstance
4736                     .getName());
4737         }
4738         if (errorWrapper.isEmpty()) {
4739             result = Either.left(downloadedArtifact);
4740         }
4741         else {
4742             result = Either.right(errorWrapper.getInnerElement());
4743         }
4744         return result;
4745     }
4746
4747     /**
4748      * uploads an artifact to a component by UUID
4749      *
4750      * @param data
4751      * @param request
4752      * @param componentType
4753      * @param componentUuid
4754      * @param resourceCommonInfo
4755      * @param operation
4756      * @return
4757      */
4758     public Either<ArtifactDefinition, ResponseFormat> uploadArtifactToComponentByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
4759         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4760         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4761         Component component = null;
4762         String componentId = null;
4763         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
4764         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4765         String userId = request.getHeader(Constants.USER_ID_HEADER);
4766
4767         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4768         if (getComponentRes.isRight()) {
4769             StorageOperationStatus status = getComponentRes.right().value();
4770             log.debug(FAILED_FETCH_COMPONENT, componentType, componentUuid, status);
4771             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), componentUuid));
4772         }
4773         if (errorWrapper.isEmpty()) {
4774             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
4775             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
4776
4777             if (!getComponentRes.left()
4778                     .value()
4779                     .getMetadataDataDefinition()
4780                     .getState()
4781                     .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4782                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
4783                 if (component != null) {
4784                     componentId = component.getUniqueId();
4785                     componentName = component.getName();
4786                 }
4787             }
4788             resourceCommonInfo.setResourceName(componentName);
4789         }
4790         if (errorWrapper.isEmpty()) {
4791             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, null, artifactInfo, origMd5, data, null, null, null, null);
4792             if (actionResult.isRight()) {
4793                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
4794                         .right()
4795                         .value());
4796                 return Either.right(actionResult.right().value());
4797             }
4798             return Either.left(actionResult.left().value().left().value());
4799         }
4800         return Either.right(errorWrapper.getInnerElement());
4801     }
4802     /**
4803      * upload an artifact to a resource instance by UUID
4804      *
4805      * @param data
4806      * @param request
4807      * @param componentType
4808      * @param componentUuid
4809      * @param resourceInstanceName
4810      * @param operation
4811      * @return
4812      */
4813     public Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName,
4814                                                                                 ArtifactOperationInfo operation) {
4815         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4816         Either<ArtifactDefinition, ResponseFormat> uploadArtifactResult;
4817         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4818         ArtifactDefinition uploadArtifact = null;
4819         Component component = null;
4820         String componentInstanceId;
4821         String componentId;
4822         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4823         String userId = request.getHeader(Constants.USER_ID_HEADER);
4824
4825         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
4826         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4827         if (getComponentRes.isRight()) {
4828             StorageOperationStatus status = getComponentRes.right().value();
4829             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4830             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), resourceInstanceName));
4831         }
4832         if (errorWrapper.isEmpty() && !getComponentRes.left()
4833                                                       .value()
4834                                                       .getMetadataDataDefinition()
4835                                                       .getState()
4836                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4837             component = checkoutParentComponent(componentType, getComponentRes.left()
4838                                                                               .value()
4839                                                                               .getMetadataDataDefinition()
4840                                                                               .getUniqueId(), userId, errorWrapper);
4841         }
4842         if (errorWrapper.isEmpty()) {
4843             if (component == null) {
4844                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4845             }
4846             else {
4847                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
4848             }
4849         }
4850         if (errorWrapper.isEmpty()) {
4851             componentInstanceId = componentRiPair.getRight().getUniqueId();
4852             componentId = componentRiPair.getLeft().getUniqueId();
4853             ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
4854
4855             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, null, artifactInfo, origMd5, data, null, null, componentId, ComponentTypeEnum
4856                     .findParamByType(componentType));
4857             if (actionResult.isRight()) {
4858                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
4859                         .right()
4860                         .value());
4861                 errorWrapper.setInnerElement(actionResult.right().value());
4862             }
4863         }
4864         if (errorWrapper.isEmpty()) {
4865             uploadArtifact = actionResult.left().value().left().value();
4866             uploadArtifactResult = Either.left(uploadArtifact);
4867         }
4868         else {
4869             uploadArtifactResult = Either.right(errorWrapper.getInnerElement());
4870         }
4871         return uploadArtifactResult;
4872     }
4873
4874     /**
4875      * updates an artifact on a component by UUID
4876      *
4877      * @param data
4878      * @param request
4879      * @param componentType
4880      * @param componentUuid
4881      * @param artifactUUID
4882      * @param operation
4883      * @return
4884      */
4885     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnComponentByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String artifactUUID,
4886                                                                                       ResourceCommonInfo resourceCommonInfo, ArtifactOperationInfo operation) {
4887         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4888         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
4889         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4890         ArtifactDefinition updateArtifact = null;
4891         Component component = null;
4892         String componentId = null;
4893         String artifactId = null;
4894         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinitionForUpdate(data, ArtifactDefinition.class);
4895         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4896         String userId = request.getHeader(Constants.USER_ID_HEADER);
4897
4898         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4899         if (getComponentRes.isRight()) {
4900             StorageOperationStatus status = getComponentRes.right().value();
4901             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4902             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
4903         }
4904         if (errorWrapper.isEmpty()) {
4905             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
4906             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
4907
4908             if (!getComponentRes.left()
4909                                 .value()
4910                                 .getMetadataDataDefinition()
4911                                 .getState()
4912                                 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4913                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
4914                 if (component != null) {
4915                     componentId = component.getUniqueId();
4916                     componentName = component.getName();
4917                 }
4918             }
4919             resourceCommonInfo.setResourceName(componentName);
4920         }
4921         if (errorWrapper.isEmpty()) {
4922             artifactId = getLatestParentArtifactDataIdByArtifactUUID(artifactUUID, errorWrapper, componentId, componentType);
4923         }
4924         if (errorWrapper.isEmpty()) {
4925             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, artifactId, artifactInfo, origMd5, data, null, null, null, null);
4926             if (actionResult.isRight()) {
4927                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
4928                         .right()
4929                         .value());
4930                 errorWrapper.setInnerElement(actionResult.right().value());
4931             }
4932         }
4933         if (errorWrapper.isEmpty()) {
4934             updateArtifact = actionResult.left().value().left().value();
4935             updateArtifactResult = Either.left(updateArtifact);
4936
4937         }
4938         else {
4939             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
4940         }
4941         return updateArtifactResult;
4942     }
4943
4944     /**
4945      * updates an artifact on a resource instance by UUID
4946      *
4947      * @param data
4948      * @param request
4949      * @param componentType
4950      * @param componentUuid
4951      * @param resourceInstanceName
4952      * @param artifactUUID
4953      * @param operation            TODO
4954      * @return
4955      */
4956     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnRiByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID,
4957                                                                                 ArtifactOperationInfo operation) {
4958
4959         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4960         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
4961         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4962         ArtifactDefinition updateArtifact = null;
4963         Component component = null;
4964         String componentInstanceId = null;
4965         String componentId = null;
4966         String artifactId = null;
4967         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4968         String userId = request.getHeader(Constants.USER_ID_HEADER);
4969
4970         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
4971         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4972         if (getComponentRes.isRight()) {
4973             StorageOperationStatus status = getComponentRes.right().value();
4974             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4975             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
4976         }
4977         if (errorWrapper.isEmpty() && !getComponentRes.left()
4978                                                       .value()
4979                                                       .getMetadataDataDefinition()
4980                                                       .getState()
4981                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4982             component = checkoutParentComponent(componentType, getComponentRes.left()
4983                                                                               .value()
4984                                                                               .getMetadataDataDefinition()
4985                                                                               .getUniqueId(), userId, errorWrapper);
4986         }
4987         if (errorWrapper.isEmpty()) {
4988             if (component == null) {
4989                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4990             }
4991             else {
4992                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
4993             }
4994         }
4995         if (errorWrapper.isEmpty()) {
4996             componentInstanceId = componentRiPair.getRight().getUniqueId();
4997             componentId = componentRiPair.getLeft().getUniqueId();
4998             artifactId = findArtifactId(componentRiPair.getRight(), artifactUUID, errorWrapper);
4999         }
5000         if (errorWrapper.isEmpty()) {
5001             ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
5002
5003             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactId, artifactInfo, origMd5, data, null, null, componentId, ComponentTypeEnum
5004                     .findParamByType(componentType));
5005             if (actionResult.isRight()) {
5006                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
5007                         .right()
5008                         .value());
5009                 errorWrapper.setInnerElement(actionResult.right().value());
5010             }
5011         }
5012         if (errorWrapper.isEmpty()) {
5013             updateArtifact = actionResult.left().value().left().value();
5014             updateArtifactResult = Either.left(updateArtifact);
5015         }
5016         else {
5017             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
5018         }
5019         return updateArtifactResult;
5020     }
5021
5022     /**
5023      * updates an artifact on a component by UUID
5024      *
5025      * @param data
5026      * @param request
5027      * @param componentType
5028      * @param componentUuid
5029      * @param artifactUUID
5030      * @param operation        TODO
5031      * @return
5032      */
5033     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnInterfaceOperationByResourceUUID(
5034             String data, HttpServletRequest request, ComponentTypeEnum componentType,
5035             String componentUuid, String artifactUUID, String operationUUID,
5036             ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
5037         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5038         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
5039         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5040         ArtifactDefinition updateArtifact = null;
5041         String componentId = null;
5042         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinitionForUpdate(data, ArtifactDefinition.class);
5043         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5044         String userId = request.getHeader(Constants.USER_ID_HEADER);
5045
5046         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5047         if (getComponentRes.isRight()) {
5048             StorageOperationStatus status = getComponentRes.right().value();
5049             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5050             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5051         }
5052         if (errorWrapper.isEmpty()) {
5053             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
5054             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
5055             if (!getComponentRes.left()
5056                     .value()
5057                     .getMetadataDataDefinition()
5058                     .getState()
5059                     .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5060                 Component component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
5061                 if (component != null) {
5062                     componentId = component.getUniqueId();
5063                     componentName = component.getName();
5064                 }
5065
5066             }
5067             resourceCommonInfo.setResourceName(componentName);
5068         }
5069         if (errorWrapper.isEmpty()) {
5070             Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId);
5071             if (interfaceName.isRight()) {
5072                 errorWrapper.setInnerElement(interfaceName.right().value());
5073             }
5074             if (errorWrapper.isEmpty()) {
5075                 actionResult = handleArtifactRequest(componentId, userId, componentType, operation,
5076                         artifactUUID, artifactInfo, origMd5, data, interfaceName.left().value(),
5077                         operationUUID, null, null);
5078                 if (actionResult.isRight()) {
5079                     log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
5080                             .right()
5081                             .value());
5082                     errorWrapper.setInnerElement(actionResult.right().value());
5083                 }
5084             }
5085         }
5086         if (errorWrapper.isEmpty()) {
5087             updateArtifact = actionResult.left().value().left().value();
5088             updateArtifactResult = Either.left(updateArtifact);
5089
5090         }
5091         else {
5092             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
5093         }
5094         return updateArtifactResult;
5095     }
5096
5097     private Either<String, ResponseFormat> fetchInterfaceName(String componentId) {
5098         Either<Component, StorageOperationStatus> componentStorageOperationStatusEither =
5099                 toscaOperationFacade.getToscaElement(componentId);
5100         if (componentStorageOperationStatusEither.isRight()) {
5101             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
5102             log.debug("Failed to fetch component information by component id, error {}", errorStatus);
5103             return Either.right(componentsUtils
5104                     .getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
5105         }
5106         Component storedComponent = componentStorageOperationStatusEither.left().value();
5107
5108         return Either.left(InterfaceUtils.createInterfaceToscaResourceName(
5109                 storedComponent.getName()));
5110     }
5111
5112
5113     /**
5114      * deletes an artifact on a component by UUID
5115      *
5116      * @param request
5117      * @param componentType
5118      * @param componentUuid
5119      * @param artifactUUID
5120      * @param resourceCommonInfo
5121      * @param operation        TODO
5122      * @return
5123      */
5124     public Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUID(HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String artifactUUID, ResourceCommonInfo resourceCommonInfo,
5125                                                                                       ArtifactOperationInfo operation) {
5126
5127         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5128         Either<ArtifactDefinition, ResponseFormat> deleteArtifactResult;
5129         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5130         ArtifactDefinition deleteArtifact = null;
5131         Component component = null;
5132         String componentId = null;
5133         String artifactId = null;
5134         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5135         String userId = request.getHeader(Constants.USER_ID_HEADER);
5136
5137         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5138         if (getComponentRes.isRight()) {
5139             StorageOperationStatus status = getComponentRes.right().value();
5140             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5141             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), componentUuid));
5142         }
5143         if (errorWrapper.isEmpty()) {
5144             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
5145             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
5146             if (!getComponentRes.left()
5147                                 .value()
5148                                 .getMetadataDataDefinition()
5149                                 .getState()
5150                                 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5151                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
5152                 if (component != null) {
5153                     componentId = component.getUniqueId();
5154                     componentName = component.getName();
5155                 }
5156             }
5157             resourceCommonInfo.setResourceName(componentName);
5158         }
5159         if (errorWrapper.isEmpty()) {
5160             artifactId = getLatestParentArtifactDataIdByArtifactUUID(artifactUUID, errorWrapper, componentId, componentType);
5161         }
5162         if (errorWrapper.isEmpty()) {
5163             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, artifactId, null, origMd5, null, null, null, null, null);
5164             if (actionResult.isRight()) {
5165                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
5166                         .right()
5167                         .value());
5168                 errorWrapper.setInnerElement(actionResult.right().value());
5169             }
5170         }
5171         if (errorWrapper.isEmpty()) {
5172             deleteArtifact = actionResult.left().value().left().value();
5173             deleteArtifactResult = Either.left(deleteArtifact);
5174         }
5175         else {
5176             deleteArtifactResult = Either.right(errorWrapper.getInnerElement());
5177         }
5178         return deleteArtifactResult;
5179     }
5180
5181     /**
5182      * deletes an artifact from a resource instance by UUID
5183      *
5184      * @param request
5185      * @param componentType
5186      * @param componentUuid
5187      * @param resourceInstanceName
5188      * @param artifactUUID
5189      * @param operation            TODO
5190      * @return
5191      */
5192     public Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUID(HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID,
5193                                                                                ArtifactOperationInfo operation) {
5194
5195         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5196         Either<ArtifactDefinition, ResponseFormat> deleteArtifactResult;
5197         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5198         ArtifactDefinition deleteArtifact = null;
5199         Component component = null;
5200         String componentInstanceId = null;
5201         String componentId = null;
5202         String artifactId = null;
5203         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5204         String userId = request.getHeader(Constants.USER_ID_HEADER);
5205         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
5206         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5207         if (getComponentRes.isRight()) {
5208             StorageOperationStatus status = getComponentRes.right().value();
5209             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5210             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5211         }
5212         if (errorWrapper.isEmpty() && !getComponentRes.left()
5213                                                       .value()
5214                                                       .getMetadataDataDefinition()
5215                                                       .getState()
5216                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5217             component = checkoutParentComponent(componentType, getComponentRes.left()
5218                                                                               .value()
5219                                                                               .getMetadataDataDefinition()
5220                                                                               .getUniqueId(), userId, errorWrapper);
5221         }
5222         if (errorWrapper.isEmpty()) {
5223             if (component == null) {
5224                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
5225             }
5226             else {
5227                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
5228             }
5229         }
5230         if (errorWrapper.isEmpty()) {
5231             componentInstanceId = componentRiPair.getRight().getUniqueId();
5232             componentId = componentRiPair.getLeft().getUniqueId();
5233             artifactId = findArtifactId(componentRiPair.getRight(), artifactUUID, errorWrapper);
5234         }
5235         if (errorWrapper.isEmpty()) {
5236
5237             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactId, null, origMd5, null, null, null, componentId, ComponentTypeEnum
5238                     .findParamByType(componentType));
5239
5240             if (actionResult.isRight()) {
5241                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
5242                         .right()
5243                         .value());
5244                 errorWrapper.setInnerElement(actionResult.right().value());
5245             }
5246         }
5247         if (errorWrapper.isEmpty()) {
5248             deleteArtifact = actionResult.left().value().left().value();
5249             deleteArtifactResult = Either.left(deleteArtifact);
5250         }
5251         else {
5252             deleteArtifactResult = Either.right(errorWrapper.getInnerElement());
5253         }
5254         return deleteArtifactResult;
5255     }
5256
5257     private String findArtifactId(ComponentInstance instance, String artifactUUID, Wrapper<ResponseFormat> errorWrapper) {
5258         String artifactId = null;
5259         ArtifactDefinition foundArtifact = null;
5260         if (instance.getDeploymentArtifacts() != null) {
5261             foundArtifact = instance.getDeploymentArtifacts()
5262                                     .values()
5263                                     .stream()
5264                                     .filter(e -> e.getArtifactUUID() != null && e.getArtifactUUID()
5265                                                                                  .equals(artifactUUID))
5266                                     .findFirst()
5267                                     .orElse(null);
5268         }
5269         if (foundArtifact == null && instance.getArtifacts() != null) {
5270             foundArtifact = instance.getArtifacts()
5271                                     .values()
5272                                     .stream()
5273                                     .filter(e -> e.getArtifactUUID() != null && e.getArtifactUUID()
5274                                                                                  .equals(artifactUUID))
5275                                     .findFirst()
5276                                     .orElse(null);
5277         }
5278         if (foundArtifact == null) {
5279             log.debug("The artifact {} was not found on instance {}. ", artifactUUID, instance.getUniqueId());
5280             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactUUID));
5281         }
5282         else {
5283             artifactId = foundArtifact.getUniqueId();
5284         }
5285         return artifactId;
5286     }
5287
5288     @SuppressWarnings("unchecked")
5289     public Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder(ArtifactDefinition heatArtifact, String envType, String parentId, NodeTypeEnum parentType, String parentName, User user, Component component,
5290                                                                                Map<String, String> existingEnvVersions) {
5291         Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
5292                                                                               .getConfiguration()
5293                                                                               .getDeploymentResourceInstanceArtifacts();
5294         if (deploymentResourceArtifacts == null) {
5295             log.debug("no deployment artifacts are configured for generated artifacts");
5296             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
5297         }
5298         Map<String, Object> placeHolderData = (Map<String, Object>) deploymentResourceArtifacts.get(envType);
5299         if (placeHolderData == null) {
5300             log.debug("no env type {} are configured for generated artifacts", envType);
5301             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
5302         }
5303
5304         String envLabel = (heatArtifact.getArtifactLabel() + HEAT_ENV_SUFFIX).toLowerCase();
5305         Either<ArtifactDefinition, ResponseFormat> createArtifactPlaceHolder = createArtifactPlaceHolderInfo(parentId, envLabel, placeHolderData, user
5306                 .getUserId(), ArtifactGroupTypeEnum.DEPLOYMENT, true);
5307         if (createArtifactPlaceHolder.isRight()) {
5308             return Either.right(createArtifactPlaceHolder.right().value());
5309         }
5310         ArtifactDefinition artifactHeatEnv = createArtifactPlaceHolder.left().value();
5311         artifactHeatEnv.setGeneratedFromId(heatArtifact.getUniqueId());
5312         artifactHeatEnv.setHeatParamsUpdateDate(System.currentTimeMillis());
5313         artifactHeatEnv.setTimeout(0);
5314         buildHeatEnvFileName(heatArtifact, artifactHeatEnv, placeHolderData);
5315         // rbetzer - keep env artifactVersion - changeComponentInstanceVersion flow
5316         handleEnvArtifactVersion(artifactHeatEnv, existingEnvVersions);
5317         ArtifactDefinition heatEnvPlaceholder;
5318         // Evg : for resource instance artifact will be added later as block with other env artifacts from BL
5319         if (parentType != NodeTypeEnum.ResourceInstance) {
5320             Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact = addHeatEnvArtifact(artifactHeatEnv, heatArtifact, component
5321                     .getUniqueId(), parentType, parentId);
5322             if (addHeatEnvArtifact.isRight()) {
5323                 log.debug("failed to create heat env artifact on resource instance");
5324                 return Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(addHeatEnvArtifact
5325                         .right()
5326                         .value(), false), "", null));
5327             }
5328             heatEnvPlaceholder = createArtifactPlaceHolder.left().value();
5329         }
5330         else {
5331             heatEnvPlaceholder = artifactHeatEnv;
5332             artifactToscaOperation.generateUUID(heatEnvPlaceholder, heatEnvPlaceholder.getArtifactVersion());
5333             setHeatCurrentValuesOnHeatEnvDefaultValues(heatArtifact, heatEnvPlaceholder);
5334         }
5335
5336         ComponentTypeEnum componentType = component.getComponentType();
5337         if (parentType == NodeTypeEnum.ResourceInstance) {
5338             componentType = ComponentTypeEnum.RESOURCE_INSTANCE;
5339         }
5340         componentsUtils.auditComponent(componentsUtils.getResponseFormat(ActionStatus.OK), user, component, AuditingActionEnum.ARTIFACT_UPLOAD,
5341                 new ResourceCommonInfo(parentName, componentType.getValue()),
5342                 ResourceVersionInfo.newBuilder().build(),
5343                 ResourceVersionInfo.newBuilder().artifactUuid(heatEnvPlaceholder.getUniqueId()).build(),
5344                 null, heatEnvPlaceholder, null);
5345         return Either.left(heatEnvPlaceholder);
5346     }
5347
5348     private void setHeatCurrentValuesOnHeatEnvDefaultValues(ArtifactDefinition artifact, ArtifactDefinition artifactDefinition) {
5349         if (artifact.getListHeatParameters() == null) {
5350             return;
5351         }
5352         List<HeatParameterDefinition> heatEnvParameters = new ArrayList<>();
5353         for (HeatParameterDefinition parameter : artifact.getListHeatParameters()) {
5354             HeatParameterDefinition heatEnvParameter = new HeatParameterDefinition(parameter);
5355             heatEnvParameter.setDefaultValue(parameter.getCurrentValue());
5356             heatEnvParameter.setCurrentValue(null);
5357             heatEnvParameters.add(heatEnvParameter);
5358         }
5359         artifactDefinition.setListHeatParameters(heatEnvParameters);
5360     }
5361
5362     private void buildHeatEnvFileName(ArtifactDefinition heatArtifact, ArtifactDefinition heatEnvArtifact, Map<String, Object> placeHolderData) {
5363         String heatExtension = GeneralUtility.getFilenameExtension(heatArtifact.getArtifactName());
5364         String envExtension = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_FILE_EXTENSION);
5365         String name = heatArtifact.getArtifactName();
5366         String fileName;
5367         if (name == null) {
5368             name = heatArtifact.getArtifactLabel();
5369             fileName = name + "." + envExtension;
5370         }
5371         else {
5372             fileName = name.replaceAll("." + heatExtension, "." + envExtension);
5373         }
5374         heatEnvArtifact.setArtifactName(fileName);
5375     }
5376
5377     private void handleEnvArtifactVersion(ArtifactDefinition heatEnvArtifact, Map<String, String> existingEnvVersions) {
5378         if (null != existingEnvVersions) {
5379             String prevVersion = existingEnvVersions.get(heatEnvArtifact.getArtifactName());
5380             if (null != prevVersion) {
5381                 heatEnvArtifact.setArtifactVersion(prevVersion);
5382             }
5383         }
5384     }
5385
5386     /**
5387      * Handles Artifacts Request For Inner Component
5388      *
5389      * @param artifactsToHandle
5390      * @param component
5391      * @param user
5392      * @param vfcsNewCreatedArtifacts
5393      * @param operation
5394      * @param shouldLock
5395      * @param inTransaction
5396      * @return
5397      */
5398     public Either<List<ArtifactDefinition>, ResponseFormat> handleArtifactsRequestForInnerVfcComponent(List<ArtifactDefinition> artifactsToHandle, Resource component, User user, List<ArtifactDefinition> vfcsNewCreatedArtifacts,
5399                                                                                                        ArtifactOperationInfo operation, boolean shouldLock, boolean inTransaction) {
5400
5401         Either<List<ArtifactDefinition>, ResponseFormat> handleArtifactsResult = null;
5402         ComponentTypeEnum componentType = component.getComponentType();
5403         List<ArtifactDefinition> uploadedArtifacts = new ArrayList<>();
5404         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5405         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult;
5406         String originData;
5407         String origMd5;
5408         try {
5409             for (ArtifactDefinition artifact : artifactsToHandle) {
5410                 originData = buildJsonStringForCsarVfcArtifact(artifact);
5411                 origMd5 = GeneralUtility.calculateMD5Base64EncodedByString(originData);
5412                 actionResult = handleArtifactRequest(component.getUniqueId(), user.getUserId(), componentType, operation, artifact
5413                         .getUniqueId(), artifact, origMd5, originData, null, null, null, null, shouldLock, inTransaction);
5414                 if (actionResult.isRight()) {
5415                     log.debug("Failed to upload artifact to component with type {} and name {}. Status is {}. ", componentType, component
5416                             .getName(), actionResult.right().value());
5417                     errorWrapper.setInnerElement(actionResult.right().value());
5418                     if (ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
5419                         vfcsNewCreatedArtifacts.addAll(uploadedArtifacts);
5420                     }
5421                     break;
5422                 }
5423                 uploadedArtifacts.add(actionResult.left().value().left().value());
5424             }
5425             if (errorWrapper.isEmpty()) {
5426                 handleArtifactsResult = Either.left(uploadedArtifacts);
5427             }
5428             else {
5429                 handleArtifactsResult = Either.right(errorWrapper.getInnerElement());
5430             }
5431         }
5432         catch (Exception e) {
5433             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
5434             handleArtifactsResult = Either.right(responseFormat);
5435             log.debug("Exception occured when handleArtifactsRequestForInnerVfcComponent, error is:{}", e.getMessage(), e);
5436         }
5437         return handleArtifactsResult;
5438     }
5439
5440     private ComponentInstance getRelatedComponentInstance(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5441         ComponentInstance componentInstance = null;
5442         String normalizedName = ValidationUtils.normalizeComponentInstanceName(resourceInstanceName);
5443         Component component = getComponentByUuid(componentType, componentUuid, errorWrapper);
5444         if (errorWrapper.isEmpty()) {
5445             componentInstance = component.getComponentInstances()
5446                                          .stream()
5447                                          .filter(ci -> ValidationUtils.normalizeComponentInstanceName(ci.getName())
5448                                                                       .equals(normalizedName))
5449                                          .findFirst()
5450                                          .orElse(null);
5451             if (componentInstance == null) {
5452                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5453                         .getComponentType()
5454                         .getValue(), component.getName()));
5455                 log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5456             }
5457         }
5458         return componentInstance;
5459     }
5460
5461     private ImmutablePair<Component, ComponentInstance> getRelatedComponentComponentInstance(Component component, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5462
5463         ImmutablePair<Component, ComponentInstance> relatedComponentComponentInstancePair = null;
5464         String normalizedName = ValidationUtils.normalizeComponentInstanceName(resourceInstanceName);
5465         ComponentInstance componentInstance = component.getComponentInstances()
5466                                                        .stream()
5467                                                        .filter(ci -> ValidationUtils.normalizeComponentInstanceName(ci.getName())
5468                                                                                     .equals(normalizedName))
5469                                                        .findFirst()
5470                                                        .orElse(null);
5471         if (componentInstance == null) {
5472             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5473                     .getComponentType()
5474                     .getValue(), component.getName()));
5475             log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5476         }
5477         else {
5478             relatedComponentComponentInstancePair = new ImmutablePair<>(component, componentInstance);
5479         }
5480         return relatedComponentComponentInstancePair;
5481     }
5482
5483     private ImmutablePair<Component, ComponentInstance> getRelatedComponentComponentInstance(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5484         ComponentInstance componentInstance;
5485         ImmutablePair<Component, ComponentInstance> relatedComponentComponentInstancePair = null;
5486         Component component = getLatestComponentByUuid(componentType, componentUuid, errorWrapper);
5487         if (errorWrapper.isEmpty()) {
5488             componentInstance = component.getComponentInstances()
5489                                          .stream()
5490                                          .filter(ci -> ci.getNormalizedName().equals(resourceInstanceName))
5491                                          .findFirst()
5492                                          .orElse(null);
5493             if (componentInstance == null) {
5494                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5495                         .getComponentType()
5496                         .getValue(), component.getName()));
5497                 log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5498             }
5499             else {
5500                 relatedComponentComponentInstancePair = new ImmutablePair<>(component, componentInstance);
5501             }
5502         }
5503         return relatedComponentComponentInstancePair;
5504     }
5505
5506     private byte[] downloadArtifact(Map<String, ArtifactDefinition> artifacts, String artifactUUID, Wrapper<ResponseFormat> errorWrapper, String componentName) {
5507
5508         byte[] downloadedArtifact = null;
5509         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = null;
5510         List<ArtifactDefinition> artifactsList = null;
5511         ArtifactDefinition deploymentArtifact = null;
5512         if (artifacts != null && !artifacts.isEmpty()) {
5513             artifactsList = artifacts.values()
5514                                      .stream()
5515                                      .filter(art -> art.getArtifactUUID() != null && art.getArtifactUUID()
5516                                                                                         .equals(artifactUUID))
5517                                      .collect(Collectors.toList());
5518         }
5519         if (artifactsList == null || artifactsList.isEmpty()) {
5520             log.debug("Deployment artifact with uuid {} was not found for component {}", artifactUUID, componentName);
5521             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactUUID));
5522         }
5523         if (errorWrapper.isEmpty()) {
5524             deploymentArtifact = artifactsList.get(0);
5525             downloadArtifactEither = downloadArtifact(deploymentArtifact);
5526             if (downloadArtifactEither.isRight()) {
5527                 log.debug("Failed to download artifact {}. ", deploymentArtifact.getArtifactName());
5528                 errorWrapper.setInnerElement(downloadArtifactEither.right().value());
5529             }
5530         }
5531         if (errorWrapper.isEmpty()) {
5532             log.trace("Succeeded to download artifact with uniqueId {}", deploymentArtifact.getUniqueId());
5533             downloadedArtifact = downloadArtifactEither.left().value().getRight();
5534         }
5535         return downloadedArtifact;
5536     }
5537
5538     private Component getLatestComponentByUuid(ComponentTypeEnum componentType, String componentUuid, Wrapper<ResponseFormat> errorWrapper) {
5539         Component component = null;
5540         Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentByUuid(componentUuid);
5541         if (getComponentRes.isRight()) {
5542             StorageOperationStatus status = getComponentRes.right().value();
5543             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5544             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5545         }
5546         else {
5547             component = getComponentRes.left().value();
5548         }
5549         return component;
5550     }
5551
5552     private Component getComponentByUuid(ComponentTypeEnum componentType, String componentUuid, Wrapper<ResponseFormat> errorWrapper) {
5553         Component component = null;
5554         Either<List<Component>, StorageOperationStatus> getComponentRes = toscaOperationFacade.getComponentListByUuid(componentUuid, null);
5555         if (getComponentRes.isRight()) {
5556             StorageOperationStatus status = getComponentRes.right().value();
5557             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5558             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5559         }
5560         else {
5561             List<Component> value = getComponentRes.left().value();
5562             if (value.isEmpty()) {
5563                 log.debug("Could not fetch component with type {} and uuid {}.", componentType, componentUuid);
5564                 ActionStatus status = componentType == ComponentTypeEnum.RESOURCE ? ActionStatus.RESOURCE_NOT_FOUND : ActionStatus.SERVICE_NOT_FOUND;
5565                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(status));
5566             }
5567             else {
5568                 component = value.get(0);
5569             }
5570         }
5571         return component;
5572     }
5573
5574     private String getLatestParentArtifactDataIdByArtifactUUID(String artifactUUID, Wrapper<ResponseFormat> errorWrapper, String parentId, ComponentTypeEnum componentType) {
5575         String artifactId = null;
5576         ActionStatus actionStatus = ActionStatus.ARTIFACT_NOT_FOUND;
5577         StorageOperationStatus storageStatus;
5578         ArtifactDefinition latestArtifact = null;
5579         List<ArtifactDefinition> artifacts = null;
5580         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifactsRes = artifactToscaOperation.getArtifacts(parentId);
5581         if (getArtifactsRes.isRight()) {
5582             storageStatus = getArtifactsRes.right().value();
5583             log.debug("Couldn't fetch artifacts data for parent component {} with uid {}, error: {}", componentType, parentId, storageStatus);
5584             if (!storageStatus.equals(StorageOperationStatus.NOT_FOUND)) {
5585                 actionStatus = componentsUtils.convertFromStorageResponse(storageStatus);
5586             }
5587             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5588         }
5589         if (errorWrapper.isEmpty()) {
5590             artifacts = getArtifactsRes.left()
5591                                        .value()
5592                                        .values()
5593                                        .stream()
5594                                        .filter(a -> a.getArtifactUUID() != null && a.getArtifactUUID()
5595                                                                                     .equals(artifactUUID))
5596                                        .collect(Collectors.toList());
5597             if (artifacts == null || artifacts.isEmpty()) {
5598                 log.debug("Couldn't fetch artifact with UUID {} data for parent component {} with uid {}, error: {}", artifactUUID, componentType, parentId, actionStatus);
5599                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5600             }
5601         }
5602         if (errorWrapper.isEmpty()) {
5603             latestArtifact = artifacts.stream().max((a1, a2) -> {
5604                 int compareRes = Double.compare(Double.parseDouble(a1.getArtifactVersion()), Double.parseDouble(a2.getArtifactVersion()));
5605                 if (compareRes == 0) {
5606                     compareRes = Long.compare(a1.getLastUpdateDate() == null ? 0 : a1.getLastUpdateDate(), a2.getLastUpdateDate() == null ? 0 : a2
5607                             .getLastUpdateDate());
5608                 }
5609                 return compareRes;
5610             }).get();
5611             if (latestArtifact == null) {
5612                 log.debug("Couldn't fetch latest artifact with UUID {} data for parent component {} with uid {}, error: {}", artifactUUID, componentType, parentId, actionStatus);
5613                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5614             }
5615         }
5616         if (errorWrapper.isEmpty()) {
5617             artifactId = latestArtifact.getUniqueId();
5618         }
5619         return artifactId;
5620     }
5621
5622     private Component checkoutParentComponent(ComponentTypeEnum componentType, String parentId, String userId, Wrapper<ResponseFormat> errorWrapper) {
5623
5624         Component component = null;
5625         Either<User, ActionStatus> getUserRes = userBusinessLogic.getUser(userId, false);
5626         if (getUserRes.isRight()) {
5627             log.debug("Could not fetch User of component {} with uid {} to checked out. Status is {}. ", componentType.getNodeType(), parentId, getUserRes
5628                     .right()
5629                     .value());
5630             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(getUserRes.right().value()));
5631         }
5632         if (errorWrapper.isEmpty()) {
5633             User modifier = getUserRes.left().value();
5634             LifecycleChangeInfoWithAction changeInfo = new LifecycleChangeInfoWithAction("External API checkout", LifecycleChanceActionEnum.UPDATE_FROM_EXTERNAL_API);
5635             Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic.changeComponentState(componentType, parentId, modifier, LifeCycleTransitionEnum.CHECKOUT, changeInfo, false, true);
5636             if (checkoutRes.isRight()) {
5637                 log.debug("Could not change state of component {} with uid {} to checked out. Status is {}. ", componentType
5638                         .getNodeType(), parentId, checkoutRes.right().value().getStatus());
5639                 errorWrapper.setInnerElement(checkoutRes.right().value());
5640             }
5641             else {
5642                 component = checkoutRes.left().value();
5643             }
5644         }
5645         return component;
5646     }
5647
5648     private String buildJsonStringForCsarVfcArtifact(ArtifactDefinition artifact) {
5649         Map<String, Object> json = new HashMap<>();
5650         String artifactName = artifact.getArtifactName();
5651         json.put(Constants.ARTIFACT_NAME, artifactName);
5652         json.put(Constants.ARTIFACT_LABEL, artifact.getArtifactLabel());
5653         json.put(Constants.ARTIFACT_TYPE, artifact.getArtifactType());
5654         json.put(Constants.ARTIFACT_GROUP_TYPE, ArtifactGroupTypeEnum.DEPLOYMENT.getType());
5655         json.put(Constants.ARTIFACT_DESCRIPTION, artifact.getDescription());
5656         json.put(Constants.ARTIFACT_PAYLOAD_DATA, artifact.getPayloadData());
5657         json.put(Constants.ARTIFACT_DISPLAY_NAME, artifact.getArtifactDisplayName());
5658         return gson.toJson(json);
5659     }
5660
5661     @VisibleForTesting
5662     void setNodeTemplateOperation(NodeTemplateOperation nodeTemplateOperation) {
5663         this.nodeTemplateOperation = nodeTemplateOperation;
5664     }
5665 }