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.components.utils.InterfaceOperationUtils;
  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, interfaceType, 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, String interfaceType,
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         Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
3114             .getInterfaceDefinitionFromComponentByInterfaceType(storedComponent, interfaceType);
3115         if(!optionalInterface.isPresent()) {
3116             log.debug("Failed to get resource interface for resource Id {}", parentId);
3117             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceType));
3118         }
3119
3120         //fetch the operation from storage
3121         InterfaceDefinition gotInterface = optionalInterface.get();
3122         Map<String, Operation> operationsMap = gotInterface.getOperationsMap();
3123         Optional<Operation> optionalOperation = operationsMap.values()
3124                 .stream()
3125                 .filter(o -> o.getUniqueId().equals(operationUuid))
3126                 .findFirst();
3127         if (!optionalOperation.isPresent()) {
3128             log.debug("Failed to get resource interface operation for resource Id {} " +
3129                     " and operationId {}", parentId, operationUuid);
3130             ResponseFormat responseFormat = componentsUtils.getResponseFormat(
3131                     ActionStatus.INTERFACE_OPERATION_NOT_FOUND, parentId);
3132             handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId,
3133                     currArtifactId, responseFormat, componentType, null);
3134             return Either.right(responseFormat);
3135         }
3136
3137         Operation operation = optionalOperation.get();
3138         ArtifactDefinition implementationArtifact =  operation.getImplementationArtifact();
3139         implementationArtifact.setArtifactName(artifactInfo.getArtifactName());
3140         implementationArtifact.setDescription(artifactInfo.getDescription());
3141         implementationArtifact.setArtifactType(artifactInfo.getArtifactType());
3142         implementationArtifact.setArtifactLabel(artifactInfo.getUniqueId());
3143         implementationArtifact.setEsId(artifactInfo.getEsId());
3144         operation.setImplementation(implementationArtifact);
3145         gotInterface.setOperationsMap(operationsMap);
3146         Either<List<InterfaceDefinition>, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
3147                 interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), Collections.singletonList(gotInterface));
3148         if (interfaceDefinitionStorageOperationStatusEither.isRight()){
3149             StorageOperationStatus storageOperationStatus = interfaceDefinitionStorageOperationStatusEither.right().value();
3150             ActionStatus actionStatus =
3151                     componentsUtils.convertFromStorageResponseForDataType(storageOperationStatus);
3152             return Either.right(componentsUtils.getResponseFormat(actionStatus));
3153         }
3154
3155         String uniqueId = implementationArtifact.getUniqueId();
3156         artifactData.setId(uniqueId);
3157         CassandraOperationStatus cassandraOperationStatus = artifactCassandraDao.saveArtifact(artifactData);
3158         if(cassandraOperationStatus != CassandraOperationStatus.OK){
3159             log.debug("Failed to persist operation {} artifact, error is {}",operation.getName(),cassandraOperationStatus);
3160             StorageOperationStatus storageStatus = DaoStatusConverter.convertCassandraStatusToStorageStatus(cassandraOperationStatus);
3161             ActionStatus convertedFromStorageResponse = componentsUtils.convertFromStorageResponse(storageStatus);
3162             return Either.right(componentsUtils.getResponseFormat(convertedFromStorageResponse));
3163         }
3164         return Either.left(Either.left(implementationArtifact));
3165     }
3166
3167     private Either<byte[], ResponseFormat> handlePayload(ArtifactDefinition artifactInfo, boolean isArtifactMetadataUpdate) {
3168         log.trace("Starting payload handling");
3169         byte[] payload = artifactInfo.getPayloadData();
3170         byte[] decodedPayload = null;
3171
3172         if (payload != null && payload.length != 0) {
3173             // the generated artifacts were already decoded by the handler
3174             decodedPayload = artifactInfo.getGenerated() ? payload : Base64.decodeBase64(payload);
3175             if (decodedPayload.length == 0) {
3176                 log.debug("Failed to decode the payload.");
3177                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
3178                 return Either.right(responseFormat);
3179             }
3180
3181             String checkSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(decodedPayload);
3182             artifactInfo.setArtifactChecksum(checkSum);
3183             log.trace("Calculated checksum, base64 payload: {},  checksum: {}", payload, checkSum);
3184
3185             // Specific payload validations of different types
3186             Either<Boolean, ResponseFormat> isValidPayload = Either.left(true);
3187             if (isDeploymentArtifact(artifactInfo)) {
3188                 log.trace("Starting deployment artifacts payload validation");
3189                 String artifactType = artifactInfo.getArtifactType();
3190                 if (ArtifactTypeEnum.HEAT.getType()
3191                                          .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.HEAT_VOL.getType()
3192                                                                                                      .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.HEAT_NET
3193                         .getType()
3194                         .equalsIgnoreCase(artifactType)
3195                         || ArtifactTypeEnum.HEAT_ENV.getType().equalsIgnoreCase(artifactType)) {
3196                     isValidPayload = validateDeploymentHeatPayload(decodedPayload, artifactType);
3197                     if (isValidPayload.isLeft()) {
3198                         isValidPayload = extractHeatParameters(artifactInfo);
3199                     }
3200                 }
3201                 else if (ArtifactTypeEnum.YANG_XML.getType()
3202                                                   .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.VNF_CATALOG.getType()
3203                                                                                                                  .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.VF_LICENSE
3204                         .getType()
3205                         .equalsIgnoreCase(artifactType)
3206                         || ArtifactTypeEnum.VENDOR_LICENSE.getType()
3207                                                           .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.MODEL_INVENTORY_PROFILE
3208                         .getType()
3209                         .equalsIgnoreCase(artifactType)
3210                         || ArtifactTypeEnum.MODEL_QUERY_SPEC.getType()
3211                                                             .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.UCPE_LAYER_2_CONFIGURATION
3212                         .getType()
3213                         .equalsIgnoreCase(artifactType)) {
3214                     isValidPayload = validateXmlPayload(decodedPayload, artifactType);
3215                 }
3216                 else if (ArtifactTypeEnum.DCAE_INVENTORY_JSON.getType()
3217                                                              .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.DCAE_INVENTORY_TOSCA
3218                         .getType()
3219                         .equalsIgnoreCase(artifactType)
3220                         || ArtifactTypeEnum.VES_EVENTS.getType()
3221                                                       .equalsIgnoreCase(artifactType) || ArtifactTypeEnum.LIFECYCLE_OPERATIONS
3222                         .getType()
3223                         .equalsIgnoreCase(artifactType)) {
3224                     String artifactFileName = artifactInfo.getArtifactName();
3225                     String fileExtension = GeneralUtility.getFilenameExtension(artifactFileName).toLowerCase();
3226                     switch (fileExtension) {
3227                         case "xml":
3228                             isValidPayload = validateXmlPayload(decodedPayload, artifactType);
3229                             break;
3230                         case "json":
3231                             isValidPayload = validateJsonPayload(decodedPayload, artifactType);
3232                             break;
3233                         case "yml":
3234                         case "yaml":
3235                             isValidPayload = validateYmlPayload(decodedPayload, artifactType);
3236                             break;
3237                         default:
3238                             break;
3239                     }
3240                 }
3241             }
3242             if (isValidPayload.isRight()) {
3243                 ResponseFormat responseFormat = isValidPayload.right().value();
3244                 return Either.right(responseFormat);
3245             }
3246
3247         } // null/empty payload is normal if called from metadata update ONLY.
3248         // The validation of whether this is metadata/payload update case is
3249         // currently done separately
3250         else {
3251             if (!isArtifactMetadataUpdate) {
3252                 log.debug("In artifact: {} Payload is missing.",artifactInfo.getArtifactName());
3253                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD);
3254                 return Either.right(responseFormat);
3255             }
3256         }
3257         log.trace("Ended payload handling");
3258         return Either.left(decodedPayload);
3259     }
3260
3261     private Either<Boolean, ResponseFormat> validateDeploymentHeatPayload(byte[] decodedPayload, String artifactType) {
3262         // Basic YAML validation
3263         YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
3264         if (!yamlToObjectConverter.isValidYaml(decodedPayload)) {
3265             log.debug("Invalid YAML format");
3266             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, artifactType);
3267             return Either.right(responseFormat);
3268         }
3269         if (!ArtifactTypeEnum.HEAT_ENV.getType().equalsIgnoreCase(artifactType)) {
3270             // HEAT specific YAML validation
3271             DeploymentArtifactHeatConfiguration heatConfiguration = yamlToObjectConverter.convert(decodedPayload, DeploymentArtifactHeatConfiguration.class);
3272             if (heatConfiguration == null || heatConfiguration.getHeat_template_version() == null) {
3273                 log.debug("HEAT doesn't contain required \"heat_template_version\" section.");
3274                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, artifactType);
3275                 return Either.right(responseFormat);
3276             }
3277         }
3278
3279         return Either.left(true);
3280     }
3281
3282     private Either<Boolean, ResponseFormat> validateYmlPayload(byte[] decodedPayload, String artifactType) {
3283         Either<Boolean, ResponseFormat> res = Either.left(true);
3284         YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
3285         if (!yamlToObjectConverter.isValidYaml(decodedPayload)) {
3286             log.debug("Invalid YAML format");
3287             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, artifactType);
3288             res = Either.right(responseFormat);
3289         }
3290
3291         return res;
3292     }
3293
3294     private Either<Boolean, ResponseFormat> validateXmlPayload(byte[] payload, String artifactType) {
3295         boolean isXmlValid = isValidXml(payload);
3296         if (!isXmlValid) {
3297             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
3298                                                                  .getResponseFormat(ActionStatus.INVALID_XML, artifactType);
3299             log.debug("Invalid XML content");
3300             return Either.right(responseFormat);
3301         }
3302         return Either.left(true);
3303     }
3304
3305     private Either<Boolean, ResponseFormat> validateJsonPayload(byte[] payload, String type) {
3306         boolean isJsonValid = isValidJson(payload);
3307         if (!isJsonValid) {
3308             ResponseFormat responseFormat = ResponseFormatManager.getInstance()
3309                                                                  .getResponseFormat(ActionStatus.INVALID_JSON, type);
3310             log.debug("Invalid JSON content");
3311             return Either.right(responseFormat);
3312         }
3313         return Either.left(true);
3314     }
3315
3316     public Either<Operation, ResponseFormat> deleteArtifactByInterface(String resourceId, String userUserId, String artifactId,
3317                                                                        boolean inTransaction) {
3318         User user = new User();
3319         user.setUserId(userUserId);
3320         Either<Resource, StorageOperationStatus> parent = toscaOperationFacade.getToscaElement(resourceId, JsonParseFlagEnum.ParseMetadata);
3321         if (parent.isRight()) {
3322             ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(parent
3323                     .right()
3324                     .value()));
3325             return Either.right(responseFormat);
3326         }
3327         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = handleDelete(resourceId, artifactId, user, AuditingActionEnum.ARTIFACT_DELETE, ComponentTypeEnum.RESOURCE, parent
3328                         .left()
3329                         .value(),
3330                 false, inTransaction);
3331         if (handleDelete.isRight()) {
3332             return Either.right(handleDelete.right().value());
3333         }
3334         Either<ArtifactDefinition, Operation> result = handleDelete.left().value();
3335         return Either.left(result.right().value());
3336
3337     }
3338
3339     private Operation convertToOperation(ArtifactDefinition artifactInfo, String operationName) {
3340         Operation op = new Operation();
3341         long time = System.currentTimeMillis();
3342         op.setCreationDate(time);
3343
3344         String artifactName = artifactInfo.getArtifactName();
3345         artifactInfo.setArtifactName(createInterfaceArtifactNameFromOperation(operationName, artifactName));
3346
3347         op.setImplementation(artifactInfo);
3348         op.setLastUpdateDate(time);
3349         return op;
3350     }
3351
3352     private String createInterfaceArtifactNameFromOperation(String operationName, String artifactName) {
3353         String newArtifactName = operationName + "_" + artifactName;
3354         log.trace("converting artifact name {} to {}", artifactName, newArtifactName);
3355         return newArtifactName;
3356     }
3357
3358     // download by MSO
3359     public Either<byte[], ResponseFormat> downloadRsrcArtifactByNames(String serviceName, String serviceVersion, String resourceName, String resourceVersion, String artifactName) {
3360
3361         // General validation
3362         if (serviceName == null || serviceVersion == null || resourceName == null || resourceVersion == null || artifactName == null) {
3363             log.debug(NULL_PARAMETER);
3364             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3365         }
3366
3367         // Normalizing artifact name
3368         artifactName = ValidationUtils.normalizeFileName(artifactName);
3369
3370         // Resource validation
3371         Either<Resource, ResponseFormat> validateResourceNameAndVersion = validateResourceNameAndVersion(resourceName, resourceVersion);
3372         if (validateResourceNameAndVersion.isRight()) {
3373             return Either.right(validateResourceNameAndVersion.right().value());
3374         }
3375
3376         Resource resource = validateResourceNameAndVersion.left().value();
3377         String resourceId = resource.getUniqueId();
3378
3379         // Service validation
3380         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3381         if (validateServiceNameAndVersion.isRight()) {
3382             return Either.right(validateServiceNameAndVersion.right().value());
3383         }
3384
3385         Map<String, ArtifactDefinition> artifacts = resource.getDeploymentArtifacts();
3386         if (artifacts == null || artifacts.isEmpty()) {
3387             log.debug("Deployment artifacts of resource {} are not found", resourceId);
3388             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3389         }
3390
3391         ArtifactDefinition deploymentArtifact = null;
3392
3393         for (ArtifactDefinition artifactDefinition : artifacts.values()) {
3394             if (artifactDefinition.getArtifactName() != null && artifactDefinition.getArtifactName()
3395                                                                                   .equals(artifactName)) {
3396                 log.debug(FOUND_DEPLOYMENT_ARTIFACT, artifactName);
3397                 deploymentArtifact = artifactDefinition;
3398                 break;
3399             }
3400         }
3401
3402         if (deploymentArtifact == null) {
3403             log.debug("No deployment artifact {} was found for resource {}", artifactName, resourceId);
3404             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3405         }
3406
3407         // Downloading the artifact
3408         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(deploymentArtifact);
3409         if (downloadArtifactEither.isRight()) {
3410             log.debug(FAILED_DOWNLOAD_ARTIFACT, artifactName);
3411             return Either.right(downloadArtifactEither.right().value());
3412         }
3413         log.trace("Download of resource artifact succeeded, uniqueId {}", deploymentArtifact.getUniqueId());
3414         return Either.left(downloadArtifactEither.left().value().getRight());
3415     }
3416
3417     // download by MSO
3418     public Either<byte[], ResponseFormat> downloadRsrcInstArtifactByNames(String serviceName, String serviceVersion, String resourceInstanceName, String artifactName) {
3419
3420         // General validation
3421         if (serviceName == null || serviceVersion == null || resourceInstanceName == null || artifactName == null) {
3422             log.debug(NULL_PARAMETER);
3423             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3424         }
3425
3426         // Normalizing artifact name
3427         artifactName = ValidationUtils.normalizeFileName(artifactName);
3428
3429         // Service validation
3430         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3431         if (validateServiceNameAndVersion.isRight()) {
3432             return Either.right(validateServiceNameAndVersion.right().value());
3433         }
3434
3435         Service service = validateServiceNameAndVersion.left().value();
3436
3437         // ResourceInstance validation
3438         Either<ComponentInstance, ResponseFormat> validateResourceInstance = validateResourceInstance(service, resourceInstanceName);
3439         if (validateResourceInstance.isRight()) {
3440             return Either.right(validateResourceInstance.right().value());
3441         }
3442
3443         ComponentInstance resourceInstance = validateResourceInstance.left().value();
3444
3445         Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
3446
3447         final String finalArtifactName = artifactName;
3448         Predicate<ArtifactDefinition> filterArtifactByName = p -> p.getArtifactName().equals(finalArtifactName);
3449
3450         boolean hasDeploymentArtifacts = artifacts != null && artifacts.values()
3451                                                                        .stream()
3452                                                                        .anyMatch(filterArtifactByName);
3453         ArtifactDefinition deployableArtifact;
3454
3455         if (!hasDeploymentArtifacts) {
3456             log.debug("Deployment artifact with name {} not found", artifactName);
3457             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactName));
3458         }
3459
3460         log.debug(FOUND_DEPLOYMENT_ARTIFACT, artifactName);
3461         deployableArtifact = artifacts.values().stream().filter(filterArtifactByName).findFirst().get();
3462         // Downloading the artifact
3463         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(deployableArtifact);
3464
3465         if (downloadArtifactEither.isRight()) {
3466             log.debug(FAILED_DOWNLOAD_ARTIFACT, artifactName);
3467             return Either.right(downloadArtifactEither.right().value());
3468         }
3469         log.trace("Download of resource artifact succeeded, uniqueId {}", deployableArtifact.getUniqueId());
3470         return Either.left(downloadArtifactEither.left().value().getRight());
3471     }
3472
3473     private Either<ComponentInstance, ResponseFormat> validateResourceInstance(Service service, String resourceInstanceName) {
3474
3475         List<ComponentInstance> riList = service.getComponentInstances();
3476         for (ComponentInstance ri : riList) {
3477             if (ri.getNormalizedName().equals(resourceInstanceName)) {
3478                 return Either.left(ri);
3479             }
3480         }
3481
3482         return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND, resourceInstanceName));
3483     }
3484
3485     private Either<Service, ResponseFormat> validateServiceNameAndVersion(String serviceName, String serviceVersion) {
3486
3487         Either<List<Service>, StorageOperationStatus> serviceListBySystemName = toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName);
3488         if (serviceListBySystemName.isRight()) {
3489             log.debug("Couldn't fetch any service with name {}", serviceName);
3490             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceListBySystemName
3491                     .right()
3492                     .value(), ComponentTypeEnum.SERVICE), serviceName));
3493         }
3494         List<Service> serviceList = serviceListBySystemName.left().value();
3495         if (serviceList == null || serviceList.isEmpty()) {
3496             log.debug("Couldn't fetch any service with name {}", serviceName);
3497             return Either.right(componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceName));
3498         }
3499
3500         Service foundService = null;
3501         for (Service service : serviceList) {
3502             if (service.getVersion().equals(serviceVersion)) {
3503                 log.trace("Found service with version {}", serviceVersion);
3504                 foundService = service;
3505                 break;
3506             }
3507         }
3508
3509         if (foundService == null) {
3510             log.debug("Couldn't find version {} for service {}", serviceVersion, serviceName);
3511             return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_VERSION_NOT_FOUND, ComponentTypeEnum.SERVICE
3512                     .getValue(), serviceVersion));
3513         }
3514         return Either.left(foundService);
3515     }
3516
3517     private Either<Resource, ResponseFormat> validateResourceNameAndVersion(String resourceName, String resourceVersion) {
3518
3519         Either<Resource, StorageOperationStatus> resourceListBySystemName = toscaOperationFacade.getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion, JsonParseFlagEnum.ParseMetadata);
3520         if (resourceListBySystemName.isRight()) {
3521             log.debug("Couldn't fetch any resource with name {} and version {}. ", resourceName, resourceVersion);
3522             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceListBySystemName
3523                     .right()
3524                     .value()), resourceName));
3525         }
3526         return Either.left(resourceListBySystemName.left().value());
3527     }
3528
3529     public Either<byte[], ResponseFormat> downloadServiceArtifactByNames(String serviceName, String serviceVersion, String artifactName) {
3530         // Validation
3531         log.trace("Starting download of service interface artifact, serviceName {}, serviceVersion {}, artifact name {}", serviceName, serviceVersion, artifactName);
3532         if (serviceName == null || serviceVersion == null || artifactName == null) {
3533             log.debug(NULL_PARAMETER);
3534             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
3535         }
3536
3537         // Normalizing artifact name
3538         final String normalizedArtifactName = ValidationUtils.normalizeFileName(artifactName);
3539
3540         // Service validation
3541         Either<Service, ResponseFormat> validateServiceNameAndVersion = validateServiceNameAndVersion(serviceName, serviceVersion);
3542         if (validateServiceNameAndVersion.isRight()) {
3543             return Either.right(validateServiceNameAndVersion.right().value());
3544         }
3545
3546         String serviceId = validateServiceNameAndVersion.left().value().getUniqueId();
3547
3548         // Looking for deployment or tosca artifacts
3549         Service service = validateServiceNameAndVersion.left().value();
3550
3551         if (MapUtils.isEmpty(service.getDeploymentArtifacts()) && MapUtils.isEmpty(service.getToscaArtifacts())) {
3552             log.debug("Neither Deployment nor Tosca artifacts of service {} are found", serviceId);
3553             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, normalizedArtifactName));
3554         }
3555
3556         Optional<ArtifactDefinition> foundArtifactOptl = null;
3557
3558         if (!MapUtils.isEmpty(service.getDeploymentArtifacts())) {
3559             foundArtifactOptl = service.getDeploymentArtifacts().values().stream()
3560                                        // filters artifact by name
3561                                        .filter(a -> a.getArtifactName().equals(normalizedArtifactName)).findAny();
3562         }
3563         if ((foundArtifactOptl == null || !foundArtifactOptl.isPresent()) && !MapUtils.isEmpty(service.getToscaArtifacts())) {
3564             foundArtifactOptl = service.getToscaArtifacts().values().stream()
3565                                        // filters TOSCA artifact by name
3566                                        .filter(a -> a.getArtifactName().equals(normalizedArtifactName)).findAny();
3567         }
3568         if (!foundArtifactOptl.isPresent()) {
3569             log.debug("The artifact {} was not found for service {}", normalizedArtifactName, serviceId);
3570             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, normalizedArtifactName));
3571         }
3572         log.debug(FOUND_DEPLOYMENT_ARTIFACT, normalizedArtifactName);
3573         // Downloading the artifact
3574         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = downloadArtifact(foundArtifactOptl
3575                 .get());
3576         if (downloadArtifactEither.isRight()) {
3577             log.debug(FAILED_DOWNLOAD_ARTIFACT, normalizedArtifactName);
3578             return Either.right(downloadArtifactEither.right().value());
3579         }
3580         log.trace("Download of service artifact succeeded, uniqueId {}", foundArtifactOptl.get().getUniqueId());
3581         return Either.left(downloadArtifactEither.left().value().getRight());
3582     }
3583
3584     public Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifact(String parentId, String artifactUniqueId) {
3585         log.trace("Starting download of artifact, uniqueId {}", artifactUniqueId);
3586         Either<ArtifactDefinition, StorageOperationStatus> artifactById = artifactToscaOperation.getArtifactById(parentId, artifactUniqueId);
3587         if (artifactById.isRight()) {
3588             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(artifactById.right().value());
3589             log.debug("Error when getting artifact info by id{}, error: {}", artifactUniqueId, actionStatus);
3590             return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, ""));
3591         }
3592         ArtifactDefinition artifactDefinition = artifactById.left().value();
3593         if (artifactDefinition == null) {
3594             log.debug("Empty artifact definition returned from DB by artifact id {}", artifactUniqueId);
3595             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, ""));
3596         }
3597
3598         return downloadArtifact(artifactDefinition);
3599     }
3600
3601     private boolean checkArtifactInComponent(org.openecomp.sdc.be.model.Component component, String artifactId) {
3602         boolean found = false;
3603         Map<String, ArtifactDefinition> artifactsS = component.getArtifacts();
3604         if (artifactsS != null) {
3605             for (Map.Entry<String, ArtifactDefinition> entry : artifactsS.entrySet()) {
3606                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3607                     found = true;
3608                     break;
3609                 }
3610             }
3611         }
3612         Map<String, ArtifactDefinition> deploymentArtifactsS = component.getDeploymentArtifacts();
3613         if (!found && deploymentArtifactsS != null) {
3614             for (Map.Entry<String, ArtifactDefinition> entry : deploymentArtifactsS.entrySet()) {
3615                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3616                     found = true;
3617                     break;
3618                 }
3619             }
3620         }
3621         Map<String, ArtifactDefinition> toscaArtifactsS = component.getToscaArtifacts();
3622         if (!found && toscaArtifactsS != null) {
3623             for (Map.Entry<String, ArtifactDefinition> entry : toscaArtifactsS.entrySet()) {
3624                 if (entry.getValue().getUniqueId().equals(artifactId)) {
3625                     found = true;
3626                     break;
3627                 }
3628             }
3629         }
3630
3631         Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
3632         if (!found && interfaces != null) {
3633             for (Map.Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
3634                 Map<String, Operation> operations = entry.getValue().getOperationsMap();
3635                 for (Map.Entry<String, Operation> entryOp : operations.entrySet()) {
3636                     if (entryOp.getValue().getImplementation() != null && entryOp.getValue()
3637                             .getImplementation()
3638                             .getUniqueId()
3639                             .equals(artifactId)) {
3640                         found = true;
3641                         break;
3642                     }
3643                 }
3644             }
3645         }
3646
3647         switch (component.getComponentType()) {
3648             case RESOURCE:
3649                 break;
3650             case SERVICE:
3651                 Map<String, ArtifactDefinition> apiArtifacts = ((Service) component).getServiceApiArtifacts();
3652                 if (!found && apiArtifacts != null) {
3653                     for (Map.Entry<String, ArtifactDefinition> entry : apiArtifacts.entrySet()) {
3654                         if (entry.getValue().getUniqueId().equals(artifactId)) {
3655                             found = true;
3656                             break;
3657                         }
3658                     }
3659                 }
3660                 break;
3661             default:
3662
3663         }
3664
3665         return found;
3666     }
3667
3668     private boolean checkArtifactInResourceInstance(Component component, String resourceInstanceId, String artifactId) {
3669
3670         boolean found = false;
3671         List<ComponentInstance> resourceInstances = component.getComponentInstances();
3672         ComponentInstance resourceInstance = null;
3673         for (ComponentInstance ri : resourceInstances) {
3674             if (ri.getUniqueId().equals(resourceInstanceId)) {
3675                 resourceInstance = ri;
3676                 break;
3677             }
3678         }
3679         if (resourceInstance != null) {
3680             Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
3681             if (artifacts != null) {
3682                 for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
3683                     if (entry.getValue().getUniqueId().equals(artifactId)) {
3684                         found = true;
3685                         break;
3686                     }
3687                 }
3688             }
3689             if (!found) {
3690                 artifacts = resourceInstance.getArtifacts();
3691                 if (artifacts != null) {
3692                     for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
3693                         if (entry.getValue().getUniqueId().equals(artifactId)) {
3694                             found = true;
3695                             break;
3696                         }
3697                     }
3698                 }
3699             }
3700         }
3701         return found;
3702     }
3703
3704     private Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists(String componentId, AuditingActionEnum auditingAction, User user, String artifactId, ComponentTypeEnum componentType,
3705                                                                                                            String containerComponentType) {
3706
3707         ComponentTypeEnum componentForAudit = null == containerComponentType ? componentType : ComponentTypeEnum.findByParamName(containerComponentType);
3708         componentForAudit.getNodeType();
3709
3710         Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentResult = toscaOperationFacade
3711                 .getToscaFullElement(componentId);
3712
3713         if (componentResult.isRight()) {
3714             ActionStatus status = componentForAudit == ComponentTypeEnum.RESOURCE ? ActionStatus.RESOURCE_NOT_FOUND : componentType == ComponentTypeEnum.SERVICE ? ActionStatus.SERVICE_NOT_FOUND : ActionStatus.PRODUCT_NOT_FOUND;
3715             ResponseFormat responseFormat = componentsUtils.getResponseFormat(status, componentId);
3716             log.debug("Service not found, serviceId {}", componentId);
3717             handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentForAudit, null);
3718             return Either.right(responseFormat);
3719         }
3720         return Either.left(componentResult.left().value());
3721     }
3722
3723     private Either<Boolean, ResponseFormat> validateWorkOnComponent(Component component, String userId, AuditingActionEnum auditingAction, User user, String artifactId, ArtifactOperationInfo operation) {
3724         if (operation.getArtifactOperationEnum() != ArtifactOperationEnum.DOWNLOAD && !operation.ignoreLifecycleState()) {
3725             Either<Boolean, ResponseFormat> canWork = validateCanWorkOnComponent(component, userId);
3726             if (canWork.isRight()) {
3727                 String uniqueId = component.getUniqueId();
3728                 log.debug("Service status isn't  CHECKOUT or user isn't owner, serviceId {}", uniqueId);
3729                 handleAuditing(auditingAction, component, uniqueId, user, null, null, artifactId, canWork.right()
3730                                                                                                          .value(), component
3731                         .getComponentType(), null);
3732                 return Either.right(canWork.right().value());
3733             }
3734         }
3735         return Either.left(true);
3736     }
3737
3738     private Either<Boolean, ResponseFormat> validateUserRole(User user, AuditingActionEnum auditingAction, String componentId, String artifactId, ComponentTypeEnum componentType, ArtifactOperationInfo operation) {
3739
3740         if (operation.getArtifactOperationEnum() != ArtifactOperationEnum.DOWNLOAD) {
3741             String role = user.getRole();
3742             if (!role.equals(Role.ADMIN.name()) && !role.equals(Role.DESIGNER.name())) {
3743                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
3744                 log.debug("addArtifact - user isn't permitted to perform operation, userId {}, role {}", user.getUserId(), role);
3745                 handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentType, null);
3746                 return Either.right(responseFormat);
3747             }
3748         }
3749         return Either.left(true);
3750     }
3751
3752     private Either<User, ResponseFormat> validateUserExists(String userId, AuditingActionEnum auditingAction, String componentId, String artifactId, ComponentTypeEnum componentType, boolean inTransaction) {
3753         User user;
3754         try{
3755             user = validateUserExists(userId, auditingAction.getName(), inTransaction);
3756         } catch(ComponentException e){
3757             user = new User();
3758             user.setUserId(userId);
3759             ResponseFormat responseFormat = e.getResponseFormat() != null ? e.getResponseFormat() :
3760                     componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
3761             handleAuditing(auditingAction, null, componentId, user, null, null, artifactId, responseFormat, componentType, null);
3762             throw e;
3763         }
3764         return Either.left(user);
3765     }
3766
3767     protected AuditingActionEnum detectAuditingType(ArtifactOperationInfo operation, String origMd5) {
3768         AuditingActionEnum auditingAction = null;
3769         switch (operation.getArtifactOperationEnum()) {
3770             case CREATE:
3771                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_UPLOAD_BY_API : AuditingActionEnum.ARTIFACT_UPLOAD;
3772                 break;
3773             case UPDATE:
3774                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_UPLOAD_BY_API : origMd5 == null ? AuditingActionEnum.ARTIFACT_METADATA_UPDATE : AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE;
3775                 break;
3776             case DELETE:
3777                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.ARTIFACT_DELETE_BY_API : AuditingActionEnum.ARTIFACT_DELETE;
3778                 break;
3779             case DOWNLOAD:
3780                 auditingAction = operation.isExternalApi() ? AuditingActionEnum.DOWNLOAD_ARTIFACT : AuditingActionEnum.ARTIFACT_DOWNLOAD;
3781                 break;
3782             default:
3783                 break;
3784         }
3785         return auditingAction;
3786     }
3787
3788     private Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifact(ArtifactDefinition artifactDefinition) {
3789         String esArtifactId = artifactDefinition.getEsId();
3790         Either<ESArtifactData, CassandraOperationStatus> artifactfromES = artifactCassandraDao.getArtifact(esArtifactId);
3791         if (artifactfromES.isRight()) {
3792             CassandraOperationStatus resourceUploadStatus = artifactfromES.right().value();
3793             StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
3794             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
3795             log.debug("Error when getting artifact from ES, error: {}", actionStatus);
3796             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(actionStatus, artifactDefinition
3797                     .getArtifactDisplayName());
3798
3799             return Either.right(responseFormat);
3800         }
3801
3802         ESArtifactData esArtifactData = artifactfromES.left().value();
3803         byte[] data = esArtifactData.getDataAsArray();
3804         if (data == null) {
3805             log.debug("Artifact data from ES is null");
3806             return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactDefinition.getArtifactDisplayName()));
3807         }
3808         String artifactName = artifactDefinition.getArtifactName();
3809         log.trace("Download of artifact succeeded, uniqueId {}, artifact file name {}", artifactDefinition.getUniqueId(), artifactName);
3810         return Either.left(new ImmutablePair<String, byte[]>(artifactName, data));
3811     }
3812
3813     public ESArtifactData createEsArtifactData(ArtifactDataDefinition artifactInfo, byte[] artifactPayload) {
3814         return new ESArtifactData(artifactInfo.getEsId(), artifactPayload);
3815     }
3816
3817     private boolean saveArtifacts(ESArtifactData artifactData, String resourceId) {
3818         CassandraOperationStatus resourceUploadStatus = artifactCassandraDao.saveArtifact(artifactData);
3819
3820         if (resourceUploadStatus.equals(CassandraOperationStatus.OK)) {
3821             log.debug("Artifact {} was saved in component .", artifactData.getId(), resourceId);
3822         }
3823         else {
3824             log.info("Failed to save artifact {}.", artifactData.getId());
3825             return false;
3826         }
3827         return true;
3828     }
3829
3830     private boolean isArtifactMetadataUpdate(AuditingActionEnum auditingActionEnum) {
3831         return auditingActionEnum.equals(AuditingActionEnum.ARTIFACT_METADATA_UPDATE);
3832     }
3833
3834     private boolean isDeploymentArtifact(ArtifactDefinition artifactInfo) {
3835         return ArtifactGroupTypeEnum.DEPLOYMENT.equals(artifactInfo.getArtifactGroupType());
3836     }
3837
3838     public Either<ArtifactDefinition, ResponseFormat> createArtifactPlaceHolderInfo(String resourceId, String logicalName, Map<String, Object> artifactInfoMap, String userUserId, ArtifactGroupTypeEnum groupType, boolean inTransaction) {
3839         Either<User, ActionStatus> user = userAdminManager.getUser(userUserId, inTransaction);
3840         if (user.isRight()) {
3841             ResponseFormat responseFormat;
3842             if (user.right().value().equals(ActionStatus.USER_NOT_FOUND)) {
3843                 log.debug("create artifact placeholder - not authorized user, userId {}", userUserId);
3844                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
3845             }
3846             else {
3847                 log.debug("create artifact placeholder - failed to authorize user, userId {}", userUserId);
3848                 responseFormat = componentsUtils.getResponseFormat(user.right().value());
3849             }
3850             return Either.right(responseFormat);
3851         }
3852
3853         ArtifactDefinition artifactDefinition = createArtifactPlaceHolderInfo(resourceId, logicalName, artifactInfoMap, user
3854                 .left()
3855                 .value(), groupType);
3856         return Either.left(artifactDefinition);
3857     }
3858
3859     public ArtifactDefinition createArtifactPlaceHolderInfo(String resourceId, String logicalName, Map<String, Object> artifactInfoMap, User user, ArtifactGroupTypeEnum groupType) {
3860         ArtifactDefinition artifactInfo = new ArtifactDefinition();
3861
3862         String artifactName = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_DISPLAY_NAME);
3863         String artifactType = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_TYPE);
3864         String artifactDescription = (String) artifactInfoMap.get(ARTIFACT_PLACEHOLDER_DESCRIPTION);
3865
3866         artifactInfo.setArtifactDisplayName(artifactName);
3867         artifactInfo.setArtifactLabel(logicalName.toLowerCase());
3868         artifactInfo.setArtifactType(artifactType);
3869         artifactInfo.setDescription(artifactDescription);
3870         artifactInfo.setArtifactGroupType(groupType);
3871         nodeTemplateOperation.setDefaultArtifactTimeout(groupType, artifactInfo);
3872
3873         setArtifactPlaceholderCommonFields(resourceId, user, artifactInfo);
3874
3875         return artifactInfo;
3876     }
3877
3878     private void setArtifactPlaceholderCommonFields(String resourceId, User user, ArtifactDefinition artifactInfo) {
3879         String uniqueId = null;
3880
3881         if (resourceId != null) {
3882             uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId.toLowerCase(), artifactInfo.getArtifactLabel()
3883                                                                                                    .toLowerCase());
3884             artifactInfo.setUniqueId(uniqueId);
3885         }
3886         artifactInfo.setUserIdCreator(user.getUserId());
3887         String fullName = user.getFullName();
3888         artifactInfo.setUpdaterFullName(fullName);
3889
3890         long time = System.currentTimeMillis();
3891
3892         artifactInfo.setCreatorFullName(fullName);
3893         artifactInfo.setCreationDate(time);
3894
3895         artifactInfo.setLastUpdateDate(time);
3896         artifactInfo.setUserIdLastUpdater(user.getUserId());
3897
3898         artifactInfo.setMandatory(true);
3899     }
3900
3901     public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) {
3902         return artifactToscaOperation.getArtifacts(parentId, parentType, groupType, instanceId);
3903     }
3904
3905     public Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifact, String componentId, NodeTypeEnum parentType, String instanceId) {
3906         return artifactToscaOperation.addHeatEnvArtifact(artifactHeatEnv, artifact, componentId, parentType, true, instanceId);
3907     }
3908
3909     private Either<ESArtifactData, ResponseFormat> createEsHeatEnvArtifactDataFromString(ArtifactDefinition artifactDefinition, String payloadStr) {
3910
3911         byte[] payload = payloadStr.getBytes();
3912
3913         ESArtifactData artifactData = createEsArtifactData(artifactDefinition, payload);
3914         return Either.left(artifactData);
3915     }
3916
3917     /**
3918      * @param artifactDefinition
3919      * @return
3920      */
3921     public Either<ArtifactDefinition, ResponseFormat> generateHeatEnvArtifact(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
3922                                                                               String instanceId, boolean shouldLock, boolean inTransaction) {
3923         String payload = generateHeatEnvPayload(artifactDefinition);
3924         String prevUUID = artifactDefinition.getArtifactUUID();
3925         ArtifactDefinition clonedBeforeGenerate = new ArtifactDefinition(artifactDefinition);
3926         return generateAndSaveHeatEnvArtifact(artifactDefinition, payload, componentType, component, resourceInstanceName, modifier, instanceId, shouldLock, inTransaction)
3927                 .left()
3928                 .bind(artifactDef -> updateArtifactOnGroupInstance(componentType, component, instanceId, prevUUID, clonedBeforeGenerate, artifactDef));
3929     }
3930
3931     public Either<ArtifactDefinition, ResponseFormat> forceGenerateHeatEnvArtifact(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
3932                                                                                    boolean shouldLock, boolean inTransaction, String instanceId) {
3933         String payload = generateHeatEnvPayload(artifactDefinition);
3934         String prevUUID = artifactDefinition.getArtifactUUID();
3935         ArtifactDefinition clonedBeforeGenerate = new ArtifactDefinition(artifactDefinition);
3936         return forceGenerateAndSaveHeatEnvArtifact(artifactDefinition, payload, componentType, component, resourceInstanceName, modifier, instanceId, shouldLock, inTransaction)
3937                 .left()
3938                 .bind(artifactDef -> updateArtifactOnGroupInstance(componentType, component, instanceId, prevUUID, clonedBeforeGenerate, artifactDef));
3939     }
3940
3941     private Either<ArtifactDefinition, ResponseFormat> updateArtifactOnGroupInstance(ComponentTypeEnum componentType, Component component, String instanceId, String prevUUID, ArtifactDefinition clonedBeforeGenerate, ArtifactDefinition updatedArtDef) {
3942         if (prevUUID == null || !prevUUID.equals(updatedArtDef.getArtifactUUID())) {
3943             List<ComponentInstance> componentInstances = component.getComponentInstances();
3944             if (componentInstances != null) {
3945                 Optional<ComponentInstance> findFirst = componentInstances.stream()
3946                                                                           .filter(ci -> ci.getUniqueId()
3947                                                                                           .equals(instanceId))
3948                                                                           .findFirst();
3949                 if (findFirst.isPresent()) {
3950                     ComponentInstance relevantInst = findFirst.get();
3951                     List<GroupInstance> updatedGroupInstances = getUpdatedGroupInstances(updatedArtDef.getUniqueId(), clonedBeforeGenerate, relevantInst
3952                             .getGroupInstances());
3953
3954                     if (CollectionUtils.isNotEmpty(updatedGroupInstances)) {
3955                         updatedGroupInstances.forEach(gi -> {
3956                             gi.getGroupInstanceArtifacts().add(updatedArtDef.getUniqueId());
3957                             gi.getGroupInstanceArtifactsUuid().add(updatedArtDef.getArtifactUUID());
3958                         });
3959                         Either<List<GroupInstance>, StorageOperationStatus> status = toscaOperationFacade.updateGroupInstancesOnComponent(component, instanceId, updatedGroupInstances);
3960                         if (status.isRight()) {
3961                             log.debug(FAILED_UPDATE_GROUPS, component.getUniqueId());
3962                             ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils
3963                                     .convertFromStorageResponse(status.right()
3964                                                                       .value()), clonedBeforeGenerate.getArtifactDisplayName());
3965                             return Either.right(responseFormat);
3966                         }
3967                     }
3968                 }
3969             }
3970         }
3971         return Either.left(updatedArtDef);
3972     }
3973
3974     private String generateHeatEnvPayload(ArtifactDefinition artifactDefinition) {
3975         List<HeatParameterDefinition> heatParameters = artifactDefinition.getListHeatParameters();
3976         StringBuilder sb = new StringBuilder();
3977         sb.append(ConfigurationManager.getConfigurationManager().getConfiguration().getHeatEnvArtifactHeader());
3978         sb.append("parameters:\n");
3979         if (heatParameters != null) {
3980             heatParameters.sort(Comparator.comparing(e -> e.getName()));
3981
3982             List<HeatParameterDefinition> empltyHeatValues = new ArrayList<>();
3983
3984             for (HeatParameterDefinition heatParameterDefinition : heatParameters) {
3985
3986                 String heatValue = heatParameterDefinition.getCurrentValue();
3987                 if (!ValidationUtils.validateStringNotEmpty(heatValue)) {
3988                     heatValue = heatParameterDefinition.getDefaultValue();
3989                     if (!ValidationUtils.validateStringNotEmpty(heatValue)) {
3990                         empltyHeatValues.add(heatParameterDefinition);
3991                         continue;
3992                     }
3993                 }
3994                 HeatParameterType type = HeatParameterType.isValidType(heatParameterDefinition.getType());
3995                 if (type != null) {
3996                     switch (type) {
3997                         case BOOLEAN:
3998                             sb.append("  ")
3999                               .append(heatParameterDefinition.getName())
4000                               .append(":")
4001                               .append(" ")
4002                               .append(Boolean.parseBoolean(heatValue))
4003                               .append("\n");
4004                             break;
4005                         case NUMBER:
4006                             sb.append("  ")
4007                               .append(heatParameterDefinition.getName())
4008                               .append(":")
4009                               .append(" ")
4010                               .append(new BigDecimal(heatValue).toPlainString())
4011                               .append("\n");
4012                             break;
4013                         case COMMA_DELIMITED_LIST:
4014                         case JSON:
4015                             sb.append("  ")
4016                               .append(heatParameterDefinition.getName())
4017                               .append(":")
4018                               .append(" ")
4019                               .append(heatValue)
4020                               .append("\n");
4021                             break;
4022                         default:
4023                             String value = heatValue;
4024                             boolean starts = value.startsWith("\"");
4025                             boolean ends = value.endsWith("\"");
4026                             if (!(starts && ends)) {
4027                                 starts = value.startsWith("'");
4028                                 ends = value.endsWith("'");
4029                                 if (!(starts && ends)) {
4030                                     value = "\"" + value + "\"";
4031                                 }
4032                             }
4033                             sb.append("  ")
4034                               .append(heatParameterDefinition.getName())
4035                               .append(":")
4036                               .append(" ")
4037                               .append(value);
4038                             sb.append("\n");
4039                             break;
4040
4041                     }
4042                 }
4043             }
4044             if (!empltyHeatValues.isEmpty()) {
4045                 empltyHeatValues.sort(Comparator.comparing(e -> e.getName()));
4046                 empltyHeatValues.forEach(hv -> {
4047                     sb.append("  ").append(hv.getName()).append(":");
4048                     HeatParameterType type = HeatParameterType.isValidType(hv.getType());
4049                     if (type != null && type == HeatParameterType.STRING && (hv.getCurrentValue() != null && "".equals(hv
4050                             .getCurrentValue()) || hv.getDefaultValue() != null && "".equals(hv.getDefaultValue()))) {
4051                         sb.append(" \"\"").append("\n");
4052                     }
4053                     else {
4054                         sb.append(" ").append("\n");
4055                     }
4056                 });
4057             }
4058         }
4059         sb.append(ConfigurationManager.getConfigurationManager().getConfiguration().getHeatEnvArtifactFooter());
4060
4061         // DE265919 fix
4062         return sb.toString().replaceAll("\\\\n", "\n");
4063     }
4064
4065     /**
4066      * @param artifactDefinition
4067      * @param payload
4068      * @return
4069      */
4070     public Either<ArtifactDefinition, ResponseFormat> generateAndSaveHeatEnvArtifact(ArtifactDefinition artifactDefinition, String payload, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName,
4071                                                                                      User modifier, String instanceId, boolean shouldLock, boolean inTransaction) {
4072         return generateArtifactPayload(artifactDefinition, componentType, component, resourceInstanceName, modifier, shouldLock, inTransaction, () -> artifactDefinition
4073                         .getHeatParamsUpdateDate(),
4074                 () -> createEsHeatEnvArtifactDataFromString(artifactDefinition, payload), instanceId);
4075
4076     }
4077
4078     public Either<ArtifactDefinition, ResponseFormat> forceGenerateAndSaveHeatEnvArtifact(ArtifactDefinition artifactDefinition, String payload, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName,
4079                                                                                           User modifier, String instanceId, boolean shouldLock, boolean inTransaction) {
4080         return generateArtifactPayload(artifactDefinition, componentType, component, resourceInstanceName, modifier, shouldLock, inTransaction, System::currentTimeMillis,
4081                 () -> createEsHeatEnvArtifactDataFromString(artifactDefinition, payload), instanceId);
4082
4083     }
4084
4085     protected Either<ArtifactDefinition, ResponseFormat> generateArtifactPayload(ArtifactDefinition artifactDefinition, ComponentTypeEnum componentType, org.openecomp.sdc.be.model.Component component, String resourceInstanceName, User modifier,
4086                                                                                  boolean shouldLock, boolean inTransaction, Supplier<Long> payloadUpdateDateGen, Supplier<Either<ESArtifactData, ResponseFormat>> esDataCreator, String instanceId) {
4087
4088         log.trace("Start generating payload for {} artifact {}", artifactDefinition.getArtifactType(), artifactDefinition
4089                 .getEsId());
4090         if (artifactDefinition.getPayloadUpdateDate() == null || artifactDefinition.getPayloadUpdateDate() == 0 || artifactDefinition
4091                 .getPayloadUpdateDate() <= payloadUpdateDateGen.get()) {
4092
4093             log.trace("Generating payload for {} artifact {}", artifactDefinition.getArtifactType(), artifactDefinition.getEsId());
4094             Either<ESArtifactData, ResponseFormat> artifactDataRes = esDataCreator.get();
4095             ESArtifactData artifactData = null;
4096
4097             if (artifactDataRes.isLeft()) {
4098                 artifactData = artifactDataRes.left().value();
4099             }
4100             else {
4101                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4102                 handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4103                                 .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4104                         ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4105
4106                 return Either.right(artifactDataRes.right().value());
4107             }
4108             String newCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(artifactData.getDataAsArray());
4109             String oldCheckSum;
4110             String esArtifactId = artifactDefinition.getEsId();
4111             Either<ESArtifactData, CassandraOperationStatus> artifactfromES;
4112             ESArtifactData esArtifactData;
4113             if (esArtifactId != null && !esArtifactId.isEmpty() && artifactDefinition.getPayloadData() == null) {
4114                 log.debug("Try to fetch artifact from cassandra with id : {}", esArtifactId);
4115                 artifactfromES = artifactCassandraDao.getArtifact(esArtifactId);
4116                 if (artifactfromES.isRight()) {
4117                     CassandraOperationStatus resourceUploadStatus = artifactfromES.right().value();
4118                     StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
4119                     ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
4120                     log.debug("Error when getting artifact from ES, error: {} esid : {}", actionStatus, esArtifactId);
4121                     return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, artifactDefinition.getArtifactDisplayName()));
4122                 }
4123                 esArtifactData = artifactfromES.left().value();
4124                 oldCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(esArtifactData.getDataAsArray());
4125             }
4126             else {
4127                 oldCheckSum = artifactDefinition.getArtifactChecksum();
4128
4129             }
4130             Either<ArtifactDefinition, StorageOperationStatus> updateArifactDefinitionStatus = null;
4131
4132             if (shouldLock) {
4133                 Either<Boolean, ResponseFormat> lockComponent = lockComponent(component, "Update Artifact - lock resource: ");
4134                 if (lockComponent.isRight()) {
4135                     handleAuditing(AuditingActionEnum.ARTIFACT_METADATA_UPDATE, component, component.getUniqueId(), modifier, null, null, artifactDefinition
4136                             .getUniqueId(), lockComponent.right().value(), component.getComponentType(), null);
4137                     return Either.right(lockComponent.right().value());
4138                 }
4139             }
4140             try {
4141                 if (oldCheckSum != null && oldCheckSum.equals(newCheckSum)) {
4142
4143                     artifactDefinition.setPayloadUpdateDate(payloadUpdateDateGen.get());
4144                     updateArifactDefinitionStatus = artifactToscaOperation.updateArtifactOnResource(artifactDefinition, component
4145                             .getUniqueId(), artifactDefinition.getUniqueId(), componentType.getNodeType(), instanceId);
4146                     log.trace("No real update done in payload for {} artifact, updating payloadUpdateDate {}", artifactDefinition
4147                             .getArtifactType(), artifactDefinition.getEsId());
4148                     if (updateArifactDefinitionStatus.isRight()) {
4149                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(updateArifactDefinitionStatus
4150                                 .right()
4151                                 .value()), artifactDefinition.getArtifactDisplayName());
4152                         log.trace("Failed to update payloadUpdateDate {}", artifactDefinition.getEsId());
4153                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4154                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4155                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4156
4157                         return Either.right(responseFormat);
4158                     }
4159                 }
4160                 else {
4161
4162                     oldCheckSum = artifactDefinition.getArtifactChecksum();
4163                     artifactDefinition.setArtifactChecksum(newCheckSum);
4164                     artifactDefinition.setEsId(artifactDefinition.getUniqueId());
4165                     log.trace("No real update done in payload for {} artifact, updating payloadUpdateDate {}", artifactDefinition
4166                             .getArtifactType(), artifactDefinition.getEsId());
4167                     updateArifactDefinitionStatus = artifactToscaOperation.updateArtifactOnResource(artifactDefinition, component
4168                             .getUniqueId(), artifactDefinition.getUniqueId(), componentType.getNodeType(), instanceId);
4169
4170                     log.trace("Update Payload  ", artifactDefinition.getEsId());
4171                 }
4172                 if (updateArifactDefinitionStatus != null && updateArifactDefinitionStatus.isLeft()) {
4173
4174                     artifactDefinition = updateArifactDefinitionStatus.left().value();
4175                     artifactData.setId(artifactDefinition.getUniqueId());
4176                     CassandraOperationStatus saveArtifactStatus = artifactCassandraDao.saveArtifact(artifactData);
4177
4178                     if (saveArtifactStatus.equals(CassandraOperationStatus.OK)) {
4179                         if (!inTransaction) {
4180                             titanDao.commit();
4181                         }
4182                         log.debug("Artifact Saved In ES {}", artifactData.getId());
4183                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4184                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4185                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4186                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4187
4188                     }
4189                     else {
4190                         if (!inTransaction) {
4191                             titanDao.rollback();
4192                         }
4193                         log.info("Failed to save artifact {}.", artifactData.getId());
4194                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4195                         handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4196                                         .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4197                                 ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4198
4199                         return Either.right(responseFormat);
4200                     }
4201                 }
4202                 else {
4203                     ResponseFormat responseFormat = componentsUtils.getResponseFormatByArtifactId(componentsUtils.convertFromStorageResponse(updateArifactDefinitionStatus
4204                             .right()
4205                             .value()), artifactDefinition.getArtifactDisplayName());
4206                     log.debug("Failed To update artifact {}", artifactData.getId());
4207                     handleAuditing(AuditingActionEnum.ARTIFACT_PAYLOAD_UPDATE, component, component.getUniqueId(), modifier, artifactDefinition, artifactDefinition
4208                                     .getUniqueId(), artifactDefinition.getUniqueId(), responseFormat,
4209                             ComponentTypeEnum.RESOURCE_INSTANCE, resourceInstanceName);
4210
4211                     return Either.right(responseFormat);
4212
4213                 }
4214             }
4215             finally {
4216                 if (shouldLock) {
4217                     graphLockOperation.unlockComponent(component.getUniqueId(), component.getComponentType()
4218                                                                                          .getNodeType());
4219                 }
4220             }
4221         }
4222
4223         return Either.left(artifactDefinition);
4224     }
4225
4226
4227     public Map<String, Object> buildJsonForUpdateArtifact(ArtifactDefinition artifactDef, ArtifactGroupTypeEnum artifactGroupType, List<ArtifactTemplateInfo> updatedRequiredArtifacts) {
4228         return this.buildJsonForUpdateArtifact(artifactDef.getUniqueId(), artifactDef.getArtifactName(), artifactDef.getArtifactType(), artifactGroupType, artifactDef
4229                         .getArtifactLabel(), artifactDef.getArtifactDisplayName(),
4230                 artifactDef.getDescription(), artifactDef.getPayloadData(), updatedRequiredArtifacts, artifactDef.getListHeatParameters());
4231
4232     }
4233
4234     public Map<String, Object> buildJsonForUpdateArtifact(String artifactId, String artifactName, String artifactType, ArtifactGroupTypeEnum artifactGroupType, String label, String displayName, String description, byte[] artifactContent,
4235                                                           List<ArtifactTemplateInfo> updatedRequiredArtifacts, List<HeatParameterDefinition> heatParameters) {
4236
4237         Map<String, Object> json = new HashMap<>();
4238         if (artifactId != null && !artifactId.isEmpty()) {
4239             json.put(Constants.ARTIFACT_ID, artifactId);
4240         }
4241
4242         json.put(Constants.ARTIFACT_NAME, artifactName);
4243         json.put(Constants.ARTIFACT_TYPE, artifactType);
4244         json.put(Constants.ARTIFACT_DESCRIPTION, description);
4245
4246         if (artifactContent != null) {
4247             log.debug("payload is encoded. perform decode");
4248             String encodedPayload = Base64.encodeBase64String(artifactContent);
4249             json.put(Constants.ARTIFACT_PAYLOAD_DATA, encodedPayload);
4250         }
4251         json.put(Constants.ARTIFACT_DISPLAY_NAME, displayName);
4252         json.put(Constants.ARTIFACT_LABEL, label);
4253         json.put(Constants.ARTIFACT_GROUP_TYPE, artifactGroupType.getType());
4254         json.put(Constants.REQUIRED_ARTIFACTS, (updatedRequiredArtifacts == null || updatedRequiredArtifacts.isEmpty()) ? new ArrayList<>()
4255                 : updatedRequiredArtifacts.stream()
4256                                           .filter(e -> e.getType().equals(ArtifactTypeEnum.HEAT_ARTIFACT.getType()) || e
4257                                                   .getType()
4258                                                   .equals(ArtifactTypeEnum.HEAT_NESTED.getType()))
4259                                           .map(e -> e.getFileName())
4260                                           .collect(Collectors.toList()));
4261         json.put(Constants.ARTIFACT_HEAT_PARAMS, (heatParameters == null || heatParameters.isEmpty()) ? new ArrayList<>()
4262                 : heatParameters);
4263         return json;
4264     }
4265
4266     public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateResourceInstanceArtifactNoContent(String resourceId, Component containerComponent, User user, Map<String, Object> json, ArtifactOperationInfo operation, ArtifactDefinition artifactInfo) {
4267
4268         String jsonStr = gson.toJson(json);
4269         ArtifactDefinition artifactDefinitionFromJson = artifactInfo == null ? RepresentationUtils.convertJsonToArtifactDefinition(jsonStr, ArtifactDefinition.class) : artifactInfo;
4270         String artifactUniqueId = artifactDefinitionFromJson == null ? null : artifactDefinitionFromJson.getUniqueId();
4271         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = validateAndHandleArtifact(resourceId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactUniqueId,
4272                 artifactDefinitionFromJson, null, jsonStr, null, null, user, containerComponent, false, false, true);
4273         if (uploadArtifactToService.isRight()) {
4274             return Either.right(uploadArtifactToService.right().value());
4275         }
4276
4277         return Either.left(uploadArtifactToService.left().value());
4278     }
4279
4280     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleUpdateHeatEnv(String componentId, ArtifactDefinition artifactInfo, AuditingActionEnum auditingAction, String artifactId, User user, ComponentTypeEnum componentType,
4281                                                                                               org.openecomp.sdc.be.model.Component parent, String originData, String origMd5, ArtifactOperationInfo operation, boolean shouldLock, boolean inTransaction) {
4282         convertParentType(componentType);
4283         String parentId = parent.getUniqueId();
4284         ArtifactDefinition currArtifact = artifactInfo;
4285
4286         if (origMd5 != null) {
4287             Either<Boolean, ResponseFormat> validateMd5 = validateMd5(origMd5, originData, artifactInfo.getPayloadData(), operation);
4288             if (validateMd5.isRight()) {
4289                 ResponseFormat responseFormat = validateMd5.right().value();
4290                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4291                 return Either.right(responseFormat);
4292             }
4293
4294             if (artifactInfo.getPayloadData() != null && artifactInfo.getPayloadData().length != 0) {
4295                 Either<Boolean, ResponseFormat> deploymentValidationResult = validateDeploymentArtifact(parent, componentId, false, artifactInfo, currArtifact, NodeTypeEnum.ResourceInstance);
4296                 if (deploymentValidationResult.isRight()) {
4297                     ResponseFormat responseFormat = deploymentValidationResult.right().value();
4298                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4299                     return Either.right(responseFormat);
4300                 }
4301
4302                 Either<byte[], ResponseFormat> payloadEither = handlePayload(artifactInfo, isArtifactMetadataUpdate(auditingAction));
4303                 if (payloadEither.isRight()) {
4304                     ResponseFormat responseFormat = payloadEither.right().value();
4305                     handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4306                     return Either.right(responseFormat);
4307                 }
4308             }
4309             else { // duplicate
4310                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_DATA, ARTIFACT_PAYLOAD);
4311                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, responseFormat, componentType, null);
4312                 return Either.right(responseFormat);
4313             }
4314         }
4315
4316         // lock resource
4317         if (shouldLock) {
4318             Either<Boolean, ResponseFormat> lockComponent = lockComponent(parent, UPDATE_ARTIFACT_LOCK);
4319             if (lockComponent.isRight()) {
4320                 handleAuditing(auditingAction, parent, parentId, user, null, null, artifactId, lockComponent.right()
4321                                                                                                             .value(), componentType, null);
4322                 return Either.right(lockComponent.right().value());
4323             }
4324         }
4325         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
4326         try {
4327             resultOp = updateHeatEnvParams(componentId, artifactId, artifactInfo, user, auditingAction, parent, componentType, origMd5);
4328             return resultOp;
4329
4330         }
4331         finally {
4332             // unlock resource
4333             if (resultOp == null || resultOp.isRight()) {
4334                 log.debug(ROLLBACK);
4335                 if (!inTransaction) {
4336                     titanDao.rollback();
4337                 }
4338             }
4339             else {
4340                 log.debug(COMMIT);
4341                 if (!inTransaction) {
4342                     titanDao.commit();
4343                 }
4344             }
4345             if (shouldLock) {
4346                 componentType = parent.getComponentType();
4347             }
4348             NodeTypeEnum nodeType = componentType.getNodeType();
4349             graphLockOperation.unlockComponent(parent.getUniqueId(), nodeType);
4350         }
4351     }
4352
4353     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateHeatEnvParams(String componentId, String artifactId, ArtifactDefinition artifactInfo, User user, AuditingActionEnum auditingAction, Component parent,
4354                                                                                               ComponentTypeEnum componentType, String origMd5) {
4355
4356         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp = null;
4357         Either<ArtifactDefinition, Operation> insideEither = null;
4358         Either<ComponentInstance, ResponseFormat> getRI = getRIFromComponent(parent, componentId, artifactId, auditingAction, user);
4359         if (getRI.isRight()) {
4360             return Either.right(getRI.right().value());
4361         }
4362         ComponentInstance ri = getRI.left().value();
4363         Either<ArtifactDefinition, ResponseFormat> getArtifactRes = getArtifactFromRI(parent, ri, componentId, artifactId, auditingAction, user);
4364         if (getArtifactRes.isRight()) {
4365             return Either.right(getArtifactRes.right().value());
4366         }
4367         ArtifactDefinition currArtifact = getArtifactRes.left().value();
4368
4369         if (currArtifact.getArtifactType().equals(ArtifactTypeEnum.HEAT.getType()) || currArtifact.getArtifactType()
4370                                                                                                   .equals(ArtifactTypeEnum.HEAT_VOL
4371                                                                                                           .getType()) || currArtifact
4372                 .getArtifactType()
4373                 .equals(ArtifactTypeEnum.HEAT_NET.getType())) {
4374             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
4375             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4376                     .getName());
4377             return Either.right(responseFormat);
4378         }
4379         List<HeatParameterDefinition> currentHeatEnvParams = currArtifact.getListHeatParameters();
4380         List<HeatParameterDefinition> updatedHeatEnvParams = artifactInfo.getListHeatParameters();
4381         new ArrayList<HeatParameterDefinition>();
4382
4383         // upload
4384         if (origMd5 != null) {
4385             Either<List<HeatParameterDefinition>, ResponseFormat> uploadParamsValidationResult = validateUploadParamsFromEnvFile(auditingAction, parent, user, artifactInfo, artifactId, componentType, ri
4386                             .getName(), currentHeatEnvParams,
4387                     updatedHeatEnvParams, currArtifact.getArtifactName());
4388             if (uploadParamsValidationResult.isRight()) {
4389                 ResponseFormat responseFormat = uploadParamsValidationResult.right().value();
4390                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4391                         .getName());
4392                 return Either.right(responseFormat);
4393             }
4394             artifactInfo.setListHeatParameters(updatedHeatEnvParams);
4395         }
4396
4397         Either<ArtifactDefinition, ResponseFormat> validateAndConvertHeatParamers = validateAndConvertHeatParamers(artifactInfo, ArtifactTypeEnum.HEAT_ENV
4398                 .getType());
4399         if (validateAndConvertHeatParamers.isRight()) {
4400             ResponseFormat responseFormat = validateAndConvertHeatParamers.right().value();
4401             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4402                     .getName());
4403             return Either.right(responseFormat);
4404         }
4405
4406         if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty()) {
4407             // fill reduced heat env parameters List for updating
4408             replaceCurrHeatValueWithUpdatedValue(currentHeatEnvParams, updatedHeatEnvParams);
4409             currArtifact.setHeatParamsUpdateDate(System.currentTimeMillis());
4410             currArtifact.setListHeatParameters(currentHeatEnvParams);
4411
4412             Either<ArtifactDefinition, StorageOperationStatus> updateArifactRes = artifactToscaOperation.updateArtifactOnResource(currArtifact, parent
4413                     .getUniqueId(), currArtifact.getUniqueId(), componentType.getNodeType(), componentId);
4414             if (updateArifactRes.isRight()) {
4415                 log.debug("Failed to update artifact on graph  - {}", artifactId);
4416                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateArifactRes
4417                         .right()
4418                         .value()));
4419                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4420                         .getName());
4421                 return Either.right(responseFormat);
4422             }
4423             StorageOperationStatus error = generateCustomizationUUIDOnInstance(parent.getUniqueId(), ri.getUniqueId(), componentType);
4424             if (error != StorageOperationStatus.OK) {
4425                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
4426                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4427                         .getName());
4428                 return Either.right(responseFormat);
4429             }
4430
4431             error = generateCustomizationUUIDOnGroupInstance(ri, updateArifactRes.left()
4432                                                                                  .value()
4433                                                                                  .getUniqueId(), parent.getUniqueId());
4434             if (error != StorageOperationStatus.OK) {
4435                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(error));
4436                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, ri
4437                         .getName());
4438                 return Either.right(responseFormat);
4439             }
4440
4441         }
4442         insideEither = Either.left(currArtifact);
4443         resultOp = Either.left(insideEither);
4444         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4445         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currArtifact, null, artifactId, responseFormat, componentType, ri
4446                 .getName());
4447         return resultOp;
4448     }
4449
4450     private void replaceCurrHeatValueWithUpdatedValue(List<HeatParameterDefinition> currentHeatEnvParams, List<HeatParameterDefinition> updatedHeatEnvParams) {
4451         for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
4452             String paramName = heatEnvParam.getName();
4453             for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4454                 if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4455                     String updatedParamValue = heatEnvParam.getCurrentValue();
4456                     currHeatParam.setCurrentValue(updatedParamValue);
4457                 }
4458             }
4459         }
4460     }
4461
4462     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateHeatParams(String componentId, String artifactId, ArtifactDefinition artifactEnvInfo, User user, AuditingActionEnum auditingAction, Component parent,
4463                                                                                            ComponentTypeEnum componentType, ArtifactDefinition currHeatArtifact, boolean needToUpdateGroup) {
4464
4465         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> resultOp;
4466         Either<ArtifactDefinition, Operation> insideEither = null;
4467         String currentHeatId = currHeatArtifact.getUniqueId();
4468
4469         String esArtifactId = currHeatArtifact.getEsId();
4470         Either<ESArtifactData, CassandraOperationStatus> artifactFromES = artifactCassandraDao.getArtifact(esArtifactId);
4471         if (artifactFromES.isRight()) {
4472             CassandraOperationStatus resourceUploadStatus = artifactFromES.right().value();
4473             StorageOperationStatus storageResponse = DaoStatusConverter.convertCassandraStatusToStorageStatus(resourceUploadStatus);
4474             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(storageResponse);
4475             log.debug("Error when getting artifact from ES, error: {}", actionStatus);
4476             return Either.right(componentsUtils.getResponseFormatByArtifactId(actionStatus, currHeatArtifact.getArtifactDisplayName()));
4477         }
4478
4479         ESArtifactData esArtifactData = artifactFromES.left().value();
4480
4481         ArtifactDefinition updatedHeatArt = currHeatArtifact;
4482
4483         List<HeatParameterDefinition> updatedHeatEnvParams = artifactEnvInfo.getListHeatParameters();
4484         List<HeatParameterDefinition> currentHeatEnvParams = currHeatArtifact.getListHeatParameters();
4485         List<HeatParameterDefinition> newHeatEnvParams = new ArrayList<HeatParameterDefinition>();
4486
4487         if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty() && currentHeatEnvParams != null && !currentHeatEnvParams
4488                 .isEmpty()) {
4489
4490             String paramName;
4491             for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
4492
4493                 paramName = heatEnvParam.getName();
4494                 for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4495                     if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4496
4497                         String updatedParamValue = heatEnvParam.getCurrentValue();
4498                         if (updatedParamValue == null) {
4499                             updatedParamValue = heatEnvParam.getDefaultValue();
4500                         }
4501                         HeatParameterType paramType = HeatParameterType.isValidType(currHeatParam.getType());
4502                         if (!paramType.getValidator().isValid(updatedParamValue, null)) {
4503                             ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
4504                             ResponseFormat responseFormat = componentsUtils.getResponseFormat(status, ArtifactTypeEnum.HEAT_ENV
4505                                     .getType(), paramType.getType(), paramName);
4506                             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactEnvInfo, null, artifactId, responseFormat, componentType, "");
4507                             return Either.right(responseFormat);
4508
4509                         }
4510                         currHeatParam.setCurrentValue(paramType.getConverter().convert(updatedParamValue, null, null));
4511                         newHeatEnvParams.add(currHeatParam);
4512                         break;
4513                     }
4514                 }
4515             }
4516             if (!newHeatEnvParams.isEmpty()) {
4517                 currHeatArtifact.setListHeatParameters(currentHeatEnvParams);
4518                 Either<ArtifactDefinition, StorageOperationStatus> operationStatus = artifactToscaOperation.updateArtifactOnResource(currHeatArtifact, parent
4519                         .getUniqueId(), currHeatArtifact.getUniqueId(), componentType.getNodeType(), componentId);
4520
4521                 if (operationStatus.isRight()) {
4522                     log.debug("Failed to update artifact on graph  - {}", currHeatArtifact.getUniqueId());
4523
4524                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(operationStatus
4525                             .right()
4526                             .value()));
4527                     return Either.right(responseFormat);
4528
4529                 }
4530                 updatedHeatArt = operationStatus.left().value();
4531                 boolean res = true;
4532                 if (!updatedHeatArt.getDuplicated() || esArtifactData.getId() == null) {
4533                     esArtifactData.setId(updatedHeatArt.getEsId());
4534                 }
4535                 res = saveArtifacts(esArtifactData, parent.getUniqueId());
4536
4537                 if (res) {
4538                     log.debug(ARTIFACT_SAVED, updatedHeatArt.getUniqueId());
4539                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4540                     handleAuditing(auditingAction, parent, parent.getUniqueId(), user, updatedHeatArt, currentHeatId, updatedHeatArt
4541                             .getUniqueId(), responseFormat, componentType, null);
4542                 }
4543                 else {
4544                     BeEcompErrorManager.getInstance().logBeDaoSystemError(UPDATE_ARTIFACT);
4545                     log.debug(FAILED_SAVE_ARTIFACT);
4546                     ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
4547                     handleAuditing(auditingAction, parent, parent.getUniqueId(), user, updatedHeatArt, currentHeatId, updatedHeatArt
4548                             .getUniqueId(), responseFormat, componentType, null);
4549                     resultOp = Either.right(responseFormat);
4550                 }
4551
4552                 insideEither = Either.left(updatedHeatArt);
4553             }
4554         }
4555         Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvArtifact;
4556         if (!currentHeatId.equals(updatedHeatArt.getUniqueId())) {
4557             artifactEnvInfo.setArtifactChecksum(null);
4558             updateHeatEnvArtifact = artifactToscaOperation.updateHeatEnvArtifact(parent.getUniqueId(), artifactEnvInfo, currentHeatId, updatedHeatArt
4559                     .getUniqueId(), componentType.getNodeType(), componentId);
4560         }
4561         else {
4562             updateHeatEnvArtifact = artifactToscaOperation.updateHeatEnvPlaceholder(artifactEnvInfo, componentId, componentType
4563                     .getNodeType());
4564
4565         }
4566         if (needToUpdateGroup && updateHeatEnvArtifact.isLeft()) {
4567             ActionStatus result = updateGroupForHeat(currHeatArtifact, updatedHeatArt, artifactEnvInfo, updateHeatEnvArtifact
4568                     .left()
4569                     .value(), parent, componentType);
4570             if (result != ActionStatus.OK) {
4571                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(result);
4572                 return Either.right(responseFormat);
4573             }
4574         }
4575
4576         if (updatedHeatEnvParams.isEmpty()) {
4577             return getResponseAndAuditInvalidEmptyHeatEnvFile(auditingAction, parent, user, currHeatArtifact, artifactId, componentType);
4578         }
4579         resultOp = Either.left(insideEither);
4580         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4581         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currHeatArtifact, null, artifactId, responseFormat, componentType, "");
4582         return resultOp;
4583
4584     }
4585
4586     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> getResponseAndAuditInvalidEmptyHeatEnvFile(AuditingActionEnum auditingAction, Component parent, User user, ArtifactDefinition currHeatArtifact, String artifactId, ComponentTypeEnum componentType) {
4587         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML, currHeatArtifact.getArtifactName());
4588         handleAuditing(auditingAction, parent, parent.getUniqueId(), user, currHeatArtifact, null, artifactId, responseFormat, componentType, "");
4589         return Either.right(responseFormat);
4590     }
4591
4592
4593     private StorageOperationStatus generateCustomizationUUIDOnGroupInstance(ComponentInstance ri, String artifactId, String componentId) {
4594         StorageOperationStatus error = StorageOperationStatus.OK;
4595         log.debug("Need to re-generate  customization UUID for group instance on component instance  {}", ri.getUniqueId());
4596         List<GroupInstance> groupsInstances = ri.getGroupInstances();
4597         List<String> groupInstancesId = null;
4598         if (groupsInstances != null && !groupsInstances.isEmpty()) {
4599             groupInstancesId = groupsInstances.stream()
4600                                               .filter(p -> p.getGroupInstanceArtifacts() != null && p.getGroupInstanceArtifacts()
4601                                                                                                      .contains(artifactId))
4602                                               .map(GroupInstanceDataDefinition::getUniqueId)
4603                                               .collect(Collectors.toList());
4604         }
4605         if (groupInstancesId != null && !groupInstancesId.isEmpty()) {
4606             toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(componentId, ri.getUniqueId(), groupInstancesId);
4607         }
4608         return error;
4609
4610     }
4611
4612     public Either<List<HeatParameterDefinition>, ResponseFormat> validateUploadParamsFromEnvFile(AuditingActionEnum auditingAction, Component parent, User user, ArtifactDefinition artifactInfo, String artifactId, ComponentTypeEnum componentType,
4613                                                                                                  String riName, List<HeatParameterDefinition> currentHeatEnvParams, List<HeatParameterDefinition> updatedHeatEnvParams, String currArtifactName) {
4614
4615         if (updatedHeatEnvParams == null || updatedHeatEnvParams.isEmpty()) {
4616             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, artifactInfo
4617                     .getArtifactName(), currArtifactName);
4618             handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, riName);
4619             return Either.right(responseFormat);
4620         }
4621
4622         for (HeatParameterDefinition uploadedHeatParam : updatedHeatEnvParams) {
4623             String paramName = uploadedHeatParam.getName();
4624             boolean isExistsInHeat = false;
4625             for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
4626                 if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
4627
4628                     isExistsInHeat = true;
4629                     uploadedHeatParam.setType(currHeatParam.getType());
4630                     uploadedHeatParam.setCurrentValue(uploadedHeatParam.getDefaultValue());
4631                     uploadedHeatParam.setDefaultValue(currHeatParam.getDefaultValue());
4632                     uploadedHeatParam.setUniqueId(currHeatParam.getUniqueId());
4633                     break;
4634                 }
4635             }
4636             if (!isExistsInHeat) {
4637                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISMATCH_HEAT_VS_HEAT_ENV, currArtifactName);
4638                 handleAuditing(auditingAction, parent, parent.getUniqueId(), user, artifactInfo, null, artifactId, responseFormat, componentType, riName);
4639                 return Either.right(responseFormat);
4640             }
4641         }
4642         return Either.left(updatedHeatEnvParams);
4643     }
4644
4645     private Either<ComponentInstance, ResponseFormat> getRIFromComponent(Component component, String riID, String artifactId, AuditingActionEnum auditingAction, User user) {
4646         ResponseFormat responseFormat = null;
4647         List<ComponentInstance> ris = component.getComponentInstances();
4648         for (ComponentInstance ri : ris) {
4649             if (riID.equals(ri.getUniqueId())) {
4650                 return Either.left(ri);
4651             }
4652         }
4653         responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, riID);
4654         log.debug("Resource Instance not found, resourceInstanceId {}", riID);
4655         handleAuditing(auditingAction, null, riID, user, null, null, artifactId, responseFormat, ComponentTypeEnum.RESOURCE_INSTANCE, null);
4656         return Either.right(responseFormat);
4657     }
4658
4659     private Either<ArtifactDefinition, ResponseFormat> getArtifactFromRI(Component component, ComponentInstance ri, String riID, String artifactId, AuditingActionEnum auditingAction, User user) {
4660         ResponseFormat responseFormat = null;
4661         Map<String, ArtifactDefinition> rtifactsMap = ri.getDeploymentArtifacts();
4662         for (ArtifactDefinition artifact : rtifactsMap.values()) {
4663             if (artifactId.equals(artifact.getUniqueId())) {
4664                 return Either.left(artifact);
4665             }
4666         }
4667         responseFormat = componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, riID, component.getUniqueId());
4668         handleAuditing(auditingAction, component, riID, user, null, null, artifactId, responseFormat, ComponentTypeEnum.RESOURCE_INSTANCE, ri
4669                 .getName());
4670         return Either.right(responseFormat);
4671     }
4672
4673     public ArtifactDefinition extractArtifactDefinition(Either<ArtifactDefinition, Operation> eitherArtifact) {
4674         ArtifactDefinition ret;
4675         if (eitherArtifact.isLeft()) {
4676             ret = eitherArtifact.left().value();
4677         }
4678         else {
4679             ret = eitherArtifact.right().value().getImplementationArtifact();
4680         }
4681         return ret;
4682     }
4683
4684     /**
4685      * downloads artifact of component by UUIDs
4686      *
4687      * @param componentType
4688      * @param componentUuid
4689      * @param artifactUUID
4690      * @param resourceCommonInfo
4691      * @return
4692      */
4693     public Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDs(ComponentTypeEnum componentType, String componentUuid, String artifactUUID, ResourceCommonInfo resourceCommonInfo) {
4694         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4695         Either<byte[], ResponseFormat> result;
4696         byte[] downloadedArtifact = null;
4697         Component component = getComponentByUuid(componentType, componentUuid, errorWrapper);
4698         if (errorWrapper.isEmpty() && component != null) {
4699             resourceCommonInfo.setResourceName(component.getName());
4700             downloadedArtifact = downloadArtifact(component.getAllArtifacts(), artifactUUID, errorWrapper, component.getName());
4701         }
4702         if (errorWrapper.isEmpty()) {
4703             result = Either.left(downloadedArtifact);
4704         }
4705         else {
4706             result = Either.right(errorWrapper.getInnerElement());
4707         }
4708         return result;
4709     }
4710
4711     /**
4712      * downloads an artifact of resource instance of component by UUIDs
4713      *
4714      * @param componentType
4715      * @param componentUuid
4716      * @param resourceInstanceName
4717      * @param artifactUUID
4718      * @return
4719      */
4720     public Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDs(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID) {
4721         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4722         Either<byte[], ResponseFormat> result;
4723         byte[] downloadedArtifact = null;
4724         ComponentInstance resourceInstance = getRelatedComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4725         if (errorWrapper.isEmpty()) {
4726             downloadedArtifact = downloadArtifact(resourceInstance.getDeploymentArtifacts(), artifactUUID, errorWrapper, resourceInstance
4727                     .getName());
4728         }
4729         if (errorWrapper.isEmpty()) {
4730             result = Either.left(downloadedArtifact);
4731         }
4732         else {
4733             result = Either.right(errorWrapper.getInnerElement());
4734         }
4735         return result;
4736     }
4737
4738     /**
4739      * uploads an artifact to a component by UUID
4740      *
4741      * @param data
4742      * @param request
4743      * @param componentType
4744      * @param componentUuid
4745      * @param resourceCommonInfo
4746      * @param operation
4747      * @return
4748      */
4749     public Either<ArtifactDefinition, ResponseFormat> uploadArtifactToComponentByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
4750         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4751         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4752         Component component = null;
4753         String componentId = null;
4754         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
4755         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4756         String userId = request.getHeader(Constants.USER_ID_HEADER);
4757
4758         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4759         if (getComponentRes.isRight()) {
4760             StorageOperationStatus status = getComponentRes.right().value();
4761             log.debug(FAILED_FETCH_COMPONENT, componentType, componentUuid, status);
4762             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), componentUuid));
4763         }
4764         if (errorWrapper.isEmpty()) {
4765             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
4766             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
4767
4768             if (!getComponentRes.left()
4769                     .value()
4770                     .getMetadataDataDefinition()
4771                     .getState()
4772                     .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4773                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
4774                 if (component != null) {
4775                     componentId = component.getUniqueId();
4776                     componentName = component.getName();
4777                 }
4778             }
4779             resourceCommonInfo.setResourceName(componentName);
4780         }
4781         if (errorWrapper.isEmpty()) {
4782             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, null, artifactInfo, origMd5, data, null, null, null, null);
4783             if (actionResult.isRight()) {
4784                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
4785                         .right()
4786                         .value());
4787                 return Either.right(actionResult.right().value());
4788             }
4789             return Either.left(actionResult.left().value().left().value());
4790         }
4791         return Either.right(errorWrapper.getInnerElement());
4792     }
4793     /**
4794      * upload an artifact to a resource instance by UUID
4795      *
4796      * @param data
4797      * @param request
4798      * @param componentType
4799      * @param componentUuid
4800      * @param resourceInstanceName
4801      * @param operation
4802      * @return
4803      */
4804     public Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName,
4805                                                                                 ArtifactOperationInfo operation) {
4806         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4807         Either<ArtifactDefinition, ResponseFormat> uploadArtifactResult;
4808         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4809         ArtifactDefinition uploadArtifact = null;
4810         Component component = null;
4811         String componentInstanceId;
4812         String componentId;
4813         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4814         String userId = request.getHeader(Constants.USER_ID_HEADER);
4815
4816         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
4817         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4818         if (getComponentRes.isRight()) {
4819             StorageOperationStatus status = getComponentRes.right().value();
4820             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4821             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), resourceInstanceName));
4822         }
4823         if (errorWrapper.isEmpty() && !getComponentRes.left()
4824                                                       .value()
4825                                                       .getMetadataDataDefinition()
4826                                                       .getState()
4827                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4828             component = checkoutParentComponent(componentType, getComponentRes.left()
4829                                                                               .value()
4830                                                                               .getMetadataDataDefinition()
4831                                                                               .getUniqueId(), userId, errorWrapper);
4832         }
4833         if (errorWrapper.isEmpty()) {
4834             if (component == null) {
4835                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4836             }
4837             else {
4838                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
4839             }
4840         }
4841         if (errorWrapper.isEmpty()) {
4842             componentInstanceId = componentRiPair.getRight().getUniqueId();
4843             componentId = componentRiPair.getLeft().getUniqueId();
4844             ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
4845
4846             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, null, artifactInfo, origMd5, data, null, null, componentId, ComponentTypeEnum
4847                     .findParamByType(componentType));
4848             if (actionResult.isRight()) {
4849                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
4850                         .right()
4851                         .value());
4852                 errorWrapper.setInnerElement(actionResult.right().value());
4853             }
4854         }
4855         if (errorWrapper.isEmpty()) {
4856             uploadArtifact = actionResult.left().value().left().value();
4857             uploadArtifactResult = Either.left(uploadArtifact);
4858         }
4859         else {
4860             uploadArtifactResult = Either.right(errorWrapper.getInnerElement());
4861         }
4862         return uploadArtifactResult;
4863     }
4864
4865     /**
4866      * updates an artifact on a component by UUID
4867      *
4868      * @param data
4869      * @param request
4870      * @param componentType
4871      * @param componentUuid
4872      * @param artifactUUID
4873      * @param operation
4874      * @return
4875      */
4876     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnComponentByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String artifactUUID,
4877                                                                                       ResourceCommonInfo resourceCommonInfo, ArtifactOperationInfo operation) {
4878         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4879         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
4880         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4881         ArtifactDefinition updateArtifact = null;
4882         Component component = null;
4883         String componentId = null;
4884         String artifactId = null;
4885         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinitionForUpdate(data, ArtifactDefinition.class);
4886         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4887         String userId = request.getHeader(Constants.USER_ID_HEADER);
4888
4889         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4890         if (getComponentRes.isRight()) {
4891             StorageOperationStatus status = getComponentRes.right().value();
4892             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4893             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
4894         }
4895         if (errorWrapper.isEmpty()) {
4896             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
4897             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
4898
4899             if (!getComponentRes.left()
4900                                 .value()
4901                                 .getMetadataDataDefinition()
4902                                 .getState()
4903                                 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4904                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
4905                 if (component != null) {
4906                     componentId = component.getUniqueId();
4907                     componentName = component.getName();
4908                 }
4909             }
4910             resourceCommonInfo.setResourceName(componentName);
4911         }
4912         if (errorWrapper.isEmpty()) {
4913             artifactId = getLatestParentArtifactDataIdByArtifactUUID(artifactUUID, errorWrapper, componentId, componentType);
4914         }
4915         if (errorWrapper.isEmpty()) {
4916             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, artifactId, artifactInfo, origMd5, data, null, null, null, null);
4917             if (actionResult.isRight()) {
4918                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
4919                         .right()
4920                         .value());
4921                 errorWrapper.setInnerElement(actionResult.right().value());
4922             }
4923         }
4924         if (errorWrapper.isEmpty()) {
4925             updateArtifact = actionResult.left().value().left().value();
4926             updateArtifactResult = Either.left(updateArtifact);
4927
4928         }
4929         else {
4930             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
4931         }
4932         return updateArtifactResult;
4933     }
4934
4935     /**
4936      * updates an artifact on a resource instance by UUID
4937      *
4938      * @param data
4939      * @param request
4940      * @param componentType
4941      * @param componentUuid
4942      * @param resourceInstanceName
4943      * @param artifactUUID
4944      * @param operation            TODO
4945      * @return
4946      */
4947     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnRiByUUID(String data, HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID,
4948                                                                                 ArtifactOperationInfo operation) {
4949
4950         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
4951         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
4952         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
4953         ArtifactDefinition updateArtifact = null;
4954         Component component = null;
4955         String componentInstanceId = null;
4956         String componentId = null;
4957         String artifactId = null;
4958         String origMd5 = request.getHeader(Constants.MD5_HEADER);
4959         String userId = request.getHeader(Constants.USER_ID_HEADER);
4960
4961         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
4962         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
4963         if (getComponentRes.isRight()) {
4964             StorageOperationStatus status = getComponentRes.right().value();
4965             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
4966             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
4967         }
4968         if (errorWrapper.isEmpty() && !getComponentRes.left()
4969                                                       .value()
4970                                                       .getMetadataDataDefinition()
4971                                                       .getState()
4972                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
4973             component = checkoutParentComponent(componentType, getComponentRes.left()
4974                                                                               .value()
4975                                                                               .getMetadataDataDefinition()
4976                                                                               .getUniqueId(), userId, errorWrapper);
4977         }
4978         if (errorWrapper.isEmpty()) {
4979             if (component == null) {
4980                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
4981             }
4982             else {
4983                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
4984             }
4985         }
4986         if (errorWrapper.isEmpty()) {
4987             componentInstanceId = componentRiPair.getRight().getUniqueId();
4988             componentId = componentRiPair.getLeft().getUniqueId();
4989             artifactId = findArtifactId(componentRiPair.getRight(), artifactUUID, errorWrapper);
4990         }
4991         if (errorWrapper.isEmpty()) {
4992             ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinition(data, ArtifactDefinition.class);
4993
4994             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactId, artifactInfo, origMd5, data, null, null, componentId, ComponentTypeEnum
4995                     .findParamByType(componentType));
4996             if (actionResult.isRight()) {
4997                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
4998                         .right()
4999                         .value());
5000                 errorWrapper.setInnerElement(actionResult.right().value());
5001             }
5002         }
5003         if (errorWrapper.isEmpty()) {
5004             updateArtifact = actionResult.left().value().left().value();
5005             updateArtifactResult = Either.left(updateArtifact);
5006         }
5007         else {
5008             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
5009         }
5010         return updateArtifactResult;
5011     }
5012
5013     /**
5014      * updates an artifact on a component by UUID
5015      *
5016      * @param data
5017      * @param request
5018      * @param componentType
5019      * @param componentUuid
5020      * @param artifactUUID
5021      * @param operation
5022      * @return
5023      */
5024     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnInterfaceOperationByResourceUUID(
5025             String data, HttpServletRequest request, ComponentTypeEnum componentType,
5026             String componentUuid, String interfaceUUID, String operationUUID, String artifactUUID,
5027         ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
5028         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5029         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
5030         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5031         ArtifactDefinition updateArtifact = null;
5032         String componentId = null;
5033         ArtifactDefinition artifactInfo = RepresentationUtils.convertJsonToArtifactDefinitionForUpdate(data, ArtifactDefinition.class);
5034         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5035         String userId = request.getHeader(Constants.USER_ID_HEADER);
5036
5037         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5038         if (getComponentRes.isRight()) {
5039             StorageOperationStatus status = getComponentRes.right().value();
5040             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5041             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5042         }
5043         if (errorWrapper.isEmpty()) {
5044             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
5045             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
5046             if (!getComponentRes.left()
5047                     .value()
5048                     .getMetadataDataDefinition()
5049                     .getState()
5050                     .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5051                 Component component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
5052                 if (component != null) {
5053                     componentId = component.getUniqueId();
5054                     componentName = component.getName();
5055                 }
5056
5057             }
5058             resourceCommonInfo.setResourceName(componentName);
5059         }
5060         if (errorWrapper.isEmpty()) {
5061             Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId, interfaceUUID);
5062             if (interfaceName.isRight()) {
5063                 errorWrapper.setInnerElement(interfaceName.right().value());
5064             }
5065             if (errorWrapper.isEmpty()) {
5066                 actionResult = handleArtifactRequest(componentId, userId, componentType, operation,
5067                         artifactUUID, artifactInfo, origMd5, data, interfaceName.left().value(),
5068                         operationUUID, null, null);
5069                 if (actionResult.isRight()) {
5070                     log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
5071                             .right()
5072                             .value());
5073                     errorWrapper.setInnerElement(actionResult.right().value());
5074                 }
5075             }
5076         }
5077         if (errorWrapper.isEmpty()) {
5078             updateArtifact = actionResult.left().value().left().value();
5079             updateArtifactResult = Either.left(updateArtifact);
5080
5081         }
5082         else {
5083             updateArtifactResult = Either.right(errorWrapper.getInnerElement());
5084         }
5085         return updateArtifactResult;
5086     }
5087
5088     private Either<String, ResponseFormat> fetchInterfaceName(String componentId, String interfaceUUID) {
5089         Either<Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade.getToscaElement(componentId);
5090         if (componentStorageOperationStatusEither.isRight()) {
5091             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
5092             log.debug("Failed to fetch component information by component id, error {}", errorStatus);
5093             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
5094         }
5095         Component storedComponent = componentStorageOperationStatusEither.left().value();
5096
5097         Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
5098             .getInterfaceDefinitionFromComponentByInterfaceId(storedComponent, interfaceUUID);
5099         if(!optionalInterface.isPresent()) {
5100             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceUUID));
5101         }
5102         return Either.left(optionalInterface.get().getType());
5103     }
5104
5105
5106     /**
5107      * deletes an artifact on a component by UUID
5108      *
5109      * @param request
5110      * @param componentType
5111      * @param componentUuid
5112      * @param artifactUUID
5113      * @param resourceCommonInfo
5114      * @param operation        TODO
5115      * @return
5116      */
5117     public Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUID(HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String artifactUUID, ResourceCommonInfo resourceCommonInfo,
5118                                                                                       ArtifactOperationInfo operation) {
5119
5120         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5121         Either<ArtifactDefinition, ResponseFormat> deleteArtifactResult;
5122         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5123         ArtifactDefinition deleteArtifact = null;
5124         Component component = null;
5125         String componentId = null;
5126         String artifactId = null;
5127         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5128         String userId = request.getHeader(Constants.USER_ID_HEADER);
5129
5130         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5131         if (getComponentRes.isRight()) {
5132             StorageOperationStatus status = getComponentRes.right().value();
5133             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5134             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status, componentType), componentUuid));
5135         }
5136         if (errorWrapper.isEmpty()) {
5137             componentId = getComponentRes.left().value().getMetadataDataDefinition().getUniqueId();
5138             String componentName = getComponentRes.left().value().getMetadataDataDefinition().getName();
5139             if (!getComponentRes.left()
5140                                 .value()
5141                                 .getMetadataDataDefinition()
5142                                 .getState()
5143                                 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5144                 component = checkoutParentComponent(componentType, componentId, userId, errorWrapper);
5145                 if (component != null) {
5146                     componentId = component.getUniqueId();
5147                     componentName = component.getName();
5148                 }
5149             }
5150             resourceCommonInfo.setResourceName(componentName);
5151         }
5152         if (errorWrapper.isEmpty()) {
5153             artifactId = getLatestParentArtifactDataIdByArtifactUUID(artifactUUID, errorWrapper, componentId, componentType);
5154         }
5155         if (errorWrapper.isEmpty()) {
5156             actionResult = handleArtifactRequest(componentId, userId, componentType, operation, artifactId, null, origMd5, null, null, null, null, null);
5157             if (actionResult.isRight()) {
5158                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, componentType, componentUuid, actionResult
5159                         .right()
5160                         .value());
5161                 errorWrapper.setInnerElement(actionResult.right().value());
5162             }
5163         }
5164         if (errorWrapper.isEmpty()) {
5165             deleteArtifact = actionResult.left().value().left().value();
5166             deleteArtifactResult = Either.left(deleteArtifact);
5167         }
5168         else {
5169             deleteArtifactResult = Either.right(errorWrapper.getInnerElement());
5170         }
5171         return deleteArtifactResult;
5172     }
5173
5174     /**
5175      * deletes an artifact from a resource instance by UUID
5176      *
5177      * @param request
5178      * @param componentType
5179      * @param componentUuid
5180      * @param resourceInstanceName
5181      * @param artifactUUID
5182      * @param operation            TODO
5183      * @return
5184      */
5185     public Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUID(HttpServletRequest request, ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, String artifactUUID,
5186                                                                                ArtifactOperationInfo operation) {
5187
5188         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5189         Either<ArtifactDefinition, ResponseFormat> deleteArtifactResult;
5190         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
5191         ArtifactDefinition deleteArtifact = null;
5192         Component component = null;
5193         String componentInstanceId = null;
5194         String componentId = null;
5195         String artifactId = null;
5196         String origMd5 = request.getHeader(Constants.MD5_HEADER);
5197         String userId = request.getHeader(Constants.USER_ID_HEADER);
5198         ImmutablePair<Component, ComponentInstance> componentRiPair = null;
5199         Either<ComponentMetadataData, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, true);
5200         if (getComponentRes.isRight()) {
5201             StorageOperationStatus status = getComponentRes.right().value();
5202             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5203             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5204         }
5205         if (errorWrapper.isEmpty() && !getComponentRes.left()
5206                                                       .value()
5207                                                       .getMetadataDataDefinition()
5208                                                       .getState()
5209                                                       .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
5210             component = checkoutParentComponent(componentType, getComponentRes.left()
5211                                                                               .value()
5212                                                                               .getMetadataDataDefinition()
5213                                                                               .getUniqueId(), userId, errorWrapper);
5214         }
5215         if (errorWrapper.isEmpty()) {
5216             if (component == null) {
5217                 componentRiPair = getRelatedComponentComponentInstance(componentType, componentUuid, resourceInstanceName, errorWrapper);
5218             }
5219             else {
5220                 componentRiPair = getRelatedComponentComponentInstance(component, resourceInstanceName, errorWrapper);
5221             }
5222         }
5223         if (errorWrapper.isEmpty()) {
5224             componentInstanceId = componentRiPair.getRight().getUniqueId();
5225             componentId = componentRiPair.getLeft().getUniqueId();
5226             artifactId = findArtifactId(componentRiPair.getRight(), artifactUUID, errorWrapper);
5227         }
5228         if (errorWrapper.isEmpty()) {
5229
5230             actionResult = handleArtifactRequest(componentInstanceId, userId, ComponentTypeEnum.RESOURCE_INSTANCE, operation, artifactId, null, origMd5, null, null, null, componentId, ComponentTypeEnum
5231                     .findParamByType(componentType));
5232
5233             if (actionResult.isRight()) {
5234                 log.debug(FAILED_UPLOAD_ARTIFACT_TO_INSTANCE, resourceInstanceName, componentType, componentUuid, actionResult
5235                         .right()
5236                         .value());
5237                 errorWrapper.setInnerElement(actionResult.right().value());
5238             }
5239         }
5240         if (errorWrapper.isEmpty()) {
5241             deleteArtifact = actionResult.left().value().left().value();
5242             deleteArtifactResult = Either.left(deleteArtifact);
5243         }
5244         else {
5245             deleteArtifactResult = Either.right(errorWrapper.getInnerElement());
5246         }
5247         return deleteArtifactResult;
5248     }
5249
5250     private String findArtifactId(ComponentInstance instance, String artifactUUID, Wrapper<ResponseFormat> errorWrapper) {
5251         String artifactId = null;
5252         ArtifactDefinition foundArtifact = null;
5253         if (instance.getDeploymentArtifacts() != null) {
5254             foundArtifact = instance.getDeploymentArtifacts()
5255                                     .values()
5256                                     .stream()
5257                                     .filter(e -> e.getArtifactUUID() != null && e.getArtifactUUID()
5258                                                                                  .equals(artifactUUID))
5259                                     .findFirst()
5260                                     .orElse(null);
5261         }
5262         if (foundArtifact == null && instance.getArtifacts() != null) {
5263             foundArtifact = instance.getArtifacts()
5264                                     .values()
5265                                     .stream()
5266                                     .filter(e -> e.getArtifactUUID() != null && e.getArtifactUUID()
5267                                                                                  .equals(artifactUUID))
5268                                     .findFirst()
5269                                     .orElse(null);
5270         }
5271         if (foundArtifact == null) {
5272             log.debug("The artifact {} was not found on instance {}. ", artifactUUID, instance.getUniqueId());
5273             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactUUID));
5274         }
5275         else {
5276             artifactId = foundArtifact.getUniqueId();
5277         }
5278         return artifactId;
5279     }
5280
5281     @SuppressWarnings("unchecked")
5282     public Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder(ArtifactDefinition heatArtifact, String envType, String parentId, NodeTypeEnum parentType, String parentName, User user, Component component,
5283                                                                                Map<String, String> existingEnvVersions) {
5284         Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
5285                                                                               .getConfiguration()
5286                                                                               .getDeploymentResourceInstanceArtifacts();
5287         if (deploymentResourceArtifacts == null) {
5288             log.debug("no deployment artifacts are configured for generated artifacts");
5289             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
5290         }
5291         Map<String, Object> placeHolderData = (Map<String, Object>) deploymentResourceArtifacts.get(envType);
5292         if (placeHolderData == null) {
5293             log.debug("no env type {} are configured for generated artifacts", envType);
5294             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
5295         }
5296
5297         String envLabel = (heatArtifact.getArtifactLabel() + HEAT_ENV_SUFFIX).toLowerCase();
5298         Either<ArtifactDefinition, ResponseFormat> createArtifactPlaceHolder = createArtifactPlaceHolderInfo(parentId, envLabel, placeHolderData, user
5299                 .getUserId(), ArtifactGroupTypeEnum.DEPLOYMENT, true);
5300         if (createArtifactPlaceHolder.isRight()) {
5301             return Either.right(createArtifactPlaceHolder.right().value());
5302         }
5303         ArtifactDefinition artifactHeatEnv = createArtifactPlaceHolder.left().value();
5304         artifactHeatEnv.setGeneratedFromId(heatArtifact.getUniqueId());
5305         artifactHeatEnv.setHeatParamsUpdateDate(System.currentTimeMillis());
5306         artifactHeatEnv.setTimeout(0);
5307         buildHeatEnvFileName(heatArtifact, artifactHeatEnv, placeHolderData);
5308         // rbetzer - keep env artifactVersion - changeComponentInstanceVersion flow
5309         handleEnvArtifactVersion(artifactHeatEnv, existingEnvVersions);
5310         ArtifactDefinition heatEnvPlaceholder;
5311         // Evg : for resource instance artifact will be added later as block with other env artifacts from BL
5312         if (parentType != NodeTypeEnum.ResourceInstance) {
5313             Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact = addHeatEnvArtifact(artifactHeatEnv, heatArtifact, component
5314                     .getUniqueId(), parentType, parentId);
5315             if (addHeatEnvArtifact.isRight()) {
5316                 log.debug("failed to create heat env artifact on resource instance");
5317                 return Either.right(componentsUtils.getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(addHeatEnvArtifact
5318                         .right()
5319                         .value(), false), "", null));
5320             }
5321             heatEnvPlaceholder = createArtifactPlaceHolder.left().value();
5322         }
5323         else {
5324             heatEnvPlaceholder = artifactHeatEnv;
5325             artifactToscaOperation.generateUUID(heatEnvPlaceholder, heatEnvPlaceholder.getArtifactVersion());
5326             setHeatCurrentValuesOnHeatEnvDefaultValues(heatArtifact, heatEnvPlaceholder);
5327         }
5328
5329         ComponentTypeEnum componentType = component.getComponentType();
5330         if (parentType == NodeTypeEnum.ResourceInstance) {
5331             componentType = ComponentTypeEnum.RESOURCE_INSTANCE;
5332         }
5333         componentsUtils.auditComponent(componentsUtils.getResponseFormat(ActionStatus.OK), user, component, AuditingActionEnum.ARTIFACT_UPLOAD,
5334                 new ResourceCommonInfo(parentName, componentType.getValue()),
5335                 ResourceVersionInfo.newBuilder().build(),
5336                 ResourceVersionInfo.newBuilder().artifactUuid(heatEnvPlaceholder.getUniqueId()).build(),
5337                 null, heatEnvPlaceholder, null);
5338         return Either.left(heatEnvPlaceholder);
5339     }
5340
5341     private void setHeatCurrentValuesOnHeatEnvDefaultValues(ArtifactDefinition artifact, ArtifactDefinition artifactDefinition) {
5342         if (artifact.getListHeatParameters() == null) {
5343             return;
5344         }
5345         List<HeatParameterDefinition> heatEnvParameters = new ArrayList<>();
5346         for (HeatParameterDefinition parameter : artifact.getListHeatParameters()) {
5347             HeatParameterDefinition heatEnvParameter = new HeatParameterDefinition(parameter);
5348             heatEnvParameter.setDefaultValue(parameter.getCurrentValue());
5349             heatEnvParameter.setCurrentValue(null);
5350             heatEnvParameters.add(heatEnvParameter);
5351         }
5352         artifactDefinition.setListHeatParameters(heatEnvParameters);
5353     }
5354
5355     private void buildHeatEnvFileName(ArtifactDefinition heatArtifact, ArtifactDefinition heatEnvArtifact, Map<String, Object> placeHolderData) {
5356         String heatExtension = GeneralUtility.getFilenameExtension(heatArtifact.getArtifactName());
5357         String envExtension = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_FILE_EXTENSION);
5358         String name = heatArtifact.getArtifactName();
5359         String fileName;
5360         if (name == null) {
5361             name = heatArtifact.getArtifactLabel();
5362             fileName = name + "." + envExtension;
5363         }
5364         else {
5365             fileName = name.replaceAll("." + heatExtension, "." + envExtension);
5366         }
5367         heatEnvArtifact.setArtifactName(fileName);
5368     }
5369
5370     private void handleEnvArtifactVersion(ArtifactDefinition heatEnvArtifact, Map<String, String> existingEnvVersions) {
5371         if (null != existingEnvVersions) {
5372             String prevVersion = existingEnvVersions.get(heatEnvArtifact.getArtifactName());
5373             if (null != prevVersion) {
5374                 heatEnvArtifact.setArtifactVersion(prevVersion);
5375             }
5376         }
5377     }
5378
5379     /**
5380      * Handles Artifacts Request For Inner Component
5381      *
5382      * @param artifactsToHandle
5383      * @param component
5384      * @param user
5385      * @param vfcsNewCreatedArtifacts
5386      * @param operation
5387      * @param shouldLock
5388      * @param inTransaction
5389      * @return
5390      */
5391     public Either<List<ArtifactDefinition>, ResponseFormat> handleArtifactsRequestForInnerVfcComponent(List<ArtifactDefinition> artifactsToHandle, Resource component, User user, List<ArtifactDefinition> vfcsNewCreatedArtifacts,
5392                                                                                                        ArtifactOperationInfo operation, boolean shouldLock, boolean inTransaction) {
5393
5394         Either<List<ArtifactDefinition>, ResponseFormat> handleArtifactsResult = null;
5395         ComponentTypeEnum componentType = component.getComponentType();
5396         List<ArtifactDefinition> uploadedArtifacts = new ArrayList<>();
5397         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
5398         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult;
5399         String originData;
5400         String origMd5;
5401         try {
5402             for (ArtifactDefinition artifact : artifactsToHandle) {
5403                 originData = buildJsonStringForCsarVfcArtifact(artifact);
5404                 origMd5 = GeneralUtility.calculateMD5Base64EncodedByString(originData);
5405                 actionResult = handleArtifactRequest(component.getUniqueId(), user.getUserId(), componentType, operation, artifact
5406                         .getUniqueId(), artifact, origMd5, originData, null, null, null, null, shouldLock, inTransaction);
5407                 if (actionResult.isRight()) {
5408                     log.debug("Failed to upload artifact to component with type {} and name {}. Status is {}. ", componentType, component
5409                             .getName(), actionResult.right().value());
5410                     errorWrapper.setInnerElement(actionResult.right().value());
5411                     if (ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum())) {
5412                         vfcsNewCreatedArtifacts.addAll(uploadedArtifacts);
5413                     }
5414                     break;
5415                 }
5416                 uploadedArtifacts.add(actionResult.left().value().left().value());
5417             }
5418             if (errorWrapper.isEmpty()) {
5419                 handleArtifactsResult = Either.left(uploadedArtifacts);
5420             }
5421             else {
5422                 handleArtifactsResult = Either.right(errorWrapper.getInnerElement());
5423             }
5424         }
5425         catch (Exception e) {
5426             ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
5427             handleArtifactsResult = Either.right(responseFormat);
5428             log.debug("Exception occured when handleArtifactsRequestForInnerVfcComponent, error is:{}", e.getMessage(), e);
5429         }
5430         return handleArtifactsResult;
5431     }
5432
5433     private ComponentInstance getRelatedComponentInstance(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5434         ComponentInstance componentInstance = null;
5435         String normalizedName = ValidationUtils.normalizeComponentInstanceName(resourceInstanceName);
5436         Component component = getComponentByUuid(componentType, componentUuid, errorWrapper);
5437         if (errorWrapper.isEmpty()) {
5438             componentInstance = component.getComponentInstances()
5439                                          .stream()
5440                                          .filter(ci -> ValidationUtils.normalizeComponentInstanceName(ci.getName())
5441                                                                       .equals(normalizedName))
5442                                          .findFirst()
5443                                          .orElse(null);
5444             if (componentInstance == null) {
5445                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5446                         .getComponentType()
5447                         .getValue(), component.getName()));
5448                 log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5449             }
5450         }
5451         return componentInstance;
5452     }
5453
5454     private ImmutablePair<Component, ComponentInstance> getRelatedComponentComponentInstance(Component component, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5455
5456         ImmutablePair<Component, ComponentInstance> relatedComponentComponentInstancePair = null;
5457         String normalizedName = ValidationUtils.normalizeComponentInstanceName(resourceInstanceName);
5458         ComponentInstance componentInstance = component.getComponentInstances()
5459                                                        .stream()
5460                                                        .filter(ci -> ValidationUtils.normalizeComponentInstanceName(ci.getName())
5461                                                                                     .equals(normalizedName))
5462                                                        .findFirst()
5463                                                        .orElse(null);
5464         if (componentInstance == null) {
5465             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5466                     .getComponentType()
5467                     .getValue(), component.getName()));
5468             log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5469         }
5470         else {
5471             relatedComponentComponentInstancePair = new ImmutablePair<>(component, componentInstance);
5472         }
5473         return relatedComponentComponentInstancePair;
5474     }
5475
5476     private ImmutablePair<Component, ComponentInstance> getRelatedComponentComponentInstance(ComponentTypeEnum componentType, String componentUuid, String resourceInstanceName, Wrapper<ResponseFormat> errorWrapper) {
5477         ComponentInstance componentInstance;
5478         ImmutablePair<Component, ComponentInstance> relatedComponentComponentInstancePair = null;
5479         Component component = getLatestComponentByUuid(componentType, componentUuid, errorWrapper);
5480         if (errorWrapper.isEmpty()) {
5481             componentInstance = component.getComponentInstances()
5482                                          .stream()
5483                                          .filter(ci -> ci.getNormalizedName().equals(resourceInstanceName))
5484                                          .findFirst()
5485                                          .orElse(null);
5486             if (componentInstance == null) {
5487                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, resourceInstanceName, RESOURCE_INSTANCE, component
5488                         .getComponentType()
5489                         .getValue(), component.getName()));
5490                 log.debug(COMPONENT_INSTANCE_NOT_FOUND, resourceInstanceName, component.getName());
5491             }
5492             else {
5493                 relatedComponentComponentInstancePair = new ImmutablePair<>(component, componentInstance);
5494             }
5495         }
5496         return relatedComponentComponentInstancePair;
5497     }
5498
5499     private byte[] downloadArtifact(Map<String, ArtifactDefinition> artifacts, String artifactUUID, Wrapper<ResponseFormat> errorWrapper, String componentName) {
5500
5501         byte[] downloadedArtifact = null;
5502         Either<ImmutablePair<String, byte[]>, ResponseFormat> downloadArtifactEither = null;
5503         List<ArtifactDefinition> artifactsList = null;
5504         ArtifactDefinition deploymentArtifact = null;
5505         if (artifacts != null && !artifacts.isEmpty()) {
5506             artifactsList = artifacts.values()
5507                                      .stream()
5508                                      .filter(art -> art.getArtifactUUID() != null && art.getArtifactUUID()
5509                                                                                         .equals(artifactUUID))
5510                                      .collect(Collectors.toList());
5511         }
5512         if (artifactsList == null || artifactsList.isEmpty()) {
5513             log.debug("Deployment artifact with uuid {} was not found for component {}", artifactUUID, componentName);
5514             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, artifactUUID));
5515         }
5516         if (errorWrapper.isEmpty()) {
5517             deploymentArtifact = artifactsList.get(0);
5518             downloadArtifactEither = downloadArtifact(deploymentArtifact);
5519             if (downloadArtifactEither.isRight()) {
5520                 log.debug("Failed to download artifact {}. ", deploymentArtifact.getArtifactName());
5521                 errorWrapper.setInnerElement(downloadArtifactEither.right().value());
5522             }
5523         }
5524         if (errorWrapper.isEmpty()) {
5525             log.trace("Succeeded to download artifact with uniqueId {}", deploymentArtifact.getUniqueId());
5526             downloadedArtifact = downloadArtifactEither.left().value().getRight();
5527         }
5528         return downloadedArtifact;
5529     }
5530
5531     private Component getLatestComponentByUuid(ComponentTypeEnum componentType, String componentUuid, Wrapper<ResponseFormat> errorWrapper) {
5532         Component component = null;
5533         Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getLatestComponentByUuid(componentUuid);
5534         if (getComponentRes.isRight()) {
5535             StorageOperationStatus status = getComponentRes.right().value();
5536             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5537             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5538         }
5539         else {
5540             component = getComponentRes.left().value();
5541         }
5542         return component;
5543     }
5544
5545     private Component getComponentByUuid(ComponentTypeEnum componentType, String componentUuid, Wrapper<ResponseFormat> errorWrapper) {
5546         Component component = null;
5547         Either<List<Component>, StorageOperationStatus> getComponentRes = toscaOperationFacade.getComponentListByUuid(componentUuid, null);
5548         if (getComponentRes.isRight()) {
5549             StorageOperationStatus status = getComponentRes.right().value();
5550             log.debug("Could not fetch component with type {} and uuid {}. Status is {}. ", componentType, componentUuid, status);
5551             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status)));
5552         }
5553         else {
5554             List<Component> value = getComponentRes.left().value();
5555             if (value.isEmpty()) {
5556                 log.debug("Could not fetch component with type {} and uuid {}.", componentType, componentUuid);
5557                 ActionStatus status = componentType == ComponentTypeEnum.RESOURCE ? ActionStatus.RESOURCE_NOT_FOUND : ActionStatus.SERVICE_NOT_FOUND;
5558                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(status));
5559             }
5560             else {
5561                 component = value.get(0);
5562             }
5563         }
5564         return component;
5565     }
5566
5567     private String getLatestParentArtifactDataIdByArtifactUUID(String artifactUUID, Wrapper<ResponseFormat> errorWrapper, String parentId, ComponentTypeEnum componentType) {
5568         String artifactId = null;
5569         ActionStatus actionStatus = ActionStatus.ARTIFACT_NOT_FOUND;
5570         StorageOperationStatus storageStatus;
5571         ArtifactDefinition latestArtifact = null;
5572         List<ArtifactDefinition> artifacts = null;
5573         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifactsRes = artifactToscaOperation.getArtifacts(parentId);
5574         if (getArtifactsRes.isRight()) {
5575             storageStatus = getArtifactsRes.right().value();
5576             log.debug("Couldn't fetch artifacts data for parent component {} with uid {}, error: {}", componentType, parentId, storageStatus);
5577             if (!storageStatus.equals(StorageOperationStatus.NOT_FOUND)) {
5578                 actionStatus = componentsUtils.convertFromStorageResponse(storageStatus);
5579             }
5580             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5581         }
5582         if (errorWrapper.isEmpty()) {
5583             artifacts = getArtifactsRes.left()
5584                                        .value()
5585                                        .values()
5586                                        .stream()
5587                                        .filter(a -> a.getArtifactUUID() != null && a.getArtifactUUID()
5588                                                                                     .equals(artifactUUID))
5589                                        .collect(Collectors.toList());
5590             if (artifacts == null || artifacts.isEmpty()) {
5591                 log.debug("Couldn't fetch artifact with UUID {} data for parent component {} with uid {}, error: {}", artifactUUID, componentType, parentId, actionStatus);
5592                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5593             }
5594         }
5595         if (errorWrapper.isEmpty()) {
5596             latestArtifact = artifacts.stream().max((a1, a2) -> {
5597                 int compareRes = Double.compare(Double.parseDouble(a1.getArtifactVersion()), Double.parseDouble(a2.getArtifactVersion()));
5598                 if (compareRes == 0) {
5599                     compareRes = Long.compare(a1.getLastUpdateDate() == null ? 0 : a1.getLastUpdateDate(), a2.getLastUpdateDate() == null ? 0 : a2
5600                             .getLastUpdateDate());
5601                 }
5602                 return compareRes;
5603             }).get();
5604             if (latestArtifact == null) {
5605                 log.debug("Couldn't fetch latest artifact with UUID {} data for parent component {} with uid {}, error: {}", artifactUUID, componentType, parentId, actionStatus);
5606                 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus, artifactUUID));
5607             }
5608         }
5609         if (errorWrapper.isEmpty()) {
5610             artifactId = latestArtifact.getUniqueId();
5611         }
5612         return artifactId;
5613     }
5614
5615     private Component checkoutParentComponent(ComponentTypeEnum componentType, String parentId, String userId, Wrapper<ResponseFormat> errorWrapper) {
5616
5617         Component component = null;
5618         Either<User, ActionStatus> getUserRes = userBusinessLogic.getUser(userId, false);
5619         if (getUserRes.isRight()) {
5620             log.debug("Could not fetch User of component {} with uid {} to checked out. Status is {}. ", componentType.getNodeType(), parentId, getUserRes
5621                     .right()
5622                     .value());
5623             errorWrapper.setInnerElement(componentsUtils.getResponseFormat(getUserRes.right().value()));
5624         }
5625         if (errorWrapper.isEmpty()) {
5626             User modifier = getUserRes.left().value();
5627             LifecycleChangeInfoWithAction changeInfo = new LifecycleChangeInfoWithAction("External API checkout", LifecycleChanceActionEnum.UPDATE_FROM_EXTERNAL_API);
5628             Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic.changeComponentState(componentType, parentId, modifier, LifeCycleTransitionEnum.CHECKOUT, changeInfo, false, true);
5629             if (checkoutRes.isRight()) {
5630                 log.debug("Could not change state of component {} with uid {} to checked out. Status is {}. ", componentType
5631                         .getNodeType(), parentId, checkoutRes.right().value().getStatus());
5632                 errorWrapper.setInnerElement(checkoutRes.right().value());
5633             }
5634             else {
5635                 component = checkoutRes.left().value();
5636             }
5637         }
5638         return component;
5639     }
5640
5641     private String buildJsonStringForCsarVfcArtifact(ArtifactDefinition artifact) {
5642         Map<String, Object> json = new HashMap<>();
5643         String artifactName = artifact.getArtifactName();
5644         json.put(Constants.ARTIFACT_NAME, artifactName);
5645         json.put(Constants.ARTIFACT_LABEL, artifact.getArtifactLabel());
5646         json.put(Constants.ARTIFACT_TYPE, artifact.getArtifactType());
5647         json.put(Constants.ARTIFACT_GROUP_TYPE, ArtifactGroupTypeEnum.DEPLOYMENT.getType());
5648         json.put(Constants.ARTIFACT_DESCRIPTION, artifact.getDescription());
5649         json.put(Constants.ARTIFACT_PAYLOAD_DATA, artifact.getPayloadData());
5650         json.put(Constants.ARTIFACT_DISPLAY_NAME, artifact.getArtifactDisplayName());
5651         return gson.toJson(json);
5652     }
5653
5654     @VisibleForTesting
5655     void setNodeTemplateOperation(NodeTemplateOperation nodeTemplateOperation) {
5656         this.nodeTemplateOperation = nodeTemplateOperation;
5657     }
5658 }