catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperation.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import com.google.common.base.Strings;
  24 import org.janusgraph.graphdb.query.JanusGraphPredicate;
  25 import fj.data.Either;
  26 import org.apache.commons.collections.CollectionUtils;
  27 import org.apache.commons.collections.MapUtils;
  28 import org.apache.commons.lang.StringUtils;
  29 import org.apache.commons.lang3.tuple.ImmutablePair;
  30 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  31 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  32 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  33 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  34 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  35 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  36 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  37 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  38 import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  40 import org.openecomp.sdc.be.model.CapabilityDefinition;
  41 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  42 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  43 import org.openecomp.sdc.be.model.PropertyDefinition;
  44 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  45 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  46 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  47 import org.openecomp.sdc.be.model.operations.api.TypeOperations;
  48 import org.openecomp.sdc.be.model.utils.TypeCompareUtils;
  49 import org.openecomp.sdc.be.resources.data.*;
  50 import org.openecomp.sdc.common.log.wrappers.Logger;
  51 import org.springframework.stereotype.Component;
  52
  53 import java.util.*;
  54 import java.util.function.Function;
  55 import java.util.stream.Collectors;
  56
  57 import static org.openecomp.sdc.be.dao.janusgraph.JanusGraphUtils.buildNotInPredicate;
  58
  59 @Component("group-type-operation")
  60 public class GroupTypeOperation implements IGroupTypeOperation {
  61
  62     private static final Logger log = Logger.getLogger(GroupTypeOperation.class.getName());
  63     private static final String CREATE_FLOW_CONTEXT = "CreateGroupType";
  64
  65     private final PropertyOperation propertyOperation;
  66     private final JanusGraphGenericDao janusGraphGenericDao;
  67     private final CapabilityTypeOperation capabilityTypeOperation;
  68     private final CapabilityOperation capabilityOperation;
  69     private final DerivedFromOperation derivedFromOperation;
  70     private final OperationUtils operationUtils;
  71
  72
  73     public GroupTypeOperation(JanusGraphGenericDao janusGraphGenericDao,
  74                               PropertyOperation propertyOperation,
  75                               CapabilityTypeOperation capabilityTypeOperation,
  76                               CapabilityOperation capabilityOperation,
  77                               DerivedFromOperation derivedFromOperation, OperationUtils operationUtils) {
  78         this.janusGraphGenericDao = janusGraphGenericDao;
  79         this.propertyOperation = propertyOperation;
  80         this.capabilityTypeOperation = capabilityTypeOperation;
  81         this.capabilityOperation = capabilityOperation;
  82         this.derivedFromOperation = derivedFromOperation;
  83         this.operationUtils = operationUtils;
  84     }
  85
  86     public Either<GroupTypeDefinition, StorageOperationStatus> addGroupType(GroupTypeDefinition groupTypeDefinition) {
  87         Either<GroupTypeDefinition, StorageOperationStatus> validationRes = validateUpdateProperties(groupTypeDefinition);
  88         if (validationRes.isRight()) {
  89             log.error("#addGroupType - One or all properties of group type {} not valid. status is {}", groupTypeDefinition, validationRes.right().value());
  90             return validationRes;
  91         }
  92
  93         return addGroupType(groupTypeDefinition, true);
  94     }
  95
  96     public Either<GroupTypeDefinition, StorageOperationStatus> addGroupType(GroupTypeDefinition groupTypeDefinition, boolean inTransaction) {
  97
  98         Either<GroupTypeDefinition, StorageOperationStatus> result = null;
  99
 100         try {
 101
 102             Either<GroupTypeData, JanusGraphOperationStatus> eitherStatus = addGroupTypeToGraph(groupTypeDefinition);
 103
 104             if (eitherStatus.isRight()) {
 105                 BeEcompErrorManager.getInstance().logBeFailedCreateNodeError(CREATE_FLOW_CONTEXT, groupTypeDefinition.getType(), eitherStatus.right().value().name());
 106                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value()));
 107             }
 108             else {
 109                 result = getGroupType(eitherStatus.left().value().getUniqueId(), inTransaction);
 110             }
 111
 112             return result;
 113
 114         } finally {
 115             janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result);
 116         }
 117
 118     }
 119
 120     public Either<GroupTypeDefinition, StorageOperationStatus> updateGroupType(GroupTypeDefinition updatedGroupType, GroupTypeDefinition currGroupType) {
 121         log.debug("updating group type {}", updatedGroupType.getType());
 122         return updateGroupTypeOnGraph(updatedGroupType, currGroupType);
 123     }
 124
 125
 126     public Either<GroupTypeDefinition, StorageOperationStatus> validateUpdateProperties(GroupTypeDefinition groupTypeDefinition) {
 127         JanusGraphOperationStatus error = null;
 128         if (CollectionUtils.isNotEmpty(groupTypeDefinition.getProperties()) && !Strings.isNullOrEmpty(groupTypeDefinition.getDerivedFrom())) {
 129             Either<Map<String, PropertyDefinition>, JanusGraphOperationStatus> allPropertiesRes =
 130                                         getAllGroupTypePropertiesFromAllDerivedFrom(groupTypeDefinition.getDerivedFrom());
 131             if (allPropertiesRes.isRight() && !allPropertiesRes.right().value().equals(
 132                 JanusGraphOperationStatus.NOT_FOUND)) {
 133                 error = allPropertiesRes.right().value();
 134                 log.debug("Couldn't fetch derived from property nodes for group type {}, error: {}", groupTypeDefinition.getType(), error);
 135             }
 136             if (error == null && !allPropertiesRes.left().value().isEmpty()) {
 137                 Either<List<PropertyDefinition>, JanusGraphOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(),
 138                         groupTypeDefinition.getProperties());
 139                 if (validatePropertiesRes.isRight()) {
 140                     error = validatePropertiesRes.right().value();
 141                 }
 142             }
 143         }
 144         if (error == null) {
 145             return Either.left(groupTypeDefinition);
 146         }
 147         return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
 148     }
 149
 150     private Either<Map<String, PropertyDefinition>, JanusGraphOperationStatus> getAllGroupTypePropertiesFromAllDerivedFrom(String firstParentType) {
 151         return janusGraphGenericDao
 152             .getNode(GraphPropertiesDictionary.TYPE.getProperty(), firstParentType, GroupTypeData.class)
 153                     .left()
 154                     .bind(parentGroup -> propertyOperation.getAllTypePropertiesFromAllDerivedFrom(parentGroup.getUniqueId(), NodeTypeEnum.GroupType, GroupTypeData.class));
 155     }
 156
 157
 158     private StorageOperationStatus mergeCapabilities(GroupTypeDefinition groupTypeDef) {
 159         Map<String, CapabilityDefinition> updatedGroupTypeCapabilities = groupTypeDef.getCapabilities();
 160         Map<String, CapabilityDefinition> newGroupTypeCapabilities;
 161         Either<List<CapabilityDefinition>, StorageOperationStatus> oldCapabilitiesRes = getCapablities(groupTypeDef.getUniqueId());
 162         if (oldCapabilitiesRes.isRight()) {
 163             StorageOperationStatus status = oldCapabilitiesRes.right().value();
 164             if (status == StorageOperationStatus.NOT_FOUND) {
 165                 newGroupTypeCapabilities = updatedGroupTypeCapabilities;
 166             }
 167             else {
 168                 return status;
 169             }
 170         }
 171         else {
 172             Map<String, CapabilityDefinition> oldCapabilities = asCapabilitiesMap(oldCapabilitiesRes.left().value());
 173             newGroupTypeCapabilities = collectNewCapabilities(updatedGroupTypeCapabilities, oldCapabilities);
 174
 175             for(Map.Entry<String, CapabilityDefinition> oldEntry: oldCapabilities.entrySet()) {
 176                 String key = oldEntry.getKey();
 177                 CapabilityDefinition newCapDef = updatedGroupTypeCapabilities != null? updatedGroupTypeCapabilities.get(key): null;
 178                 CapabilityDefinition oldCapDef = oldEntry.getValue();
 179
 180                 StorageOperationStatus deleteCapResult = deleteOutdatedCapability(newGroupTypeCapabilities, newCapDef, oldCapDef);
 181                 if(deleteCapResult != StorageOperationStatus.OK) {
 182                     return deleteCapResult;
 183                 }
 184             }
 185         }
 186
 187         JanusGraphOperationStatus createCapResult = createCapabilities(new GroupTypeData(groupTypeDef), newGroupTypeCapabilities);
 188         return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createCapResult);
 189     }
 190
 191     /**
 192      * @param newGroupTypeCapabilities
 193      * @param newCapDef
 194      * @param oldCapDef
 195      * @return
 196      */
 197     private StorageOperationStatus deleteOutdatedCapability(Map<String, CapabilityDefinition> newGroupTypeCapabilities, CapabilityDefinition newCapDef, CapabilityDefinition oldCapDef) {
 198         if(!isUpdateAllowed(newCapDef, oldCapDef)) {
 199             return StorageOperationStatus.MATCH_NOT_FOUND;
 200         }
 201
 202         if (!TypeCompareUtils.capabilityEquals(oldCapDef, newCapDef)) {
 203             StorageOperationStatus deleteCapResult = capabilityOperation.deleteCapability(oldCapDef);
 204
 205             if(deleteCapResult == StorageOperationStatus.OK) {
 206                 newGroupTypeCapabilities.put(newCapDef.getName(), newCapDef);
 207             }
 208             else {
 209                 return deleteCapResult;
 210             }
 211         }
 212
 213         return StorageOperationStatus.OK;
 214     }
 215
 216     private boolean isUpdateAllowed(CapabilityDefinition newCapDef, CapabilityDefinition oldCapDef) {
 217         if (newCapDef == null) {
 218             log.error("#upsertCapabilities - Failed due to attempt to delete the capability with id {}", oldCapDef.getUniqueId());
 219             return false;
 220         }
 221
 222         if (newCapDef.getType() == null || !newCapDef.getType().equals(oldCapDef.getType())) {
 223             log.error("#upsertCapabilities - Failed due to attempt to change type of the capability with id {}", oldCapDef.getUniqueId());
 224             return false;
 225         }
 226
 227         return true;
 228     }
 229
 230     /**
 231      * @param updatedGroupTypeCapabilities
 232      * @param oldCapabilities
 233      * @return
 234      */
 235     private Map<String, CapabilityDefinition> collectNewCapabilities(Map<String, CapabilityDefinition> updatedGroupTypeCapabilities, Map<String, CapabilityDefinition> oldCapabilities) {
 236         return updatedGroupTypeCapabilities != null? updatedGroupTypeCapabilities.entrySet().stream()
 237                 .filter(entry -> !oldCapabilities.containsKey(entry.getKey()))
 238                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue) ): null;
 239     }
 240
 241     private JanusGraphOperationStatus createCapabilities(GroupTypeData groupTypeData, Map<String, CapabilityDefinition> groupCapabilities) {
 242         if (MapUtils.isEmpty(groupCapabilities)) {
 243             return JanusGraphOperationStatus.OK;
 244         }
 245
 246         return groupCapabilities.values().stream()
 247                 .map(v -> createCapability(groupTypeData, v))
 248                 .filter(Either::isRight)
 249                 .findFirst()
 250                 .map(either -> either.right().value())
 251                 .orElse(JanusGraphOperationStatus.OK);
 252     }
 253
 254     private Either<GraphRelation, JanusGraphOperationStatus> createCapability(GroupTypeData groupTypeData, CapabilityDefinition  capabilityDef) {
 255         Either<CapabilityTypeDefinition, JanusGraphOperationStatus> eitherCapData = capabilityTypeOperation.getCapabilityTypeByType(capabilityDef.getType());
 256         return eitherCapData
 257                 .left()
 258                 .map(CapabilityTypeData::new)
 259                 .left()
 260                 .bind(capTypeData -> capabilityOperation.addCapabilityToGraph(groupTypeData.getUniqueId(), capTypeData, capabilityDef))
 261                 .left()
 262                 .bind(capData -> connectToCapability(groupTypeData, capData, capabilityDef.getName()));
 263     }
 264
 265
 266     /**
 267      * Get capability with all relevant properties
 268      * @param groupTypeId
 269      * @return
 270      */
 271     private Either<List<CapabilityDefinition>, StorageOperationStatus> getCapablities(String groupTypeId) {
 272         Either<List<ImmutablePair<CapabilityData, GraphEdge>>, JanusGraphOperationStatus> groupCapabilitiesOnGraph =
 273                 janusGraphGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), groupTypeId, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class, true);
 274
 275         if (groupCapabilitiesOnGraph.isRight()) {
 276             JanusGraphOperationStatus capabilityStatus = groupCapabilitiesOnGraph.right().value();
 277             if (capabilityStatus == JanusGraphOperationStatus.NOT_FOUND) {
 278                 return Either.left(Collections.emptyList());
 279             }
 280             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(capabilityStatus));
 281         }
 282
 283         List<ImmutablePair<CapabilityData, GraphEdge>> groupCapabilites = groupCapabilitiesOnGraph.left().value();
 284         groupCapabilites.forEach(this::fillCapabilityName);
 285
 286         return capabilityOperation.getCapabilitiesWithProps(groupCapabilites)
 287                 .right()
 288                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 289     }
 290
 291     private void fillCapabilityName(ImmutablePair<CapabilityData, GraphEdge> pair) {
 292         pair.getLeft().getCapabilityDataDefinition().setName((String)pair.getRight().getProperties().get(GraphEdgePropertiesDictionary.NAME.getProperty()));
 293     }
 294
 295     private Either<GraphRelation, JanusGraphOperationStatus> connectToCapability(GroupTypeData groupTypeData, CapabilityData capabilityData, String capabilityName) {
 296         Map<String, Object> properties = new HashMap<>();
 297         properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), capabilityName);
 298
 299         return janusGraphGenericDao.createRelation(groupTypeData, capabilityData, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, properties);
 300     }
 301
 302
 303     public List<GroupTypeDefinition> getAllGroupTypes(Set<String> excludedGroupTypes) {
 304         Map<String, Map.Entry<JanusGraphPredicate, Object>> predicateCriteria = buildNotInPredicate(GraphPropertiesDictionary.TYPE.getProperty(), excludedGroupTypes);
 305         List<GroupTypeData> groupTypes = janusGraphGenericDao
 306             .getByCriteriaWithPredicate(NodeTypeEnum.GroupType, predicateCriteria, GroupTypeData.class)
 307                 .left()
 308                 .on(operationUtils::onJanusGraphOperationFailure);
 309         return convertGroupTypesToDefinition(groupTypes);
 310     }
 311
 312
 313     private List<GroupTypeDefinition> convertGroupTypesToDefinition(List<GroupTypeData> groupTypes) {
 314         return groupTypes.stream()
 315                 .map(type -> new GroupTypeDefinition(type.getGroupTypeDataDefinition()))
 316                 .collect(Collectors.toList());
 317     }
 318
 319
 320     public Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeByUid(String uniqueId) {
 321         log.debug("#getGroupTypeByUid - fetching group type with id {}", uniqueId);
 322         return janusGraphGenericDao
 323             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), uniqueId, GroupTypeData.class)
 324                 .right()
 325                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus)
 326                 .left()
 327                 .bind(groupType -> buildGroupTypeDefinition(uniqueId, groupType));
 328     }
 329
 330     public Either<GroupTypeDefinition, StorageOperationStatus> getGroupType(String uniqueId, boolean inTransaction) {
 331         Either<GroupTypeDefinition, StorageOperationStatus> result = null;
 332         try {
 333
 334             Either<GroupTypeDefinition, StorageOperationStatus> ctResult = getGroupTypeByUid(uniqueId);
 335
 336             if (ctResult.isRight()) {
 337                 StorageOperationStatus status = ctResult.right().value();
 338                 if (status != StorageOperationStatus.NOT_FOUND) {
 339                     log.error("Failed to retrieve information on element uniqueId: {}. status is {}", uniqueId, status);
 340                 }
 341                 result = Either.right(ctResult.right().value());
 342                 return result;
 343             }
 344
 345             result = Either.left(ctResult.left().value());
 346
 347             return result;
 348         } finally {
 349             janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result);
 350         }
 351
 352     }
 353
 354     public Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeByType(String type) {
 355         return getLatestGroupTypeByType(type, true);
 356     }
 357
 358     public Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeByType(String type, boolean inTransaction) {
 359         Map<String, Object> mapCriteria = new HashMap<>();
 360         mapCriteria.put(GraphPropertiesDictionary.TYPE.getProperty(), type);
 361         mapCriteria.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
 362
 363         return getGroupTypeByCriteria(type, mapCriteria, inTransaction);
 364
 365     }
 366
 367     public Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeByCriteria(String type, Map<String, Object> properties, boolean inTransaction) {
 368         Either<GroupTypeDefinition, StorageOperationStatus> result = null;
 369         try {
 370             if (type == null || type.isEmpty()) {
 371                 log.error("type is empty");
 372                 result = Either.right(StorageOperationStatus.INVALID_ID);
 373                 return result;
 374             }
 375
 376             Either<List<GroupTypeData>, StorageOperationStatus> groupTypeEither = janusGraphGenericDao
 377                 .getByCriteria(NodeTypeEnum.GroupType, properties, GroupTypeData.class)
 378                     .right()
 379                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 380             if (groupTypeEither.isRight()) {
 381                 result = Either.right(groupTypeEither.right().value());
 382             } else {
 383                 GroupTypeDataDefinition dataDefinition = groupTypeEither.left().value().stream()
 384                         .map(GroupTypeData::getGroupTypeDataDefinition)
 385                         .findFirst()
 386                         .get();
 387                 result = getGroupTypeByUid(dataDefinition.getUniqueId());
 388
 389             }
 390             return result;
 391
 392         } finally {
 393             janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result);
 394         }
 395     }
 396
 397     private Either<GroupTypeDefinition, StorageOperationStatus> buildGroupTypeDefinition(String uniqueId, GroupTypeData groupTypeNode) {
 398         GroupTypeDefinition groupType = new GroupTypeDefinition(groupTypeNode.getGroupTypeDataDefinition());
 399         return fillDerivedFrom(uniqueId, groupType)
 400                 .left()
 401                 .map(derivedFrom -> fillProperties(uniqueId, groupType, derivedFrom))
 402                 .left()
 403                 .bind(props -> fillCapabilities(uniqueId, groupType));
 404     }
 405
 406     private Either<GroupTypeDefinition, StorageOperationStatus> fillCapabilities(String uniqueId, GroupTypeDefinition groupType) {
 407         return getCapablities(uniqueId)
 408                 .left()
 409                 .map(capabilities -> {
 410                     groupType.setCapabilities(asCapabilitiesMap(capabilities));
 411                     return groupType;
 412                 });
 413     }
 414
 415     private Either<GroupTypeData, StorageOperationStatus> fillDerivedFrom(String uniqueId, GroupTypeDefinition groupType) {
 416         log.debug("#fillDerivedFrom - fetching group type {} derived node", groupType.getType());
 417         return derivedFromOperation.getDerivedFromChild(uniqueId, NodeTypeEnum.GroupType, GroupTypeData.class)
 418                 .right()
 419                 .bind(this::handleDerivedFromNotExist)
 420                 .left()
 421                 .map(derivedFrom -> setDerivedFrom(groupType, derivedFrom));
 422
 423     }
 424
 425     private Either<List<PropertyDefinition>, StorageOperationStatus> fillProperties(String uniqueId, GroupTypeDefinition groupType, GroupTypeData derivedFromNode) {
 426         log.debug("#fillProperties - fetching all properties for group type {}", groupType.getType());
 427         return propertyOperation.findPropertiesOfNode(NodeTypeEnum.GroupType, uniqueId)
 428                 .right()
 429                 .bind(this::handleGroupTypeHasNoProperties)
 430                 .left()
 431                 .bind(propsMap -> fillDerivedFromProperties(groupType, derivedFromNode, new ArrayList<>(propsMap.values())));
 432     }
 433
 434     Either<Map<String, PropertyDefinition>, StorageOperationStatus> handleGroupTypeHasNoProperties(JanusGraphOperationStatus err) {
 435         if (err == JanusGraphOperationStatus.NOT_FOUND) {
 436             return Either.left(new HashMap<>());
 437         }
 438         return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(err));
 439     }
 440
 441     private Either<List<PropertyDefinition>, StorageOperationStatus> fillDerivedFromProperties(GroupTypeDefinition groupType, GroupTypeData derivedFromNode, List<PropertyDefinition> groupTypeDirectProperties) {
 442         if (derivedFromNode == null) {
 443             groupType.setProperties(groupTypeDirectProperties);
 444             return Either.left(groupTypeDirectProperties);
 445         }
 446         log.debug("#fillDerivedFromProperties - fetching all properties of derived from chain for group type {}", groupType.getType());
 447         return propertyOperation.getAllPropertiesRec(derivedFromNode.getUniqueId(), NodeTypeEnum.GroupType, GroupTypeData.class)
 448                 .left()
 449                 .map(derivedFromProps -> {groupTypeDirectProperties.addAll(derivedFromProps); return groupTypeDirectProperties;})
 450                 .left()
 451                 .map(allProps -> {groupType.setProperties(allProps);return allProps;});
 452     }
 453
 454     private Either<GroupTypeData, StorageOperationStatus> handleDerivedFromNotExist(StorageOperationStatus err) {
 455         if (err == StorageOperationStatus.NOT_FOUND) {
 456             return Either.left(null);
 457         }
 458         return Either.right(err);
 459     }
 460
 461     private GroupTypeData setDerivedFrom(GroupTypeDefinition groupTypeDefinition, GroupTypeData derivedFrom) {
 462         if (derivedFrom != null) {
 463             groupTypeDefinition.setDerivedFrom(derivedFrom.getGroupTypeDataDefinition().getType());
 464         }
 465         return derivedFrom;
 466     }
 467
 468
 469     public Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeByTypeAndVersion(String type, String version) {
 470         return getGroupTypeByTypeAndVersion(type, version, false);
 471     }
 472
 473     public Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeByTypeAndVersion(String type, String version, boolean inTransaction) {
 474         Map<String, Object> mapCriteria = new HashMap<>();
 475         mapCriteria.put(GraphPropertiesDictionary.TYPE.getProperty(), type);
 476         mapCriteria.put(GraphPropertiesDictionary.VERSION.getProperty(), version);
 477
 478         return getGroupTypeByCriteria(type, mapCriteria, inTransaction);
 479     }
 480
 481     /**
 482      * Add group type to graph.
 483      * <p>
 484      * 1. Add group type node
 485      * <p>
 486      * 2. Add edge between the former node to its parent(if exists)
 487      * <p>
 488      * 3. Add property node and associate it to the node created at #1. (per property & if exists)
 489      *
 490      * @param groupTypeDefinition
 491      * @return
 492      */
 493     private Either<GroupTypeData, JanusGraphOperationStatus> addGroupTypeToGraph(GroupTypeDefinition groupTypeDefinition) {
 494
 495         log.debug("Got group type {}", groupTypeDefinition);
 496
 497         String ctUniqueId = UniqueIdBuilder.buildGroupTypeUid(groupTypeDefinition.getType(), groupTypeDefinition.getVersion(), "grouptype");
 498
 499         GroupTypeData groupTypeData = buildGroupTypeData(groupTypeDefinition, ctUniqueId);
 500
 501         log.debug("Before adding group type to graph. groupTypeData = {}", groupTypeData);
 502
 503         Either<GroupTypeData, JanusGraphOperationStatus> createGTResult = janusGraphGenericDao
 504             .createNode(groupTypeData, GroupTypeData.class);
 505         log.debug("After adding group type to graph. status is = {}", createGTResult);
 506
 507         if (createGTResult.isRight()) {
 508             JanusGraphOperationStatus operationStatus = createGTResult.right().value();
 509             log.error("Failed to add group type {} to graph. status is {}", groupTypeDefinition.getType(), operationStatus);
 510             return Either.right(operationStatus);
 511         }
 512
 513         GroupTypeData resultCTD = createGTResult.left().value();
 514         List<PropertyDefinition> properties = groupTypeDefinition.getProperties();
 515         Either<Map<String, PropertyData>, JanusGraphOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.GroupType, properties);
 516         if (addPropertiesToCapablityType.isRight()) {
 517             log.error("Failed add properties {} to capability {}", properties, groupTypeDefinition.getType());
 518             return Either.right(addPropertiesToCapablityType.right().value());
 519         }
 520
 521         String derivedFrom = groupTypeDefinition.getDerivedFrom();
 522         if (derivedFrom != null) {
 523             Either<GraphRelation, JanusGraphOperationStatus> createRelation = connectToDerivedFrom(ctUniqueId, derivedFrom);
 524             if (createRelation.isRight()) {
 525                 return Either.right(createRelation.right().value());
 526             }
 527         }
 528
 529         Map<String, CapabilityDefinition> groupCapTypes = groupTypeDefinition.getCapabilities();
 530         if (!MapUtils.isEmpty(groupCapTypes)) {
 531             JanusGraphOperationStatus status = createCapabilities(groupTypeData, groupCapTypes);
 532             if (status != JanusGraphOperationStatus.OK) {
 533                 return Either.right(status);
 534             }
 535         }
 536
 537         return Either.left(createGTResult.left().value());
 538
 539     }
 540
 541
 542     private Either<GraphRelation, JanusGraphOperationStatus> connectToDerivedFrom(String ctUniqueId, String derivedFrom) {
 543         log.debug("Before creating relation between Group Type with id {} to its parent {}", ctUniqueId, derivedFrom);
 544
 545         Either<GroupTypeData, JanusGraphOperationStatus> derivedFromGroupTypeResult =
 546                 janusGraphGenericDao
 547                     .getNode(GraphPropertiesDictionary.TYPE.getProperty(), derivedFrom, GroupTypeData.class);
 548
 549         if (derivedFromGroupTypeResult.isLeft()) {
 550             UniqueIdData from = new UniqueIdData(NodeTypeEnum.GroupType, ctUniqueId);
 551             GroupTypeData to = derivedFromGroupTypeResult.left().value();
 552
 553             Either<GraphRelation, JanusGraphOperationStatus> createRelation = janusGraphGenericDao
 554                 .createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null);
 555             log.debug("After create relation between Group Type with id {} to its parent {}, status is {}.", ctUniqueId, derivedFrom, createRelation);
 556             return createRelation;
 557         } else {
 558             JanusGraphOperationStatus status = derivedFromGroupTypeResult.right().value();
 559             log.debug("Failed to found parent Group Type {}, stauts is {}.", derivedFrom, status);
 560             return Either.right(status);
 561         }
 562     }
 563
 564     private GroupTypeData buildGroupTypeData(GroupTypeDefinition groupTypeDefinition, String ctUniqueId) {
 565
 566         GroupTypeData groupTypeData = new GroupTypeData(groupTypeDefinition);
 567
 568         groupTypeData.getGroupTypeDataDefinition().setUniqueId(ctUniqueId);
 569         Long creationDate = groupTypeData.getGroupTypeDataDefinition().getCreationTime();
 570         if (creationDate == null) {
 571             creationDate = System.currentTimeMillis();
 572         }
 573         groupTypeData.getGroupTypeDataDefinition().setCreationTime(creationDate);
 574         groupTypeData.getGroupTypeDataDefinition().setModificationTime(creationDate);
 575
 576         return groupTypeData;
 577     }
 578
 579     public Either<Boolean, StorageOperationStatus> isCapabilityTypeDerivedFrom(String childCandidateType, String parentCandidateType) {
 580         Map<String, Object> propertiesToMatch = new HashMap<>();
 581         propertiesToMatch.put(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), childCandidateType);
 582         Either<List<CapabilityTypeData>, JanusGraphOperationStatus> getResponse = janusGraphGenericDao
 583             .getByCriteria(NodeTypeEnum.CapabilityType, propertiesToMatch, CapabilityTypeData.class);
 584         if (getResponse.isRight()) {
 585             JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value();
 586             log.debug("Couldn't fetch capability type {}, error: {}", childCandidateType,
 587                 janusGraphOperationStatus);
 588             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(
 589                 janusGraphOperationStatus));
 590         }
 591         String childUniqueId = getResponse.left().value().get(0).getUniqueId();
 592         Set<String> travelledTypes = new HashSet<>();
 593         do {
 594             travelledTypes.add(childUniqueId);
 595             Either<List<ImmutablePair<CapabilityTypeData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 596                 .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), childUniqueId, GraphEdgeLabels.DERIVED_FROM,
 597                     NodeTypeEnum.CapabilityType, CapabilityTypeData.class);
 598             if (childrenNodes.isRight()) {
 599                 if (childrenNodes.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 600                     JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value();
 601                     log.debug("Couldn't fetch derived from node for capability type {}, error: {}", childCandidateType,
 602                         janusGraphOperationStatus);
 603                     return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(
 604                         janusGraphOperationStatus));
 605                 } else {
 606                     log.debug("Derived from node is not found for type {} - this is OK for root capability.", childCandidateType);
 607                     return Either.left(false);
 608                 }
 609             }
 610             String derivedFromUniqueId = childrenNodes.left().value().get(0).getLeft().getUniqueId();
 611             if (derivedFromUniqueId.equals(parentCandidateType)) {
 612                 log.debug("Verified that capability type {} derives from capability type {}", childCandidateType, parentCandidateType);
 613                 return Either.left(true);
 614             }
 615             childUniqueId = derivedFromUniqueId;
 616         } while (!travelledTypes.contains(childUniqueId));
 617         // this stop condition should never be used, if we use it, we have an
 618         // illegal cycle in graph - "derived from" hierarchy cannot be cycled.
 619         // It's here just to avoid infinite loop in case we have such cycle.
 620         log.error("Detected a cycle of \"derived from\" edges starting at capability type node {}", childUniqueId);
 621         return Either.right(StorageOperationStatus.GENERAL_ERROR);
 622     }
 623
 624     /**
 625      * @param list
 626      * @return
 627      */
 628     private Map<String, CapabilityDefinition> asCapabilitiesMap(List<CapabilityDefinition> list) {
 629         return list.stream()
 630                 .collect(Collectors.toMap(CapabilityDefinition::getName, Function.identity()));
 631     }
 632
 633
 634     private Either<GroupTypeDefinition, StorageOperationStatus> updateGroupTypeOnGraph(GroupTypeDefinition updatedGroupType, GroupTypeDefinition currGroupType) {
 635         updateGroupTypeData(updatedGroupType, currGroupType);
 636         return janusGraphGenericDao.updateNode(new GroupTypeData(updatedGroupType), GroupTypeData.class)
 637                 .right()
 638                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus)
 639                 .left()
 640                 .bind(updatedNode -> updateGroupProperties(updatedGroupType.getUniqueId(), updatedGroupType.getProperties()))
 641                 .left()
 642                 .bind(updatedProperties -> updateGroupDerivedFrom(updatedGroupType, currGroupType.getDerivedFrom()))
 643                 .right()
 644                 .bind(result -> TypeOperations.mapOkStatus(result, null))
 645                 .left()
 646                 .bind(updatedDerivedFrom -> TypeOperations.mapOkStatus(mergeCapabilities(updatedGroupType), updatedGroupType))
 647                 .left()
 648                 .bind(def -> getGroupTypeByUid(def.getUniqueId()));
 649     }
 650
 651
 652     private Either<Map<String, PropertyData>, StorageOperationStatus> updateGroupProperties(String groupId, List<PropertyDefinition> properties) {
 653         log.debug("#updateGroupProperties - updating group type properties for group type with id {}", groupId);
 654         Map<String, PropertyDefinition> mapProperties = properties != null? properties.stream()
 655                 .collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())): null;
 656         return propertyOperation.mergePropertiesAssociatedToNode(NodeTypeEnum.GroupType, groupId, mapProperties)
 657                 .right()
 658                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 659     }
 660
 661
 662
 663     private Either<GraphRelation, StorageOperationStatus> updateGroupDerivedFrom(GroupTypeDefinition updatedGroupType, String currDerivedFromGroupType) {
 664
 665         String groupTypeId = updatedGroupType.getUniqueId();
 666         if (StringUtils.equals(updatedGroupType.getDerivedFrom(), currDerivedFromGroupType)) {
 667             return Strings.isNullOrEmpty(currDerivedFromGroupType)?
 668                     Either.right(StorageOperationStatus.OK):
 669                         getLatestGroupTypeByType(currDerivedFromGroupType, true)
 670                         .left()
 671                         .map(def -> null);
 672         }
 673
 674         StorageOperationStatus status = isLegalToReplaceParent(currDerivedFromGroupType, updatedGroupType.getDerivedFrom(), updatedGroupType.getType());
 675         if ( status != StorageOperationStatus.OK) {
 676             return Either.right(status);
 677         }
 678
 679         log.debug("#updateGroupDerivedFrom - updating group derived from relation for group type with id {}. old derived type {}. new derived type {}", groupTypeId, currDerivedFromGroupType, updatedGroupType.getDerivedFrom());
 680         StorageOperationStatus deleteDerivedRelationStatus = deleteDerivedFromGroupType(groupTypeId, currDerivedFromGroupType);
 681         if (deleteDerivedRelationStatus != StorageOperationStatus.OK) {
 682             return Either.right(deleteDerivedRelationStatus);
 683         }
 684         return addDerivedFromRelation(updatedGroupType, groupTypeId);
 685     }
 686
 687     private StorageOperationStatus isLegalToReplaceParent(String oldTypeParent, String newTypeParent, String childType) {
 688         return derivedFromOperation.isUpdateParentAllowed(oldTypeParent, newTypeParent, childType, NodeTypeEnum.GroupType, GroupTypeData.class, t -> t.getGroupTypeDataDefinition().getType());
 689     }
 690
 691     private Either<GraphRelation, StorageOperationStatus> addDerivedFromRelation(GroupTypeDataDefinition groupTypeDef, String gtUniqueId) {
 692         String derivedFrom = groupTypeDef.getDerivedFrom();
 693         if (derivedFrom == null) {
 694             return Either.left(null);
 695         }
 696         log.debug("#addDerivedFromRelationBefore - adding derived from relation between group type {} to its parent {}", groupTypeDef.getType(), derivedFrom);
 697         return this.getLatestGroupTypeByType(derivedFrom, true)
 698                 .left()
 699                 .bind(derivedFromGroup -> derivedFromOperation.addDerivedFromRelation(gtUniqueId, derivedFromGroup.getUniqueId(), NodeTypeEnum.GroupType));
 700     }
 701
 702     private StorageOperationStatus deleteDerivedFromGroupType(String groupTypeId, String derivedFromType) {
 703         if (derivedFromType == null) {
 704             return StorageOperationStatus.OK;
 705         }
 706         log.debug("#deleteDerivedFromGroupType - deleting derivedFrom relation for group type with id {} and its derived type {}", groupTypeId, derivedFromType);
 707         return getLatestGroupTypeByType(derivedFromType, true)
 708                 .either(derivedFromNode -> derivedFromOperation.removeDerivedFromRelation(groupTypeId, derivedFromNode.getUniqueId(), NodeTypeEnum.GroupType),
 709                         err -> err);
 710     }
 711
 712     private void updateGroupTypeData(GroupTypeDefinition updatedTypeDefinition, GroupTypeDefinition currTypeDefinition) {
 713         updatedTypeDefinition.setUniqueId(currTypeDefinition.getUniqueId());
 714         updatedTypeDefinition.setCreationTime(currTypeDefinition.getCreationTime());
 715         updatedTypeDefinition.setModificationTime(System.currentTimeMillis());
 716     }
 717
 718 }