catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.java

   1 package org.openecomp.sdc.be.model.jsontitan.operations;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7 import java.util.Optional;
   8 import java.util.UUID;
   9 import java.util.stream.Collectors;
  10
  11 import org.apache.commons.collections.MapUtils;
  12 import org.apache.commons.lang3.tuple.ImmutableTriple;
  13 import org.apache.commons.lang3.tuple.Triple;
  14 import org.apache.tinkerpop.gremlin.structure.Direction;
  15 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  16 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  17 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  18 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  19 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  20 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  21 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  22 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  24 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  25 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  26 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  27 import org.openecomp.sdc.be.model.ArtifactDefinition;
  28 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  29 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  30 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  31 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  32 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  33 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  34 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  35 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38 import org.slf4j.MDC;
  39
  40 import fj.data.Either;
  41
  42 @org.springframework.stereotype.Component("artifacts-operations")
  43
  44 public class ArtifactsOperations extends BaseOperation {
  45         private static Logger log = LoggerFactory.getLogger(ArtifactsOperations.class.getName());
  46
  47         public Either<ArtifactDefinition, StorageOperationStatus> addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, String instanceId) {
  48
  49                 Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(parentId, artifactInfo, type, artifactInfo.getUniqueId(), instanceId, false);
  50                 if (status.isRight()) {
  51
  52                         log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), parentId, status.right().value());
  53                         BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
  54                         return Either.right(status.right().value());
  55                 } else {
  56
  57                         ArtifactDataDefinition artifactData = status.left().value();
  58
  59                         ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
  60                         log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
  61                         return Either.left(artifactDefResult);
  62                 }
  63
  64         }
  65
  66         public Either<ArtifactDefinition, StorageOperationStatus> updateArifactOnResource(ArtifactDefinition artifactInfo, String id, String artifactId, NodeTypeEnum type, String instanceId) {
  67
  68                 Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(id, artifactInfo, type, artifactId, instanceId, true);
  69                 if (status.isRight()) {
  70
  71                         log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), id, status.right().value());
  72                         BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
  73                         return Either.right(status.right().value());
  74                 } else {
  75
  76                         ArtifactDataDefinition artifactData = status.left().value();
  77
  78                         ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
  79                         log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
  80                         return Either.left(artifactDefResult);
  81                 }
  82         }
  83
  84         public Either<Boolean, StorageOperationStatus> isCloneNeeded(String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum type) {
  85                 ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();
  86
  87                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
  88                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
  89                 return super.isCloneNeeded(parentId, edgeLabelEnum);
  90         }
  91
  92         public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id) {
  93                 return getArtifactById(parentId, id, null, null);
  94         }
  95
  96         public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id, ComponentTypeEnum componentType, String containerId) {
  97                 Either<ArtifactDefinition, StorageOperationStatus> result = null;
  98                 ArtifactDataDefinition foundArtifact = null;
  99                 if (componentType != null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
 100                         foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 101                         if ( foundArtifact == null ){
 102                                 foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 103                         }
 104                 }
 105                 if (foundArtifact == null) {
 106                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 107                 }
 108                 if (foundArtifact == null) {
 109                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.TOSCA_ARTIFACTS);
 110                 }
 111
 112                 if (foundArtifact == null) {
 113                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.ARTIFACTS);
 114                 }
 115
 116                 if (foundArtifact == null) {
 117                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 118                 }
 119
 120                 if (foundArtifact == null) {
 121                         result = Either.right(StorageOperationStatus.NOT_FOUND);
 122                         return result;
 123                 }
 124
 125                 ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(null, foundArtifact);
 126                 return Either.left(artifactDefResult);
 127
 128         }
 129
 130         public Either<ArtifactDefinition, StorageOperationStatus> removeArifactFromResource(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 131                 Either<ArtifactDefinition, StorageOperationStatus> status = removeArtifactOnGraph(id, artifactId, type, deleteMandatoryArtifact);
 132
 133                 if (status.isRight()) {
 134
 135                         log.debug("Failed to delete artifact {} of resource {}", artifactId, id);
 136
 137                         BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("Delete Artifact", artifactId, String.valueOf(status.right().value()));
 138                         return Either.right(status.right().value());
 139                 } else {
 140
 141                         return Either.left(status.left().value());
 142                 }
 143         }
 144
 145         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) {
 146
 147                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, parentType);
 148                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 149
 150                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> foundArtifact = null;
 151                 Map<String, ArtifactDefinition> resMap = new HashMap<>();
 152                 foundArtifact = getArtifactByLabel(parentId, instanceId, edgeLabelEnum);
 153                 if (foundArtifact.isRight()) {
 154                         log.debug("Failed to find artifact in component {} with label {} ", parentId, edgeLabelEnum);
 155                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(foundArtifact.right().value()));
 156                 }
 157
 158                 resMap.putAll(foundArtifact.left().value());
 159
 160                 return Either.left(resMap);
 161         }
 162
 163         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId) {
 164
 165                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> foundArtifact = null;
 166                 Map<String, ArtifactDefinition> resMap = new HashMap<>();
 167                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.ARTIFACTS);
 168                 if (foundArtifact.isLeft()) {
 169                         resMap.putAll(foundArtifact.left().value());
 170
 171                 }
 172                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 173                 if (foundArtifact.isLeft()) {
 174                         resMap.putAll(foundArtifact.left().value());
 175
 176                 }
 177                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.TOSCA_ARTIFACTS);
 178                 if (foundArtifact.isLeft()) {
 179                         resMap.putAll(foundArtifact.left().value());
 180
 181                 }
 182
 183                 return Either.left(resMap);
 184
 185         }
 186
 187         public Either<ArtifactDefinition, StorageOperationStatus> removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 188
 189                 Either<ArtifactDefinition, StorageOperationStatus> artifactData = this.getArtifactById(id, artifactId);
 190                 if (artifactData.isRight()) {
 191                         log.debug("Failed to find artifact in component {} with id {} ", id, artifactId);
 192                         return Either.right(artifactData.right().value());
 193                 }
 194                 ArtifactDataDefinition artifactDefinition = artifactData.left().value();
 195                 boolean isMandatory = false;
 196                 if ((artifactDefinition.getMandatory() || artifactDefinition.getServiceApi()) && !deleteMandatoryArtifact) {
 197                         // return Either.left(artifactData.left().value());
 198                         isMandatory = true;
 199                 }
 200
 201                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactDefinition.getArtifactGroupType(), type);
 202                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 203                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 204
 205                 if (!isMandatory) {
 206                         StorageOperationStatus status = deleteToscaDataElement(id, edgeLabelEnum, vertexTypeEnum, artifactDefinition.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
 207                         if (status != StorageOperationStatus.OK)
 208                                 return Either.right(status);
 209                 }
 210
 211                 return Either.left(artifactData.left().value());
 212
 213         }
 214
 215         public void updateUUID(ArtifactDataDefinition artifactData, String oldChecksum, String oldVesrion, boolean isUpdate) {
 216                 if (oldVesrion == null || oldVesrion.isEmpty())
 217                         oldVesrion = "0";
 218
 219                 String currentChecksum = artifactData.getArtifactChecksum();
 220                 if(isUpdate && artifactData.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())){
 221                         generateUUID(artifactData, oldVesrion);
 222                 }
 223                 if (oldChecksum == null || oldChecksum.isEmpty()) {
 224                         if (currentChecksum != null) {
 225                                 generateUUID(artifactData, oldVesrion);
 226                         }
 227                 } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) {
 228                         generateUUID(artifactData, oldVesrion);
 229                 }
 230
 231         }
 232
 233         // @TODO add implementation
 234
 235         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType) {
 236                 return null;
 237         }
 238
 239         public Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifactHeat, String componentId, NodeTypeEnum parentType, boolean failIfExist, String instanceId) {
 240                 artifactHeatEnv.setGeneratedFromId(artifactHeat.getUniqueId());
 241                 return addArifactToComponent(artifactHeatEnv, componentId, parentType, failIfExist, instanceId);
 242         }
 243
 244         public Either<ArtifactDefinition, StorageOperationStatus> getHeatArtifactByHeatEnvId(String parentId, ArtifactDefinition heatEnv, NodeTypeEnum parentType, String containerId, ComponentTypeEnum componentType) {
 245                 String id = heatEnv.getGeneratedFromId();
 246                 ComponentTypeEnum compType;
 247                 switch (parentType) {
 248                 case ResourceInstance:
 249                         compType = ComponentTypeEnum.RESOURCE_INSTANCE;
 250                         break;
 251                 default:
 252                         compType = componentType;
 253                 }
 254                 return getArtifactById(parentId, id, compType, containerId);
 255         }
 256
 257         public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvArtifact(String id, ArtifactDefinition artifactEnvInfo, String artifactId, String newArtifactId, NodeTypeEnum type, String instanceId) {
 258
 259                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> artifactsEither = getArtifactByLabel(id, instanceId, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 260                 if (artifactsEither.isRight()) {
 261                         log.debug("Failed to find artifacts in component {} with id {} ", id, artifactsEither.right().value());
 262                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(artifactsEither.right().value()));
 263                 }
 264
 265                 Map<String, ArtifactDefinition> artifacts = artifactsEither.left().value();
 266                 List<ArtifactDefinition> envList = artifacts.values().stream().filter(a -> a.getGeneratedFromId()!= null && a.getGeneratedFromId().equals(artifactId)).collect(Collectors.toList());
 267                 if (envList != null && !envList.isEmpty()) {
 268                         envList.forEach(a -> {
 269                                 a.setGeneratedFromId(newArtifactId);
 270                                 updateArifactOnResource(a, id, a.getUniqueId(), type, instanceId);
 271
 272                         });
 273
 274                 }
 275                 return Either.left(artifactEnvInfo);
 276         }
 277
 278         public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvPlaceholder(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type) {
 279                 return updateArifactOnResource(artifactInfo, parentId, artifactInfo.getUniqueId(), type, null);
 280         }
 281
 282         // public Either<List<HeatParameterDefinition>, StorageOperationStatus> getHeatParamsForEnv(ArtifactDefinition heatEnvArtifact, String parentId) {
 283         // return null;
 284         // }
 285
 286         ///////////////////////////////////////////// private methods ////////////////////////////////////////////////////
 287
 288         protected ArtifactDefinition convertArtifactDataToArtifactDefinition(ArtifactDefinition artifactInfo, ArtifactDataDefinition artifactDefResult) {
 289                 log.debug("The object returned after create property is {}", artifactDefResult);
 290
 291                 ArtifactDefinition propertyDefResult = new ArtifactDefinition(artifactDefResult);
 292                 if (artifactInfo != null)
 293                         propertyDefResult.setPayload(artifactInfo.getPayloadData());
 294
 295                 List<HeatParameterDefinition> parameters = new ArrayList<HeatParameterDefinition>();
 296                 /*
 297                  * StorageOperationStatus heatParametersOfNode = heatParametersOperation.getHeatParametersOfNode(NodeTypeEnum.ArtifactRef, artifactDefResult.getUniqueId().toString(), parameters); if ((heatParametersOfNode.equals(StorageOperationStatus.OK))
 298                  * && !parameters.isEmpty()) { propertyDefResult.setHeatParameters(parameters); }
 299                  */
 300                 return propertyDefResult;
 301         }
 302
 303         private ArtifactDataDefinition getInstanceArtifactByLabelAndId(String parentId, String id, String containerId, EdgeLabelEnum edgeLabelEnum) {
 304                 ArtifactDataDefinition foundArtifact = null;
 305                 Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> artifactsEither = getDataFromGraph(containerId, edgeLabelEnum);
 306                 if (artifactsEither.isRight()) {
 307                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, containerId, artifactsEither.right().value());
 308                         return null;
 309                 }
 310
 311                 Map<String, MapArtifactDataDefinition> artifacts = artifactsEither.left().value();
 312
 313                 MapArtifactDataDefinition artifactsPerInstance = artifacts.get(parentId);
 314                 if (artifactsPerInstance == null) {
 315                         log.debug("failed to fetch artifacts for instance {} in tosca element with id {}, error {}", parentId, containerId, artifactsEither.right().value());
 316                         return null;
 317                 }
 318                 Optional<ArtifactDataDefinition> op = artifactsPerInstance.getMapToscaDataDefinition().values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
 319                 if (op.isPresent()) {
 320                         foundArtifact = op.get();
 321                 }
 322                 return foundArtifact;
 323         }
 324
 325         private ArtifactDataDefinition getArtifactByLabelAndId(String parentId, String id, EdgeLabelEnum edgeLabelEnum) {
 326                 ArtifactDataDefinition foundArtifact = null;
 327                 Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> artifactsEither = getDataFromGraph(parentId, edgeLabelEnum);
 328                 if (artifactsEither.isRight()) {
 329                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, artifactsEither.right().value());
 330                         return null;
 331                 }
 332
 333                 Map<String, ArtifactDataDefinition> artifacts = artifactsEither.left().value();
 334                 Optional<ArtifactDataDefinition> op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
 335                 if (op.isPresent()) {
 336                         foundArtifact = op.get();
 337                 }
 338                 return foundArtifact;
 339         }
 340
 341         private Either<Map<String, ArtifactDefinition>, TitanOperationStatus> getArtifactByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
 342
 343                 Map<String, ArtifactDefinition> artMap = null;
 344                 Map<String, ArtifactDataDefinition> artifactDataMap = null;
 345
 346                 if (edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 347                         Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum);
 348                         if (resultEither.isRight()) {
 349                                 log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, resultEither.right().value());
 350                                 return Either.right(resultEither.right().value());
 351                         }
 352                         artifactDataMap = resultEither.left().value();
 353                 }else{
 354                         Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum);
 355                         if (resultEither.isRight()) {
 356                                 log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, resultEither.right().value());
 357                                 return Either.right(resultEither.right().value());
 358                         }
 359                         Map<String, MapArtifactDataDefinition> mapArtifacts = resultEither.left().value();
 360                         MapArtifactDataDefinition artifactPerInstance = mapArtifacts.get(instanceId);
 361                         if ( artifactPerInstance != null ){
 362                                 artifactDataMap = artifactPerInstance.getMapToscaDataDefinition();
 363                         }
 364                 }
 365                 if (artifactDataMap != null && !artifactDataMap.isEmpty()) {
 366                         artMap = artifactDataMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> convertArtifactDataToArtifactDefinition(null, e.getValue())));
 367                 }else{
 368                         artMap = new HashMap<>();
 369                 }
 370                 return Either.left(artMap);
 371
 372         }
 373
 374         private Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> getEdgeLabelEnumFromArtifactGroupType(ArtifactGroupTypeEnum groupType, NodeTypeEnum nodeType) {
 375                 EdgeLabelEnum edgeLabelEnum;
 376                 VertexTypeEnum vertexTypeEnum;
 377                 Boolean isDeepElement = false;
 378                 /*
 379                  * if (nodeType == NodeTypeEnum.ResourceInstance) { edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; isDeepElement = true; } else {
 380                  */
 381                 switch (groupType) {
 382                 case TOSCA:
 383                         edgeLabelEnum = EdgeLabelEnum.TOSCA_ARTIFACTS;
 384                         vertexTypeEnum = VertexTypeEnum.TOSCA_ARTIFACTS;
 385                         break;
 386                 case DEPLOYMENT:
 387                         if (nodeType == NodeTypeEnum.ResourceInstance) {
 388                                 edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS;
 389                                 vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS;
 390                                 isDeepElement = true;
 391                         } else {
 392                                 edgeLabelEnum = EdgeLabelEnum.DEPLOYMENT_ARTIFACTS;
 393                                 vertexTypeEnum = VertexTypeEnum.DEPLOYMENT_ARTIFACTS;
 394                         }
 395                         break;
 396                 case SERVICE_API:
 397                         edgeLabelEnum = EdgeLabelEnum.SERVICE_API_ARTIFACTS;
 398                         vertexTypeEnum = VertexTypeEnum.SERVICE_API_ARTIFACTS;
 399                         break;
 400                 default:
 401                         if (nodeType == NodeTypeEnum.ResourceInstance) {
 402                                 edgeLabelEnum = EdgeLabelEnum.INSTANCE_ARTIFACTS;
 403                                 vertexTypeEnum = VertexTypeEnum.INSTANCE_ARTIFACTS;
 404                                 isDeepElement = true;
 405                         } else {
 406                                 edgeLabelEnum = EdgeLabelEnum.ARTIFACTS;
 407                                 vertexTypeEnum = VertexTypeEnum.ARTIFACTS;
 408                         }
 409                         break;
 410                 }
 411                 // }
 412                 return new ImmutableTriple<EdgeLabelEnum, Boolean, VertexTypeEnum>(edgeLabelEnum, isDeepElement, vertexTypeEnum);
 413
 414         }
 415
 416         public Either<ArtifactDataDefinition, StorageOperationStatus> updateArtifactOnGraph(String componentId, ArtifactDefinition artifactInfo, NodeTypeEnum type, String artifactId, String instanceId, boolean isUpdate) {
 417                 Either<ArtifactDataDefinition, StorageOperationStatus> res = null;
 418                 ArtifactDataDefinition artifactToUpdate = new ArtifactDataDefinition(artifactInfo);
 419                 ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();
 420
 421                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
 422                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 423                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 424
 425                 Either<Boolean, StorageOperationStatus> isNeedToCloneEither = isCloneNeeded(componentId, edgeLabelEnum);
 426                 if (isNeedToCloneEither.isRight()) {
 427                         log.debug("Failed check is clone needed {}", componentId);
 428                         return Either.right(isNeedToCloneEither.right().value());
 429
 430                 }
 431                 boolean isNeedToClone = isNeedToCloneEither.left().value();
 432
 433                 if (artifactId == null || isNeedToClone) {
 434                         String uniqueId;
 435                         if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 436                                 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel());
 437                         } else {
 438                                 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(instanceId, artifactToUpdate.getArtifactLabel());
 439                         }
 440                         artifactToUpdate.setUniqueId(uniqueId);
 441
 442                 } else
 443                         artifactToUpdate.setUniqueId(artifactId);
 444
 445                 Map<String, ArtifactDataDefinition> artifacts = null;
 446                 if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 447
 448                         Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);
 449
 450                         if (artifactsEither.isLeft() && artifactsEither.left().value() != null && !artifactsEither.left().value().isEmpty()) {
 451                                 artifacts = artifactsEither.left().value();
 452                                 if (isNeedToClone) {
 453                                         artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE));
 454                                 }
 455                         }
 456                 } else {
 457                         Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);
 458                         if (artifactsEither.isLeft()) {
 459                                 Map<String, MapArtifactDataDefinition> artifactInst = artifactsEither.left().value();
 460                                 if (isNeedToClone) {
 461                                         artifactInst.values().forEach(ma -> ma.getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
 462                                 }
 463                                 MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId);
 464                                 if (artifatcsOnInstance != null) {
 465                                         artifacts = artifatcsOnInstance.getMapToscaDataDefinition();
 466                                 }
 467                         }
 468                 }
 469                 String oldChecksum = null;
 470                 String oldVersion = null;
 471                 if (artifacts != null && artifacts.containsKey(artifactInfo.getArtifactLabel())) {
 472                         ArtifactDataDefinition oldArtifactData = artifacts.get(artifactInfo.getArtifactLabel());
 473                         oldChecksum = oldArtifactData.getArtifactChecksum();
 474                         oldVersion = oldArtifactData.getArtifactVersion();
 475                         if (isNeedToClone)
 476                                 artifactToUpdate.setDuplicated(Boolean.FALSE);
 477                         else {
 478                                 if (artifactToUpdate.getDuplicated()) {
 479                                         String id = type != NodeTypeEnum.ResourceInstance ? componentId : instanceId;
 480                                         String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(id, artifactToUpdate.getArtifactLabel());
 481                                         artifactToUpdate.setUniqueId(uniqueId);
 482                                         artifactToUpdate.setDuplicated(Boolean.TRUE);
 483                                 }
 484                         }
 485                 }
 486                 updateUUID(artifactToUpdate, oldChecksum, oldVersion, isUpdate);
 487
 488                 if (artifactInfo.getPayloadData() == null) {
 489                         if (!artifactToUpdate.getMandatory() || artifactToUpdate.getEsId() != null) {
 490                                 artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
 491                         }
 492                 } else {
 493                         if (artifactToUpdate.getEsId() == null) {
 494                                 artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
 495
 496                         }
 497                 }
 498
 499                 StorageOperationStatus status;
 500                 if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 501                         status = updateToscaDataOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactToUpdate, JsonPresentationFields.ARTIFACT_LABEL);
 502                 } else {
 503                         List<String> pathKeys = new ArrayList<>();
 504                         pathKeys.add(instanceId);
 505                         List<ArtifactDataDefinition> toscaDataList = new ArrayList<>();
 506                         toscaDataList.add(artifactToUpdate);
 507                         status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
 508                 }
 509                 if (status == StorageOperationStatus.OK)
 510                         res = Either.left(artifactToUpdate);
 511                 else
 512                         res = Either.right(status);
 513                 return res;
 514         }
 515
 516         public void generateUUID(ArtifactDataDefinition artifactData, String oldVesrion) {
 517
 518                 UUID uuid = UUID.randomUUID();
 519                 artifactData.setArtifactUUID(uuid.toString());
 520                 MDC.put("serviceInstanceID", uuid.toString());
 521                 updateVersionAndDate(artifactData, oldVesrion);
 522         }
 523
 524         private void updateVersionAndDate(ArtifactDataDefinition artifactData, String oldVesrion) {
 525                 if (artifactData.getArtifactChecksum() != null) {
 526                         long time = System.currentTimeMillis();
 527                         artifactData.setPayloadUpdateDate(time);
 528                 }
 529                 int newVersion = new Integer(oldVesrion).intValue();
 530                 newVersion++;
 531                 artifactData.setArtifactVersion(String.valueOf(newVersion));
 532         }
 533
 534         private boolean validateParentType(NodeTypeEnum type) {
 535                 boolean isValid = false;
 536                 switch (type) {
 537                 case Resource:
 538                 case InterfaceOperation:
 539                 case Service:
 540                 case ResourceInstance:
 541                         isValid = true;
 542                         break;
 543                 default:
 544                         log.debug("Not supported node type for artifact relation : {} ", type);
 545                 }
 546                 return isValid;
 547         }
 548
 549         public Either<ArtifactDataDefinition, StorageOperationStatus> removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 550
 551                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type);
 552                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 553                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 554
 555                 if (deleteMandatoryArtifact || !(artifactFromGraph.getMandatory() || artifactFromGraph.getServiceApi())) {
 556                         StorageOperationStatus status;
 557                         if (triple.getMiddle()) {
 558                                 List<String> pathKeys = new ArrayList<>();
 559                                 pathKeys.add(instanceId);
 560                                 status = deleteToscaDataDeepElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
 561                         } else {
 562                                 status = deleteToscaDataElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
 563                         }
 564                         if (status != StorageOperationStatus.OK)
 565                                 return Either.right(status);
 566                 }
 567                 return Either.left(artifactFromGraph);
 568
 569         }
 570
 571         public Either<ArtifactDataDefinition, StorageOperationStatus> deleteArtifactWithClonnigOnGraph(String componentId, ArtifactDefinition artifactToDelete, NodeTypeEnum type, String instanceId, boolean deleteMandatoryArtifact) {
 572
 573                 Either<ArtifactDataDefinition, StorageOperationStatus> result = null;
 574                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactToDelete.getArtifactGroupType(), type);
 575                 EdgeLabelEnum edgeLabel = triple.getLeft();
 576                 VertexTypeEnum vertexLabel = triple.getRight();
 577
 578                 Boolean deleteElement = deleteMandatoryArtifact || !(artifactToDelete.getMandatory() || artifactToDelete.getServiceApi());
 579                 Map<String, ToscaDataDefinition> artifacts = null;
 580                 GraphVertex parentVertex = null;
 581                 Either<Map<String, ToscaDataDefinition>, TitanOperationStatus> getArtifactsRes = null;
 582
 583                 Either<GraphVertex, TitanOperationStatus> getToscaElementRes = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
 584                 if (getToscaElementRes.isRight()) {
 585                         CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", componentId, getToscaElementRes.right().value());
 586                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
 587                 }
 588                 if (result == null) {
 589                         parentVertex = getToscaElementRes.left().value();
 590                         getArtifactsRes = this.getDataFromGraph(parentVertex, edgeLabel);
 591                         if (getArtifactsRes.isRight()) {
 592                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getArtifactsRes.right().value()));
 593                         }
 594                 }
 595                 if (result == null) {
 596                         artifacts = getArtifactsRes.left().value();
 597                         if (triple.getMiddle()) {
 598                                 artifacts.values().forEach(ma -> ((MapArtifactDataDefinition) ma).getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
 599                                 MapArtifactDataDefinition artifatcsOnInstance = (MapArtifactDataDefinition) artifacts.get(instanceId);
 600                                 if (artifatcsOnInstance != null && deleteElement) {
 601                                         artifatcsOnInstance.getMapToscaDataDefinition().remove(artifactToDelete.getArtifactLabel());
 602                                 }
 603                         } else {
 604                                 if (deleteElement) {
 605                                         artifacts.remove(artifactToDelete.getArtifactLabel());
 606                                 }
 607                                 artifacts.values().stream().forEach(a -> ((ArtifactDataDefinition) a).setDuplicated(Boolean.TRUE));
 608                         }
 609                         artifactToDelete.setDuplicated(Boolean.TRUE);
 610                 }
 611                 if (artifacts != null) {
 612                         TitanOperationStatus status = titanDao.deleteEdgeByDirection(parentVertex, Direction.OUT, edgeLabel);
 613                         if (status != TitanOperationStatus.OK) {
 614                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 615                         } else if (MapUtils.isNotEmpty(artifacts)) {
 616                                 Either<GraphVertex, StorageOperationStatus> assosiateRes = assosiateElementToData(parentVertex, vertexLabel, edgeLabel, artifacts);
 617                                 if (assosiateRes.isRight()) {
 618                                         result = Either.right(result.right().value());
 619                                 }
 620                         }
 621                 }
 622                 if (result == null) {
 623                         result = Either.left(artifactToDelete);
 624                 }
 625                 return result;
 626         }
 627 }