gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.be.model.jsontitan.operations;
   2
   3 import java.util.ArrayList;
   4 import java.util.EnumMap;
   5 import java.util.HashMap;
   6 import java.util.Iterator;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Optional;
  10 import java.util.Map.Entry;
  11 import java.util.stream.Collectors;
  12
  13 import org.apache.commons.collections.CollectionUtils;
  14 import org.apache.commons.collections.MapUtils;
  15 import org.apache.commons.lang.StringUtils;
  16 import org.apache.commons.lang3.tuple.ImmutablePair;
  17 import org.apache.tinkerpop.gremlin.structure.Direction;
  18 import org.apache.tinkerpop.gremlin.structure.Edge;
  19 import org.apache.tinkerpop.gremlin.structure.Vertex;
  20
  21 import org.openecomp.sdc.be.config.ConfigurationManager;
  22 import org.openecomp.sdc.be.dao.api.ActionStatus;
  23 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  24 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  25 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
  26 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  27 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  28 import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils;
  29 import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils;
  30 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  31 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  32 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  34 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
  38 import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
  40 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  42 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  43 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  44 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  45 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  46 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  48 import org.openecomp.sdc.be.model.ArtifactDefinition;
  49 import org.openecomp.sdc.be.model.ComponentParametersView;
  50 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  51 import org.openecomp.sdc.be.model.GroupDefinition;
  52 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  53 import org.openecomp.sdc.be.model.User;
  54 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
  55 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
  56 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
  57 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  58 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  59 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  60 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  61 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  62 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  63 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
  64 import org.openecomp.sdc.exception.ResponseFormat;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67
  68 import fj.data.Either;
  69
  70 @org.springframework.stereotype.Component("tosca-element-lifecycle-operation")
  71
  72 /**
  73  * Allows to perform lifecycle operations: checkin, checkout, submit for testing, start certification and certification process for tosca element
  74  */
  75 public class ToscaElementLifecycleOperation extends BaseOperation {
  76
  77         private static final String FAILED_TO_GET_VERTICES = "Failed to get vertices by id {}. Status is {}. ";
  78         public static final String VERSION_DELIMETER = ".";
  79         public static final String VERSION_DELIMETER_REGEXP = "\\.";
  80
  81         private static Logger logger = LoggerFactory.getLogger(ToscaElementLifecycleOperation.class.getName());
  82
  83         /**
  84          * Performs changing a lifecycle state of tosca element from "checked out" or "ready for certification" to "checked in"
  85          *
  86          * @param currState
  87          * @param toscaElementId
  88          * @param modifierId
  89          * @param ownerId
  90          * @return
  91          */
  92         public Either<ToscaElement, StorageOperationStatus> checkinToscaELement(LifecycleStateEnum currState, String toscaElementId, String modifierId, String ownerId) {
  93                 Either<GraphVertex, StorageOperationStatus> updateResult = null;
  94                 Either<ToscaElement, StorageOperationStatus> result = null;
  95                 Map<String, GraphVertex> vertices = null;
  96                 ToscaElementOperation operation;
  97                 try {
  98                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckin(toscaElementId, modifierId, ownerId));
  99                         if (getVerticesRes.isRight()) {
 100                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 101                                 updateResult = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 102                         } else {
 103                                 vertices = getVerticesRes.left().value();
 104                                 updateResult = checkinToscaELement(currState, vertices.get(toscaElementId), vertices.get(ownerId), vertices.get(modifierId), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 105                         }
 106                         if (updateResult.isLeft()) {
 107                                 ComponentParametersView componentParametersView = buildComponentParametersViewAfterCheckin();
 108                                 operation = getToscaElementOperation(vertices.get(toscaElementId).getLabel());
 109                                 result = operation.getToscaElement(updateResult.left().value().getUniqueId(), componentParametersView);
 110                                 if (result.isRight()) {
 111                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to get updated tosca element {}. Status is {}", toscaElementId, result.right().value());
 112                                 }
 113                         } else {
 114                                 result = Either.right(updateResult.right().value());
 115                         }
 116                 } catch (Exception e) {
 117                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during checkin of tosca element {}. {} ", toscaElementId, e.getMessage());
 118                 }
 119                 return result;
 120         }
 121
 122         /**
 123          * Returns vertex presenting owner of tosca element specified by uniqueId
 124          *
 125          * @param toscaElement
 126          * @return
 127          */
 128         public Either<User, StorageOperationStatus> getToscaElementOwner(String toscaElementId) {
 129                 Either<User, StorageOperationStatus> result = null;
 130                 GraphVertex toscaElement = null;
 131                 Either<GraphVertex, TitanOperationStatus> getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
 132                 if (getToscaElementRes.isRight()) {
 133                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
 134                 }
 135                 if (result == null) {
 136                         toscaElement = getToscaElementRes.left().value();
 137                         Iterator<Vertex> vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name());
 138                         if (vertices == null || !vertices.hasNext()) {
 139                                 result = Either.right(StorageOperationStatus.NOT_FOUND);
 140                         } else {
 141                                 result = Either.left(convertToUser(vertices.next()));
 142                         }
 143                 }
 144                 return result;
 145         }
 146
 147         /**
 148          * Returns vertex presenting owner of tosca element specified by uniqueId
 149          *
 150          * @param toscaElement
 151          * @return
 152          */
 153         public Either<User, StorageOperationStatus> getToscaElementOwner(GraphVertex toscaElement) {
 154                 Either<User, StorageOperationStatus> result = null;
 155                 Iterator<Vertex> vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name());
 156                 if (vertices == null || !vertices.hasNext()) {
 157                         result = Either.right(StorageOperationStatus.NOT_FOUND);
 158                 } else {
 159                         result = Either.left(convertToUser(vertices.next()));
 160                 }
 161                 return result;
 162         }
 163
 164         /**
 165          * Performs checkout of a tosca element
 166          *
 167          * @param toscaElementId
 168          * @param modifierId
 169          * @param ownerId
 170          * @param currState
 171          * @return
 172          */
 173         public Either<ToscaElement, StorageOperationStatus> checkoutToscaElement(String toscaElementId, String modifierId, String ownerId) {
 174                 Either<ToscaElement, StorageOperationStatus> result = null;
 175                 Map<String, GraphVertex> vertices = null;
 176                 try {
 177                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckout(toscaElementId, modifierId, ownerId));
 178                         if (getVerticesRes.isRight()) {
 179                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 180                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 181                         }
 182                         if (result == null) {
 183                                 vertices = getVerticesRes.left().value();
 184                                 // update previous component if not certified
 185                                 StorageOperationStatus status = updatePreviousVersion(vertices.get(toscaElementId), vertices.get(ownerId));
 186                                 if (status != StorageOperationStatus.OK) {
 187                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update vertex with id {} . Status is {}. ", status);
 188                                         result = Either.right(status);
 189                                 }
 190                         }
 191                         if (result == null) {
 192                                 result = cloneToscaElementForCheckout(vertices.get(toscaElementId), vertices.get(modifierId));
 193                                 if (result.isRight()) {
 194                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to checkout tosca element {}. Status is {} ", toscaElementId, result.right().value());
 195                                 }
 196
 197                         }
 198                 } catch (Exception e) {
 199                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during checkout tosca element {}. {}", toscaElementId, e.getMessage());
 200                 }
 201                 return result;
 202         }
 203
 204         /**
 205          * Performs undo checkout for tosca element
 206          *
 207          * @param toscaElementId
 208          * @return
 209          */
 210         public Either<ToscaElement, StorageOperationStatus> undoCheckout(String toscaElementId) {
 211                 Either<ToscaElement, StorageOperationStatus> result = null;
 212                 Either<GraphVertex, TitanOperationStatus> getToscaElementRes = null;
 213                 Iterator<Edge> nextVersionComponentIter = null;
 214                 ToscaElementOperation operation;
 215                 try {
 216                         getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata);
 217                         if (getToscaElementRes.isRight()) {
 218                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 219                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
 220                         }
 221                         if (result == null && hasPreviousVersion(getToscaElementRes.left().value())) {
 222                                 // find previous version
 223                                 nextVersionComponentIter = getToscaElementRes.left().value().getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name());
 224                                 if (nextVersionComponentIter == null || !nextVersionComponentIter.hasNext()) {
 225                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch previous version of tosca element with name {}. ", getToscaElementRes.left().value().getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString());
 226                                         result = Either.right(StorageOperationStatus.NOT_FOUND);
 227                                 }
 228                                 if (result == null) {
 229                                         StorageOperationStatus updateOldResourceResult = updateOldToscaElementBeforeUndoCheckout(nextVersionComponentIter.next().outVertex());
 230                                         if (updateOldResourceResult != StorageOperationStatus.OK) {
 231                                                 result = Either.right(updateOldResourceResult);
 232                                         }
 233                                 }
 234                         }
 235                         if (result == null) {
 236                                 operation = getToscaElementOperation(getToscaElementRes.left().value().getLabel());
 237                                 result = operation.deleteToscaElement(getToscaElementRes.left().value());
 238                         }
 239                 } catch (Exception e) {
 240                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during undo checkout tosca element {}. {}", toscaElementId, e.getMessage());
 241                 }
 242                 return result;
 243         }
 244
 245         private boolean hasPreviousVersion(GraphVertex toscaElementVertex) {
 246                 boolean hasPreviousVersion = true;
 247                 String version = (String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION);
 248                 if (StringUtils.isEmpty(version) || version.equals("0.1"))
 249                         hasPreviousVersion = false;
 250                 return hasPreviousVersion;
 251         }
 252
 253         /**
 254          * Performs request certification for tosca element
 255          *
 256          * @param toscaElementId
 257          * @param modifierId
 258          * @param ownerId
 259          * @return
 260          */
 261         public Either<ToscaElement, StorageOperationStatus> requestCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) {
 262                 Either<GraphVertex, StorageOperationStatus> resultUpdate = null;
 263                 Either<ToscaElement, StorageOperationStatus> result = null;
 264                 GraphVertex toscaElement = null;
 265                 GraphVertex modifier = null;
 266                 GraphVertex owner;
 267                 try {
 268                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
 269                         if (getVerticesRes.isRight()) {
 270                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 271                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 272                         }
 273                         if (result == null) {
 274                                 toscaElement = getVerticesRes.left().value().get(toscaElementId);
 275                                 modifier = getVerticesRes.left().value().get(modifierId);
 276                                 owner = getVerticesRes.left().value().get(ownerId);
 277
 278                                 StorageOperationStatus status = handleRelationsUponRequestForCertification(toscaElement, modifier, owner);
 279                                 if (status != StorageOperationStatus.OK) {
 280                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations on certification request for tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status);
 281                                 }
 282                         }
 283                         if (result == null) {
 284                                 LifecycleStateEnum nextState = LifecycleStateEnum.READY_FOR_CERTIFICATION;
 285
 286                                 toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name());
 287                                 toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
 288
 289                                 resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement);
 290                                 if (resultUpdate.isRight()) {
 291                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to set lifecycle for tosca elememt {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value());
 292                                         result = Either.right(resultUpdate.right().value());
 293                                 }
 294                         }
 295                         if (result == null) {
 296                                 ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel());
 297                                 result = operation.getToscaElement(toscaElement.getUniqueId());
 298                         }
 299                         return result;
 300
 301                 } catch (Exception e) {
 302                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during request certification tosca element {}. {}", toscaElementId, e.getMessage());
 303                 }
 304                 return result;
 305         }
 306
 307         /**
 308          * Starts certification of tosca element
 309          *
 310          * @param toscaElementId
 311          * @param modifierId
 312          * @param ownerId
 313          * @return
 314          */
 315         public Either<ToscaElement, StorageOperationStatus> startCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) {
 316                 Either<ToscaElement, StorageOperationStatus> result = null;
 317                 Either<GraphVertex, StorageOperationStatus> resultUpdate = null;
 318                 GraphVertex toscaElement = null;
 319                 GraphVertex modifier = null;
 320                 GraphVertex owner;
 321                 try {
 322                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
 323                         if (getVerticesRes.isRight()) {
 324                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 325                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 326                         }
 327                         if (result == null) {
 328                                 toscaElement = getVerticesRes.left().value().get(toscaElementId);
 329                                 modifier = getVerticesRes.left().value().get(modifierId);
 330                                 owner = getVerticesRes.left().value().get(ownerId);
 331
 332                                 StorageOperationStatus status = handleRelationsUponCertification(toscaElement, modifier, owner);
 333                                 if (status != StorageOperationStatus.OK) {
 334                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations during certification of tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status);
 335                                 }
 336                         }
 337                         if (result == null) {
 338                                 LifecycleStateEnum nextState = LifecycleStateEnum.CERTIFICATION_IN_PROGRESS;
 339
 340                                 toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name());
 341                                 toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
 342
 343                                 resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement);
 344                                 if (resultUpdate.isRight()) {
 345                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Couldn't set lifecycle for component {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value());
 346                                         result = Either.right(resultUpdate.right().value());
 347                                 }
 348                         }
 349                         if (result == null) {
 350                                 ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel());
 351                                 result = operation.getToscaElement(toscaElement.getUniqueId());
 352                         }
 353                 } catch (Exception e) {
 354                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during start certification tosca element {}. {}", toscaElementId, e.getMessage());
 355                 }
 356                 return result;
 357         }
 358
 359         public Either<ToscaElement, StorageOperationStatus> certifyToscaElement(String toscaElementId, String modifierId, String ownerId) {
 360                 Either<ToscaElement, StorageOperationStatus> result = null;
 361                 Either<GraphVertex, StorageOperationStatus> cloneRes = null;
 362                 GraphVertex toscaElement = null;
 363                 GraphVertex modifier = null;
 364                 GraphVertex certifiedToscaElement = null;
 365                 Integer majorVersion = null;
 366
 367                 StorageOperationStatus status;
 368                 try {
 369                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
 370                         if (getVerticesRes.isRight()) {
 371                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 372                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 373                         }
 374                         if (result == null) {
 375                                 toscaElement = getVerticesRes.left().value().get(toscaElementId);
 376                                 modifier = getVerticesRes.left().value().get(modifierId);
 377                                 majorVersion = getMajorVersion((String) toscaElement.getMetadataProperty(GraphPropertyEnum.VERSION));
 378                                 status = handleRelationsOfPreviousToscaElementBeforeCertifying(toscaElement, modifier, majorVersion);
 379                                 if (status != StorageOperationStatus.OK) {
 380                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations of previous tosca element before certifying {}. Status is {}. ", toscaElement.getUniqueId(), status);
 381                                 }
 382                         }
 383                         if (result == null) {
 384                                 cloneRes = cloneToscaElementForCertify(toscaElement, modifier, majorVersion);
 385                                 if (cloneRes.isRight()) {
 386                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to clone tosca element during certification. ");
 387                                         result = Either.right(cloneRes.right().value());
 388                                 }
 389                         }
 390                         if (result == null) {
 391                                 certifiedToscaElement = cloneRes.left().value();
 392                                 status = handleRelationsOfNewestCertifiedToscaElement(toscaElement, certifiedToscaElement);
 393                                 if (status != StorageOperationStatus.OK) {
 394                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations of newest certified tosca element {}. Status is {}. ", certifiedToscaElement.getUniqueId(), status);
 395                                 }
 396                         }
 397                         if (result == null) {
 398                                 return getToscaElementOperation(toscaElement.getLabel()).getToscaElement(certifiedToscaElement.getUniqueId());
 399                         }
 400                 } catch (Exception e) {
 401                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during certification tosca element {}. {}", toscaElementId, e.getMessage());
 402                 }
 403                 return result;
 404         }
 405
 406         /**
 407          * Deletes (marks as deleted) all tosca elements according received name and uuid
 408          *
 409          * @param vertexType
 410          * @param componentType
 411          * @param componentName
 412          * @param uuid
 413          * @return
 414          */
 415         public Either<Boolean, StorageOperationStatus> deleteOldToscaElementVersions(VertexTypeEnum vertexType, ComponentTypeEnum componentType, String componentName, String uuid) {
 416
 417                 Either<Boolean, StorageOperationStatus> result = null;
 418                 ToscaElementOperation operation = getToscaElementOperation(componentType);
 419
 420                 try {
 421                         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 422                         properties.put(GraphPropertyEnum.UUID, uuid);
 423                         properties.put(GraphPropertyEnum.NAME, componentName);
 424                         Either<List<GraphVertex>, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(vertexType, properties, JsonParseFlagEnum.ParseMetadata);
 425                         if (getToscaElementsRes.isRight()) {
 426                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value()));
 427                         }
 428                         if (result == null) {
 429                                 result = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value());
 430                         }
 431                         if (result == null) {
 432                                 result = Either.left(true);
 433                         }
 434                 } catch (Exception e) {
 435                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage());
 436                 }
 437                 return result;
 438         }
 439
 440         /**
 441          * Performs cancelation or failure of certification for received tosca element
 442          *
 443          * @param toscaElementId
 444          * @param modifierId
 445          * @param ownerId
 446          * @param nextState
 447          * @return
 448          */
 449         public Either<ToscaElement, StorageOperationStatus> cancelOrFailCertification(String toscaElementId, String modifierId, String ownerId, LifecycleStateEnum nextState) {
 450                 Either<ToscaElement, StorageOperationStatus> result = null;
 451                 StorageOperationStatus status;
 452                 ToscaElementOperation operation = null;
 453                 GraphVertex toscaElement = null;
 454                 GraphVertex modifier = null;
 455                 try {
 456                         Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
 457                         if (getVerticesRes.isRight()) {
 458                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
 459                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
 460                         }
 461                         if (result == null) {
 462                                 toscaElement = getVerticesRes.left().value().get(toscaElementId);
 463                                 modifier = getVerticesRes.left().value().get(modifierId);
 464                                 operation = getToscaElementOperation(toscaElement.getLabel());
 465                                 toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
 466                                 toscaElement.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifier.getUniqueId());
 467                                 toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name());
 468
 469                                 Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElement);
 470                                 if (updateVertexRes.isRight()) {
 471                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update vertex {} . Status is {}. ", toscaElementId, updateVertexRes.right().value());
 472                                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertexRes.right().value()));
 473                                 }
 474                         }
 475                         if (result == null) {
 476                                 // cancel certification process
 477                                 status = handleRelationsUponCancelCertification(toscaElement, nextState);
 478                                 if (status != StorageOperationStatus.OK) {
 479                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations upon cancel certification {}. Status is {}. ", toscaElement.getUniqueId(), status);
 480                                 }
 481                         }
 482                         if (result == null) {
 483                                 // fail certification
 484                                 status = handleRelationsUponFailCertification(toscaElement, nextState);
 485                                 if (status != StorageOperationStatus.OK) {
 486                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to handle relations upon fail certification {}. Status is {}. ", toscaElement.getUniqueId(), status);
 487                                 }
 488                         }
 489                         if (result == null) {
 490                                 result = operation.getToscaElement(toscaElementId);
 491                         }
 492                 } catch (Exception e) {
 493                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during cancel or fail certification of tosca element {}. {}. ", toscaElementId, e.getMessage());
 494                 }
 495                 return result;
 496         }
 497
 498         public Either<GraphVertex, TitanOperationStatus> findUser(String userId) {
 499                 return findUserVertex(userId);
 500         }
 501
 502         private Either<Boolean, StorageOperationStatus> markToscaElementsAsDeleted(ToscaElementOperation operation, List<GraphVertex> toscaElements) {
 503                 Either<Boolean, StorageOperationStatus> result = Either.left(true);
 504                 for (GraphVertex resourceToDelete : toscaElements) {
 505                         if (!((String) resourceToDelete.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals(LifecycleStateEnum.CERTIFIED.name())) {
 506                                 Either<GraphVertex, StorageOperationStatus> deleteElementRes = operation.markComponentToDelete(resourceToDelete);
 507                                 if (deleteElementRes.isRight()) {
 508                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete tosca element {}. Status is {}. ", resourceToDelete.getUniqueId(), deleteElementRes.right().value());
 509                                         result = Either.right(deleteElementRes.right().value());
 510                                         break;
 511                                 }
 512                         }
 513                 }
 514                 return result;
 515         }
 516
 517         private StorageOperationStatus handleRelationsOfNewestCertifiedToscaElement(GraphVertex toscaElement, GraphVertex certifiedToscaElement) {
 518                 StorageOperationStatus result = null;
 519                 Edge foundEdge = null;
 520                 Iterator<Edge> certReqUserEdgeIter = null;
 521                 // add rfc relation to preserve follower information
 522                 // get user of certification request
 523                 certReqUserEdgeIter = toscaElement.getVertex().edges(Direction.IN, GraphEdgeLabels.LAST_STATE.name());
 524                 if (certReqUserEdgeIter == null || !certReqUserEdgeIter.hasNext()) {
 525                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. ");
 526                         result = StorageOperationStatus.NOT_FOUND;
 527                 }
 528                 if (result == null) {
 529                         TitanOperationStatus createVersionEdgeStatus = titanDao.createEdge(toscaElement, certifiedToscaElement, EdgeLabelEnum.VERSION, new HashMap<>());
 530                         if (createVersionEdgeStatus != TitanOperationStatus.OK) {
 531                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create version edge from last element {} to new certified element {}. status=", toscaElement.getUniqueId(),certifiedToscaElement.getUniqueId(), createVersionEdgeStatus);
 532                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(createVersionEdgeStatus);
 533                         }
 534                 }
 535                 if(result == null){
 536
 537                         while (certReqUserEdgeIter.hasNext()) {
 538                                 Edge edge = certReqUserEdgeIter.next();
 539                                 if (((String) titanDao.getProperty(edge, EdgePropertyEnum.STATE)).equals(LifecycleStateEnum.READY_FOR_CERTIFICATION.name())) {
 540                                         foundEdge = edge;
 541                                         break;
 542                                 }
 543
 544                         }
 545                         if (foundEdge == null) {
 546                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. ");
 547                                 result = StorageOperationStatus.NOT_FOUND;
 548                         }
 549                 }
 550                 if (result == null) {
 551                         TitanOperationStatus createEdgeRes = titanDao.createEdge(foundEdge.outVertex(), certifiedToscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, foundEdge);
 552                         if (createEdgeRes != TitanOperationStatus.OK) {
 553                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create rfc relation for component {}. status=", certifiedToscaElement.getUniqueId(), createEdgeRes);
 554                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes);
 555                         }
 556                 }
 557                 if (result == null) {
 558                         result = StorageOperationStatus.OK;
 559                 }
 560                 return result;
 561         }
 562
 563         private StorageOperationStatus handleRelationsUponFailCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) {
 564                 StorageOperationStatus result = null;
 565                 TitanOperationStatus status = null;
 566                 Edge originEdge;
 567                 Vertex user = null;
 568                 if (nextState == LifecycleStateEnum.NOT_CERTIFIED_CHECKIN) {
 569                         // fail certification
 570                         // delete relation CERTIFICATION_IN_PROGRESS
 571                         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 572                         properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
 573
 574                         Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
 575                         if (deleteResult.isRight()) {
 576                                 status = deleteResult.right().value();
 577                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", status);
 578                                 result = StorageOperationStatus.INCONSISTENCY;
 579                         }
 580                         if (result == null) {
 581                                 // delete relation READY_FOR_CERTIFICATION
 582                                 properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION);
 583                                 deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
 584                                 if (deleteResult.isRight()) {
 585                                         status = deleteResult.right().value();
 586                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete last state edge. Status is {}. ", status);
 587                                         result = StorageOperationStatus.INCONSISTENCY;
 588                                 }
 589                         }
 590                         if (result == null) {
 591                                 // delete relation NOT_CERTIFIED_CHECKIN (in order to change to STATE)
 592                                 properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 593                                 deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
 594                                 if (deleteResult.isRight()) {
 595                                         status = deleteResult.right().value();
 596                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete last state edge. Status is {}. ", status);
 597                                         result = StorageOperationStatus.INCONSISTENCY;
 598                                 }
 599                         }
 600                         if (result == null) {
 601                                 // create new STATE relation NOT_CERTIFIED_CHECKIN
 602                                 originEdge = deleteResult.left().value();
 603                                 user = originEdge.outVertex();
 604                                 status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
 605                                 if (status != TitanOperationStatus.OK) {
 606                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status);
 607                                         result = StorageOperationStatus.INCONSISTENCY;
 608                                 }
 609                         }
 610                         if (result == null) {
 611                                 // delete relation LAST_MODIFIER (in order to change tester to designer)
 612                                 deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
 613                                 if (status != TitanOperationStatus.OK) {
 614                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status);
 615                                         result = StorageOperationStatus.INCONSISTENCY;
 616                                 }
 617                         }
 618                         if (result == null) {
 619                                 // create new LAST_MODIFIER relation
 620                                 originEdge = deleteResult.left().value();
 621                                 status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.LAST_MODIFIER, originEdge);
 622                                 if (status != TitanOperationStatus.OK) {
 623                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status);
 624                                         result = StorageOperationStatus.INCONSISTENCY;
 625                                 }
 626                         }
 627                 }
 628                 if (result == null) {
 629                         result = StorageOperationStatus.OK;
 630                 }
 631                 return result;
 632         }
 633
 634         private StorageOperationStatus handleRelationsUponCancelCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) {
 635                 StorageOperationStatus result = null;
 636                 Edge originEdge;
 637                 if (nextState == LifecycleStateEnum.READY_FOR_CERTIFICATION) {
 638                         // delete relation CERTIFICATION_IN_PROGRESS
 639                         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 640                         properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
 641                         Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
 642
 643                         if (deleteResult.isRight()) {
 644                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is  {}. ", deleteResult.right().value());
 645                                 result = StorageOperationStatus.INCONSISTENCY;
 646                         }
 647                         if (result == null) {
 648                                 // delete relation READY_FOR_CERTIFICATION (LAST_STATE)
 649                                 properties.put(GraphPropertyEnum.STATE, nextState);
 650                                 deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
 651
 652                                 if (deleteResult.isRight()) {
 653                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete last state edge. Status is {}. ", deleteResult.right().value());
 654                                         result = StorageOperationStatus.INCONSISTENCY;
 655                                 }
 656                         }
 657                         if (result == null) {
 658                                 // create relation READY_FOR_CERTIFICATION (STATE)
 659                                 originEdge = deleteResult.left().value();
 660                                 TitanOperationStatus status = titanDao.createEdge(originEdge.outVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
 661                                 if (status != TitanOperationStatus.OK) {
 662                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status);
 663                                         result = StorageOperationStatus.INCONSISTENCY;
 664                                 }
 665                         }
 666                         if (result == null) {
 667                                 result = StorageOperationStatus.OK;
 668                         }
 669                 }
 670                 return result;
 671         }
 672
 673         private StorageOperationStatus handleRelationsOfPreviousToscaElementBeforeCertifying(GraphVertex toscaElement, GraphVertex modifier, Integer majorVersion) {
 674                 StorageOperationStatus result = null;
 675                 if (majorVersion > 0) {
 676                         Either<Vertex, StorageOperationStatus> findRes = findLastCertifiedToscaElementVertex(toscaElement);
 677                         if (findRes.isRight()) {
 678                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch last certified tosca element {} . Status is {}. ", toscaElement.getMetadataProperty(GraphPropertyEnum.NAME), findRes.right().value());
 679                                 result = findRes.right().value();
 680                         }
 681                         if (result == null) {
 682                                 Vertex lastCertifiedVertex = findRes.left().value();
 683                                 Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 684                                 properties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
 685                                 TitanOperationStatus status = titanDao.updateVertexMetadataPropertiesWithJson(lastCertifiedVertex, properties);
 686                                 if (status != TitanOperationStatus.OK) {
 687                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to set highest version  of tosca element {} to [{}]. Status is {}", toscaElement.getUniqueId(), false, status);
 688                                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 689                                 }
 690                         }
 691                 }
 692                 if (result == null) {
 693                         result = StorageOperationStatus.OK;
 694                 }
 695                 return result;
 696         }
 697
 698         private StorageOperationStatus handleRelationsUponRequestForCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) {
 699                 TitanOperationStatus status;
 700                 StorageOperationStatus result = null;
 701
 702                 if (((String) toscaElement.getMetadataProperty(GraphPropertyEnum.STATE)).equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
 703                         // remove CHECKOUT relation
 704                         Either<Edge, TitanOperationStatus> deleteRes = titanDao.deleteEdge(owner, toscaElement, EdgeLabelEnum.STATE);
 705                         if (deleteRes.isRight()) {
 706                                 status = deleteRes.right().value();
 707                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete edge. Status is {}. ", status);
 708                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 709                         }
 710                         if (result == null) {
 711                                 // create CHECKIN relation
 712                                 Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
 713                                 properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 714                                 status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, properties);
 715                                 if (status != TitanOperationStatus.OK) {
 716                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status);
 717                                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 718                                 }
 719                         }
 720                 } else {
 721                         status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
 722                         if (status != TitanOperationStatus.OK) {
 723                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 724                         }
 725                 }
 726                 if (result == null) {
 727                         // create RFC relation
 728                         Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
 729                         properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION);
 730                         status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, properties);
 731                         if (status != TitanOperationStatus.OK) {
 732                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status);
 733                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 734                         }
 735                 }
 736                 if (result == null) {
 737                         result = StorageOperationStatus.OK;
 738                 }
 739                 return result;
 740         }
 741
 742         private StorageOperationStatus handleRelationsUponCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) {
 743
 744                 StorageOperationStatus result = null;
 745                 TitanOperationStatus status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
 746                 if (status != TitanOperationStatus.OK) {
 747                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 748                 }
 749                 if (result == null) {
 750                         Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
 751                         properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
 752                         status = titanDao.createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties);
 753                         if (status != TitanOperationStatus.OK) {
 754                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status);
 755                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
 756                         }
 757                 }
 758                 if (result == null) {
 759                         result = StorageOperationStatus.OK;
 760                 }
 761                 return result;
 762         }
 763
 764         private Either<Vertex, StorageOperationStatus> findLastCertifiedToscaElementVertex(GraphVertex toscaElement) {
 765                 return findLastCertifiedToscaElementVertexRecursively(toscaElement.getVertex());
 766         }
 767
 768         private Either<Vertex, StorageOperationStatus> findLastCertifiedToscaElementVertexRecursively(Vertex vertex) {
 769                 if (isCertifiedVersion((String) vertex.property(GraphPropertyEnum.VERSION.getProperty()).value())) {
 770                         return Either.left(vertex);
 771                 }
 772                 Iterator<Edge> edgeIter = vertex.edges(Direction.IN, EdgeLabelEnum.VERSION.name());
 773                 if (!edgeIter.hasNext()) {
 774                         return Either.right(StorageOperationStatus.NOT_FOUND);
 775                 }
 776                 return findLastCertifiedToscaElementVertexRecursively(edgeIter.next().outVertex());
 777         }
 778
 779         private boolean isCertifiedVersion(String version) {
 780                 String[] versionParts = version.split(VERSION_DELIMETER_REGEXP);
 781                 if (Integer.parseInt(versionParts[0]) > 0 && Integer.parseInt(versionParts[1]) == 0) {
 782                         return true;
 783                 }
 784                 return false;
 785         }
 786
 787         private StorageOperationStatus updateOldToscaElementBeforeUndoCheckout(Vertex previousVersionToscaElement) {
 788
 789                 StorageOperationStatus result = StorageOperationStatus.OK;
 790                 String previousVersion = (String) previousVersionToscaElement.property(GraphPropertyEnum.VERSION.getProperty()).value();
 791                 if (!previousVersion.endsWith(".0")) {
 792                         try {
 793                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to update vertex of previous version of tosca element", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty()));
 794
 795                                 Map<String, Object> propertiesToUpdate = new HashMap<>();
 796                                 propertiesToUpdate.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true);
 797                                 Map<String, Object> jsonMetadataMap = JsonParserUtils.parseToJson((String) previousVersionToscaElement.property(GraphPropertyEnum.METADATA.getProperty()).value());
 798                                 jsonMetadataMap.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true);
 799                                 propertiesToUpdate.put(GraphPropertyEnum.METADATA.getProperty(), JsonParserUtils.jsonToString(jsonMetadataMap));
 800
 801                                 titanDao.setVertexProperties(previousVersionToscaElement, propertiesToUpdate);
 802
 803                                 Iterator<Edge> edgesIter = previousVersionToscaElement.edges(Direction.IN, EdgeLabelEnum.LAST_STATE.name());
 804                                 if (!edgesIter.hasNext()) {
 805                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch last modifier vertex for tosca element {}. ", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty()));
 806                                         result = StorageOperationStatus.NOT_FOUND;
 807                                 } else {
 808                                         Edge lastStateEdge = edgesIter.next();
 809                                         Vertex lastModifier = lastStateEdge.outVertex();
 810                                         TitanOperationStatus replaceRes = titanDao.replaceEdgeLabel(lastModifier, previousVersionToscaElement, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE);
 811                                         if (replaceRes != TitanOperationStatus.OK) {
 812                                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to replace label from {} to {}. status = {}", EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE, replaceRes);
 813                                                 result = StorageOperationStatus.INCONSISTENCY;
 814                                                 if (replaceRes != TitanOperationStatus.INVALID_ID) {
 815                                                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(replaceRes);
 816                                                 }
 817                                         }
 818                                 }
 819                         } catch (Exception e) {
 820                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during update previous tosca element {} before undo checkout. {} ", e.getMessage());
 821                         }
 822                 }
 823                 return result;
 824         }
 825
 826         private StorageOperationStatus updatePreviousVersion(GraphVertex toscaElementVertex, GraphVertex ownerVertex) {
 827                 StorageOperationStatus result = null;
 828                 String ownerId = (String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID);
 829                 String toscaElementId = toscaElementVertex.getUniqueId();
 830                 if (!toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) {
 831                         toscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
 832                         Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElementVertex);
 833                         if (updateVertexRes.isRight()) {
 834                                 TitanOperationStatus titatStatus = updateVertexRes.right().value();
 835                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update tosca element vertex {}. Status is  {}", toscaElementVertex.getUniqueId(), titatStatus);
 836                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus);
 837                         }
 838                         Either<Edge, TitanOperationStatus> deleteEdgeRes = null;
 839                         if (result == null) {
 840                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to replace edge with label {} to label {} from {} to {}. ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId);
 841
 842                                 deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
 843                                 if (deleteEdgeRes.isRight()) {
 844                                         TitanOperationStatus titanStatus = deleteEdgeRes.right().value();
 845                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete edge with label {} from {} to {}. Status is {} ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId, titanStatus);
 846                                         if (!titanStatus.equals(TitanOperationStatus.INVALID_ID)) {
 847                                                 result = DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus);
 848                                         } else {
 849                                                 result = StorageOperationStatus.INCONSISTENCY;
 850                                         }
 851                                 }
 852                         }
 853                         if (result == null) {
 854                                 TitanOperationStatus createEdgeRes = titanDao.createEdge(ownerVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_STATE, deleteEdgeRes.left().value());
 855                                 if (createEdgeRes != TitanOperationStatus.OK) {
 856                                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes);
 857                                 }
 858                         }
 859                 }
 860                 if (result == null) {
 861                         result = StorageOperationStatus.OK;
 862                 }
 863                 return result;
 864         }
 865
 866         private Either<ToscaElement, StorageOperationStatus> cloneToscaElementForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) {
 867
 868                 Either<ToscaElement, StorageOperationStatus> result = null;
 869                 Either<GraphVertex, StorageOperationStatus> cloneResult = null;
 870                 ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel());
 871                 // check if component with the next version doesn't exist.
 872                 Iterator<Edge> nextVersionComponentIter = toscaElementVertex.getVertex().edges(Direction.OUT, EdgeLabelEnum.VERSION.name());
 873                 if (nextVersionComponentIter != null && nextVersionComponentIter.hasNext()) {
 874                         String fetchedVersion = (String) nextVersionComponentIter.next().inVertex().property(GraphPropertyEnum.VERSION.getProperty()).value();
 875                         String fetchedName = (String) nextVersionComponentIter.next().inVertex().property(GraphPropertyEnum.NORMALIZED_NAME.getProperty()).value();
 876                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to checkout component {} with version {}. The component with name {} and version {} was fetched from graph as existing following version. ",
 877                                         toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString(), toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION).toString(), fetchedName, fetchedVersion);
 878                         result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
 879                 }
 880                 if (result == null) {
 881                         cloneResult = operation.cloneToscaElement(toscaElementVertex, cloneGraphVertexForCheckout(toscaElementVertex, modifierVertex), modifierVertex);
 882                         if (cloneResult.isRight()) {
 883                                 result = Either.right(cloneResult.right().value());
 884                         }
 885                 }
 886                 GraphVertex clonedVertex = null;
 887                 if (result == null) {
 888                         clonedVertex = cloneResult.left().value();
 889                         TitanOperationStatus status = titanDao.createEdge(toscaElementVertex.getVertex(), cloneResult.left().value().getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
 890                         if (status != TitanOperationStatus.OK) {
 891                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION,
 892                                                 toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), cloneResult.left().value().getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status);
 893                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 894                         }
 895                 }
 896                 if (result == null) {
 897                         result = operation.getToscaElement(cloneResult.left().value().getUniqueId());
 898                         if (result.isRight()) {
 899                                 return result;
 900                         }
 901
 902                         ToscaElement toscaElement = result.left().value();
 903                         if (toscaElement.getToscaType() == ToscaElementTypeEnum.TopologyTemplate) {
 904                                 result = handleFixTopologyTemplate(toscaElementVertex, result, operation, clonedVertex, toscaElement);
 905                         }
 906                 }
 907                 return result;
 908         }
 909
 910         private Either<ToscaElement, StorageOperationStatus> handleFixTopologyTemplate(GraphVertex toscaElementVertex, Either<ToscaElement, StorageOperationStatus> result, ToscaElementOperation operation, GraphVertex clonedVertex,
 911                         ToscaElement toscaElement) {
 912                 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
 913                 Map<String, MapPropertiesDataDefinition> instInputs = topologyTemplate.getInstInputs();
 914                 Map<String, MapGroupsDataDefinition> instGroups = topologyTemplate.getInstGroups();
 915                 Map<String, MapArtifactDataDefinition> instArtifactsMap = topologyTemplate.getInstanceArtifacts();
 916                 Map<String, ToscaElement> origCompMap = new HashMap<>();
 917                 if (instInputs == null) {
 918                         instInputs = new HashMap<>();
 919                 }
 920                 if (instGroups == null) {
 921                         instGroups = new HashMap<>();
 922                 }
 923                 if (instArtifactsMap == null) {
 924                         instArtifactsMap = new HashMap<>();
 925                 }
 926                 Map<String, ComponentInstanceDataDefinition> instancesMap = topologyTemplate.getComponentInstances();
 927                 boolean isAddInstGroup = instGroups == null || instGroups.isEmpty();
 928                 boolean needUpdateComposition = false;
 929
 930                 if (instancesMap != null && !instancesMap.isEmpty()) {
 931                         for (ComponentInstanceDataDefinition vfInst : instancesMap.values()) {
 932                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "vfInst name is {} . OriginType {}. ", vfInst.getName(), vfInst.getOriginType());
 933                                 if (vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) {
 934                                         collectInstanceInputAndGroups(instInputs, instGroups, instArtifactsMap, origCompMap, isAddInstGroup, vfInst, clonedVertex);
 935                                 }
 936                                 needUpdateComposition = needUpdateComposition || fixToscaComponentName(vfInst, origCompMap);
 937                                 if(needUpdateComposition){
 938                                         instancesMap.put(vfInst.getUniqueId(), vfInst);
 939                                 }
 940                         }
 941                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "before add to graph instInputs {}  instGroups {} needUpdateComposition {}", instInputs, instGroups, needUpdateComposition);
 942                         if (!instInputs.isEmpty()) {
 943                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "before add inst inputs {} ", instInputs == null ? 0 : instInputs.size());
 944                                 GraphVertex toscaDataVertex = null;
 945                                 Either<GraphVertex, TitanOperationStatus> instInpVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_INPUTS, JsonParseFlagEnum.ParseJson);
 946                                 if (instInpVertexEither.isLeft()) {
 947                                         toscaDataVertex = instInpVertexEither.left().value();
 948                                 }
 949
 950                                 StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_INPUTS, EdgeLabelEnum.INST_INPUTS, toscaDataVertex, instInputs);
 951                                 if (status != StorageOperationStatus.OK) {
 952                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update instance inputs . Status is {}. ", status);
 953                                         result = Either.right(status);
 954                                         return result;
 955                                 }
 956
 957                         }
 958                         if (!instGroups.isEmpty()) {
 959                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "before add inst groups {} ", instGroups == null ? 0 : instGroups.size());
 960                                 GraphVertex toscaDataVertex = null;
 961                                 Either<GraphVertex, TitanOperationStatus> instGrVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_GROUPS, JsonParseFlagEnum.ParseJson);
 962                                 if (instGrVertexEither.isLeft()) {
 963                                         toscaDataVertex = instGrVertexEither.left().value();
 964                                 }
 965
 966                                 StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_GROUPS, EdgeLabelEnum.INST_GROUPS, toscaDataVertex, instGroups);
 967                                 if (status != StorageOperationStatus.OK) {
 968                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update instance group . Status is {}. ", status);
 969                                         result = Either.right(status);
 970                                         return result;
 971                                 }
 972
 973                         }
 974                         if (needUpdateComposition) {
 975                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "before update Instances ");
 976                                 Map<String, CompositionDataDefinition> jsonComposition = (Map<String, CompositionDataDefinition>) clonedVertex.getJson();
 977                                 CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue());
 978                                 compositionDataDefinition.setComponentInstances(instancesMap);
 979                                 Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(clonedVertex);
 980                                 if (updateElement.isRight()) {
 981                                         TitanOperationStatus status = updateElement.right().value();
 982                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update instances on metadata vertex . Status is {}. ", status);
 983                                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 984                                         return result;
 985                                 }
 986                         }
 987
 988                         result = operation.getToscaElement(clonedVertex.getUniqueId());
 989
 990                 } else {
 991                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "RI map empty on component {}", toscaElement.getUniqueId());
 992                 }
 993                 return result;
 994         }
 995
 996         private boolean fixToscaComponentName(ComponentInstanceDataDefinition vfInst, Map<String, ToscaElement> origCompMap) {
 997                 if (vfInst.getToscaComponentName() == null || vfInst.getToscaComponentName().isEmpty()) {
 998                         String ciUid = vfInst.getUniqueId();
 999                         String origCompUid = vfInst.getComponentUid();
1000                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "fixToscaComponentName:: Ri id {} . origin component id is {}. type is{} ", ciUid, origCompUid, vfInst.getOriginType());
1001                         ToscaElement origComp = null;
1002                         if (!origCompMap.containsKey(origCompUid)) {
1003                                 Either<ToscaElement, StorageOperationStatus> origCompEither;
1004                                 if (vfInst.getOriginType() == null || vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) {
1005                                         origCompEither = topologyTemplateOperation.getToscaElement(origCompUid);
1006                                 }else{
1007                                         origCompEither = nodeTypeOperation.getToscaElement(origCompUid);
1008                                 }
1009                                 if (origCompEither.isRight()) {
1010                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value());
1011                                         return false;
1012                                 }
1013                                 origComp =  origCompEither.left().value();
1014                                 origCompMap.put(origCompUid, origComp);
1015                         } else {
1016                                 origComp = origCompMap.get(origCompUid);
1017                         }
1018                         String toscaName = (String) origComp.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME);
1019                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Origin component id is {}. toscaName {}", origCompUid, toscaName);
1020                         vfInst.setToscaComponentName(toscaName);
1021                         return true;
1022                 }
1023                 return false;
1024         }
1025
1026         private void collectInstanceInputAndGroups(Map<String, MapPropertiesDataDefinition> instInputs, Map<String, MapGroupsDataDefinition> instGroups, Map<String, MapArtifactDataDefinition> instArtifactsMap, Map<String, ToscaElement> origCompMap,
1027                         boolean isAddInstGroup, ComponentInstanceDataDefinition vfInst, GraphVertex clonedVertex) {
1028                 String ciUid = vfInst.getUniqueId();
1029                 String origCompUid = vfInst.getComponentUid();
1030                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "collectInstanceInputAndGroups:: Ri id {} . origin component id is {}. ", ciUid, origCompUid);
1031                 TopologyTemplate origComp = null;
1032                 if (!origCompMap.containsKey(origCompUid)) {
1033                         Either<ToscaElement, StorageOperationStatus> origCompEither = topologyTemplateOperation.getToscaElement(origCompUid);
1034                         if (origCompEither.isRight()) {
1035                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value());
1036                                 return;
1037                         }
1038                         origComp = (TopologyTemplate) origCompEither.left().value();
1039                         origCompMap.put(origCompUid, origComp);
1040                 } else {
1041                         origComp = (TopologyTemplate) origCompMap.get(origCompUid);
1042                 }
1043                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Orig component {}. ", origComp.getUniqueId());
1044
1045                 Map<String, PropertyDataDefinition> origInputs = origComp.getInputs();
1046                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Orig component inputs size {}. ", origInputs == null ? 0 : origInputs.size());
1047                 if (origInputs != null) {
1048                         if (!instInputs.containsKey(ciUid)) {
1049                                 MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(origInputs);
1050                                 instInputs.put(ciUid, instProperties);
1051                         } else {
1052
1053                                 MapPropertiesDataDefinition instInputMap = instInputs.get(ciUid);
1054                                 Map<String, PropertyDataDefinition> instProp = instInputMap.getMapToscaDataDefinition();
1055                                 origInputs.forEach((propName, propMap) -> {
1056                                         if (!instProp.containsKey(propName)) {
1057                                                 instProp.put(propName, propMap);
1058                                         }
1059                                 });
1060                         }
1061                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "ComponentInstanseInputs {}. ", instInputs.get(ciUid));
1062                 }
1063
1064                 if (isAddInstGroup) {
1065                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "before create group instance. ");
1066                         List<GroupDataDefinition> filteredGroups = null;
1067
1068
1069                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "check vf groups before filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size());
1070                         if (origComp.getGroups() != null && !origComp.getGroups().isEmpty()) {
1071                                 filteredGroups = origComp.getGroups().values().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
1072                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "check vf groups . Size is {} ", filteredGroups == null ? 0 : filteredGroups.size());
1073                         }
1074                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "check vf groups after filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size());
1075                         if (CollectionUtils.isNotEmpty(filteredGroups)) {
1076                                 MapArtifactDataDefinition instArifacts = null;
1077                                 if(!instArtifactsMap.containsKey(ciUid)){
1078
1079                                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "istance artifacts not found ");
1080
1081                                                 Map<String, ArtifactDataDefinition> deploymentArtifacts = origComp.getDeploymentArtifacts();
1082
1083
1084                                                 instArifacts = new MapArtifactDataDefinition(deploymentArtifacts);
1085                                                  addToscaDataDeepElementsBlockToToscaElement(clonedVertex, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, instArifacts, ciUid);
1086
1087                                                  instArtifactsMap.put(ciUid, instArifacts);
1088
1089                                 }else{
1090                                         instArifacts = instArtifactsMap.get(ciUid);
1091                                 }
1092
1093                                 if(instArifacts != null){
1094                                         Map<String, ArtifactDataDefinition> instDeplArtifMap = instArifacts.getMapToscaDataDefinition();
1095
1096                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "check group dep artifacts. Size is {} ", instDeplArtifMap == null ? 0 : instDeplArtifMap.values().size());
1097                                         Map<String, GroupInstanceDataDefinition> groupInstanceToCreate = new HashMap<>();
1098                                         for(GroupDataDefinition group:filteredGroups){
1099                                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "create new groupInstance  {} ", group.getName());
1100                                                 GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition(group, vfInst);
1101                                                 List<String> artifactsUid = new ArrayList<>();
1102                                                 List<String> artifactsId = new ArrayList<>();
1103                                                 for (ArtifactDataDefinition artifact : instDeplArtifMap.values()) {
1104                                                         //CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "create new groupInstance  {} ", artifact.getA);
1105                                                         Optional<String> op = group.getArtifacts().stream().filter(p -> p.equals(artifact.getGeneratedFromId())).findAny();
1106                                                         if (op.isPresent()) {
1107                                                                 artifactsUid.add(artifact.getArtifactUUID());
1108                                                                 artifactsId.add(artifact.getUniqueId());
1109
1110                                                         }
1111                                                 }
1112                                                 groupInstance.setGroupInstanceArtifacts(artifactsId);
1113                                                 groupInstance.setGroupInstanceArtifactsUuid(artifactsUid);
1114                                                 groupInstanceToCreate.put(groupInstance.getName(), groupInstance);
1115                                         }
1116                                         if (MapUtils.isNotEmpty(groupInstanceToCreate)) {
1117                                                 instGroups.put(vfInst.getUniqueId(), new MapGroupsDataDefinition(groupInstanceToCreate));
1118
1119                                         }
1120                                 }
1121                         }
1122                 }
1123         }
1124
1125         private GraphVertex cloneGraphVertexForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) {
1126                 GraphVertex nextVersionToscaElementVertex = new GraphVertex();
1127                 String uniqueId = UniqueIdBuilder.buildComponentUniqueId();
1128                 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(toscaElementVertex.getMetadataProperties());
1129                 nextVersionToscaElementVertex.setMetadataProperties(metadataProperties);
1130                 nextVersionToscaElementVertex.setUniqueId(uniqueId);
1131                 nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel());
1132                 nextVersionToscaElementVertex.setType(toscaElementVertex.getType());
1133
1134                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId);
1135                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name());
1136                 String nextVersion = getNextVersion((String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION));
1137                 if (isFirstCheckoutAfterCertification(nextVersion)) {
1138                         nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UUID, IdBuilderUtils.generateUUID());
1139                 }
1140                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, nextVersion);
1141                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1142                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
1143
1144                 if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) {
1145                         nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.getValue());
1146                 }
1147                 if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) {
1148                         nextVersionToscaElementVertex.setMetadataJson(new HashMap<String, Object>(toscaElementVertex.getMetadataJson()));
1149                         nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties();
1150                 }
1151                 long currTime = System.currentTimeMillis();
1152                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, currTime);
1153                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, currTime);
1154                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId());
1155                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId());
1156                 if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE) {
1157                         nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CONFORMANCE_LEVEL, ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
1158                 }
1159
1160                 if (!MapUtils.isEmpty(toscaElementVertex.getJson())) {
1161                         nextVersionToscaElementVertex.setJson(new HashMap<String, ToscaDataDefinition>(toscaElementVertex.getJson()));
1162                 }
1163                 return nextVersionToscaElementVertex;
1164         }
1165
1166         private Either<GraphVertex, StorageOperationStatus> cloneToscaElementForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) {
1167                 Either<GraphVertex, StorageOperationStatus> result;
1168                 Either<List<GraphVertex>, StorageOperationStatus> deleteResult = null;
1169                 GraphVertex clonedToscaElement = null;
1170                 result = getToscaElementOperation(toscaElementVertex.getLabel()).cloneToscaElement(toscaElementVertex, cloneGraphVertexForCertify(toscaElementVertex, modifierVertex, majorVersion), modifierVertex);
1171                 if (result.isRight()) {
1172                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to clone tosca element {} for certification. Sattus is {}. ", toscaElementVertex.getUniqueId(), result.right().value());
1173                 } else {
1174                         clonedToscaElement = result.left().value();
1175                         deleteResult = deleteAllPreviousNotCertifiedVersions(toscaElementVertex);
1176                         if (deleteResult.isRight()) {
1177                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete all previous npt certified versions of tosca element {}. Status is {}. ", toscaElementVertex.getUniqueId(), deleteResult.right().value());
1178                                 result = Either.right(deleteResult.right().value());
1179                         }
1180                 }
1181                 if (result.isLeft()) {
1182                         result = handlePreviousVersionRelation(clonedToscaElement, deleteResult.left().value(), majorVersion);
1183                 }
1184                 return result;
1185         }
1186
1187         private Either<GraphVertex, StorageOperationStatus> handlePreviousVersionRelation(GraphVertex clonedToscaElement, List<GraphVertex> deletedVersions, Integer majorVersion) {
1188                 Either<GraphVertex, StorageOperationStatus> result = null;
1189                 Vertex previousCertifiedToscaElement = null;
1190                 if (majorVersion > 0) {
1191                         List<GraphVertex> firstMinorVersionVertex = deletedVersions.stream().filter(gv -> getMinorVersion((String) gv.getMetadataProperty(GraphPropertyEnum.VERSION)) == 1).collect(Collectors.toList());
1192
1193                         if (CollectionUtils.isEmpty(firstMinorVersionVertex)) {
1194                                 result = Either.right(StorageOperationStatus.NOT_FOUND);
1195                         } else {
1196                                 previousCertifiedToscaElement = getPreviousCertifiedToscaElement(firstMinorVersionVertex.get(0));
1197                                 if (previousCertifiedToscaElement == null) {
1198                                         result = Either.right(StorageOperationStatus.NOT_FOUND);
1199                                 }
1200                         }
1201                         if (result == null) {
1202                                 TitanOperationStatus status = titanDao.createEdge(previousCertifiedToscaElement, clonedToscaElement.getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
1203                                 if (status != TitanOperationStatus.OK) {
1204                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION,
1205                                                         previousCertifiedToscaElement.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), clonedToscaElement.getUniqueId(), status);
1206                                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
1207                                 }
1208                         }
1209                 }
1210                 if (result == null) {
1211                         result = Either.left(clonedToscaElement);
1212                 }
1213                 return result;
1214         }
1215
1216         private Vertex getPreviousCertifiedToscaElement(GraphVertex graphVertex) {
1217
1218                 Iterator<Edge> edges = graphVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name());
1219                 if (edges.hasNext()) {
1220                         return edges.next().outVertex();
1221                 }
1222                 return null;
1223         }
1224
1225         private Either<List<GraphVertex>, StorageOperationStatus> deleteAllPreviousNotCertifiedVersions(GraphVertex toscaElementVertex) {
1226                 Either<List<GraphVertex>, StorageOperationStatus> result = null;
1227
1228                 ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel());
1229                 List<GraphVertex> previosVersions = null;
1230                 Object uuid = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.UUID);
1231                 Object componentName = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NAME);
1232                 try {
1233                         Map<GraphPropertyEnum, Object> properties = new HashMap<>();
1234                         properties.put(GraphPropertyEnum.UUID, uuid);
1235                         properties.put(GraphPropertyEnum.NAME, componentName);
1236                         Either<List<GraphVertex>, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(toscaElementVertex.getLabel(), properties, JsonParseFlagEnum.ParseMetadata);
1237                         if (getToscaElementsRes.isRight()) {
1238                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value()));
1239                         }
1240                         if (result == null) {
1241                                 previosVersions = getToscaElementsRes.left().value();
1242                                 Either<Boolean, StorageOperationStatus> deleteResult = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value());
1243                                 if (deleteResult.isRight()) {
1244                                         result = Either.right(deleteResult.right().value());
1245                                 }
1246                         }
1247                         if (result == null) {
1248                                 result = Either.left(previosVersions);
1249                         }
1250                 } catch (Exception e) {
1251                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage());
1252                 }
1253                 return result;
1254         }
1255
1256         private GraphVertex cloneGraphVertexForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) {
1257
1258                 GraphVertex nextVersionToscaElementVertex = new GraphVertex();
1259                 String uniqueId = IdBuilderUtils.generateUniqueId();
1260                 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(toscaElementVertex.getMetadataProperties());
1261                 nextVersionToscaElementVertex.setMetadataProperties(metadataProperties);
1262                 nextVersionToscaElementVertex.setUniqueId(uniqueId);
1263                 nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel());
1264                 nextVersionToscaElementVertex.setType(toscaElementVertex.getType());
1265
1266                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId);
1267                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name());
1268                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, (majorVersion + 1) + VERSION_DELIMETER + "0");
1269                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
1270                 nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
1271                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, System.currentTimeMillis());
1272                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, null);
1273                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId());
1274                 nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId());
1275
1276                 if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED)) {
1277                         nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.getValue());
1278                 }
1279                 if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) {
1280                         nextVersionToscaElementVertex.setMetadataJson(new HashMap<String, Object>(toscaElementVertex.getMetadataJson()));
1281                         nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties();
1282                 }
1283                 if (!MapUtils.isEmpty(toscaElementVertex.getJson())) {
1284                         nextVersionToscaElementVertex.setJson(new HashMap<String, ToscaDataDefinition>(toscaElementVertex.getJson()));
1285                 }
1286                 return nextVersionToscaElementVertex;
1287         }
1288
1289         private ComponentParametersView buildComponentParametersViewAfterCheckin() {
1290                 ComponentParametersView componentParametersView = new ComponentParametersView();
1291                 componentParametersView.disableAll();
1292                 componentParametersView.setIgnoreUsers(false);
1293                 return componentParametersView;
1294         }
1295
1296         private Either<GraphVertex, StorageOperationStatus> checkinToscaELement(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex, LifecycleStateEnum nextState) {
1297                 Either<GraphVertex, StorageOperationStatus> updateRelationsRes;
1298                 Either<GraphVertex, StorageOperationStatus> result = changeStateToCheckedIn(currState, toscaElementVertex, ownerVertex, modifierVertex);
1299                 if (result.isLeft()) {
1300                         toscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name());
1301                         toscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
1302                         result = updateToscaElementVertexMetadataPropertiesAndJson(toscaElementVertex);
1303                 }
1304                 if (result.isLeft()) {
1305                         updateRelationsRes = updateLastModifierEdge(toscaElementVertex, ownerVertex, modifierVertex);
1306                         if (updateRelationsRes.isRight()) {
1307                                 result = Either.right(updateRelationsRes.right().value());
1308                         }
1309                 }
1310                 return result;
1311         }
1312
1313         private Either<GraphVertex, StorageOperationStatus> updateToscaElementVertexMetadataPropertiesAndJson(GraphVertex toscaElementVertex) {
1314
1315                 Either<GraphVertex, StorageOperationStatus> result;
1316
1317                 Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElementVertex);
1318                 if (updateVertexRes.isRight()) {
1319                         TitanOperationStatus titatStatus = updateVertexRes.right().value();
1320                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update state of tosca element vertex {} metadata. Status is  {}", toscaElementVertex.getUniqueId(), titatStatus);
1321                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus));
1322                 } else {
1323                         result = Either.left(updateVertexRes.left().value());
1324                 }
1325                 return result;
1326         }
1327
1328         private Either<GraphVertex, StorageOperationStatus> changeStateToCheckedIn(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) {
1329                 Either<GraphVertex, StorageOperationStatus> result = null;
1330                 LifecycleStateEnum nextState = LifecycleStateEnum.NOT_CERTIFIED_CHECKIN;
1331                 String faileToUpdateStateMsg = "Failed to update state of tosca element {}. Status is  {}";
1332
1333                 if (currState == LifecycleStateEnum.READY_FOR_CERTIFICATION) {
1334                         // In case of cancel "ready for certification" remove last state edge with "STATE" property equals to "NOT_CERTIFIED_CHECKIN"
1335                         Map<GraphPropertyEnum, Object> vertexProperties = new HashMap<>();
1336                         vertexProperties.put(GraphPropertyEnum.STATE, nextState);
1337                         Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElementVertex, EdgeLabelEnum.LAST_STATE, vertexProperties);
1338                         if (deleteResult.isRight()) {
1339                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId(), deleteResult.right().value());
1340                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "failed to update last state relation");
1341                                 result = Either.right(StorageOperationStatus.INCONSISTENCY);
1342                         }
1343                 }
1344                 if (result == null) {
1345                         // Remove CHECKOUT relation
1346                         Either<Edge, TitanOperationStatus> deleteEdgeResult = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
1347                         if (deleteEdgeResult.isRight()) {
1348                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId());
1349                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeResult.right().value()));
1350                         }
1351                 }
1352                 if (result == null) {
1353                         // Create CHECKIN relation
1354                         Map<EdgePropertyEnum, Object> edgeProperties = new HashMap<>();
1355                         edgeProperties.put(EdgePropertyEnum.STATE, nextState);
1356                         TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.STATE, edgeProperties);
1357                         if (createEdgeRes != TitanOperationStatus.OK) {
1358                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId());
1359                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes));
1360                         }
1361                 }
1362                 if (result == null) {
1363                         result = Either.left(toscaElementVertex);
1364                 }
1365                 return result;
1366         }
1367
1368         private Either<GraphVertex, StorageOperationStatus> updateLastModifierEdge(GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) {
1369                 Either<GraphVertex, StorageOperationStatus> result = null;
1370                 if (!modifierVertex.getMetadataProperties().get(GraphPropertyEnum.USERID).equals(ownerVertex.getMetadataProperties().get(GraphPropertyEnum.USERID))) {
1371                         Either<Edge, TitanOperationStatus> deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.LAST_MODIFIER);
1372                         if (deleteEdgeRes.isRight()) {
1373                                 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete last modifier {} to tosca element {}. Edge type is {}", ownerVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER);
1374                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeRes.right().value()));
1375                         }
1376                         if (result == null) {
1377                                 TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
1378
1379                                 if (createEdgeRes != TitanOperationStatus.OK) {
1380                                         CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to associate user {} to component {}. Edge type is {}", modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER);
1381                                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes));
1382                                 } else {
1383                                         result = Either.left(modifierVertex);
1384                                 }
1385                         }
1386                 } else {
1387                         result = Either.left(ownerVertex);
1388                 }
1389                 return result;
1390         }
1391
1392         private Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> prepareParametersToGetVerticesForCheckin(String toscaElementId, String modifierId, String ownerId) {
1393                 Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> verticesToGetParameters = new HashMap<>();
1394                 verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseMetadata));
1395                 verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1396                 verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1397                 return verticesToGetParameters;
1398         }
1399
1400         private Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> prepareParametersToGetVerticesForRequestCertification(String toscaElementId, String modifierId, String ownerId) {
1401                 Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> verticesToGetParameters = new HashMap<>();
1402                 verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseAll));
1403                 verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1404                 verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1405                 return verticesToGetParameters;
1406         }
1407
1408         private Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> prepareParametersToGetVerticesForCheckout(String toscaElementId, String modifierId, String ownerId) {
1409                 Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> verticesToGetParameters = new HashMap<>();
1410                 verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseAll));
1411                 verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1412                 verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse));
1413                 return verticesToGetParameters;
1414         }
1415
1416         private String getNextVersion(String currVersion) {
1417                 String[] versionParts = currVersion.split(VERSION_DELIMETER_REGEXP);
1418                 Integer minorVersion = Integer.parseInt(versionParts[1]) + 1;
1419                 return versionParts[0] + VERSION_DELIMETER + minorVersion;
1420         }
1421
1422         private Integer getMinorVersion(String version) {
1423                 String[] versionParts = version.split(VERSION_DELIMETER_REGEXP);
1424                 return Integer.parseInt(versionParts[1]);
1425         }
1426
1427         private Integer getMajorVersion(String version) {
1428                 String[] versionParts = version.split(VERSION_DELIMETER_REGEXP);
1429                 return Integer.parseInt(versionParts[0]);
1430         }
1431
1432         private boolean isFirstCheckoutAfterCertification(String version) {
1433                 if (Integer.parseInt(version.split(VERSION_DELIMETER_REGEXP)[0]) != 0 && Integer.parseInt(version.split(VERSION_DELIMETER_REGEXP)[1]) == 1) {
1434                         return true;
1435                 }
1436                 return false;
1437         }
1438 }