catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ElementOperation.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 package org.openecomp.sdc.be.model.operations.impl;
  21
  22 import fj.data.Either;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.EnumMap;
  26 import java.util.HashMap;
  27 import java.util.Iterator;
  28 import java.util.LinkedHashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Optional;
  32 import java.util.stream.Collectors;
  33 import org.apache.commons.collections4.CollectionUtils;
  34 import org.apache.commons.collections4.MapUtils;
  35 import org.apache.commons.lang3.tuple.ImmutablePair;
  36 import org.apache.tinkerpop.gremlin.structure.Vertex;
  37 import org.janusgraph.core.JanusGraph;
  38 import org.janusgraph.core.JanusGraphVertex;
  39 import org.openecomp.sdc.be.config.ArtifactConfigManager;
  40 import org.openecomp.sdc.be.config.ArtifactConfiguration;
  41 import org.openecomp.sdc.be.config.CategoryBaseTypeConfig;
  42 import org.openecomp.sdc.be.config.Configuration;
  43 import org.openecomp.sdc.be.config.ConfigurationManager;
  44 import org.openecomp.sdc.be.dao.api.ActionStatus;
  45 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  46 import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
  47 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  48 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphDao;
  49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  50 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  51 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  52 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  53 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  54 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  55 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  56 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  57 import org.openecomp.sdc.be.datatypes.category.CategoryDataDefinition;
  58 import org.openecomp.sdc.be.datatypes.category.GroupingDataDefinition;
  59 import org.openecomp.sdc.be.datatypes.category.SubCategoryDataDefinition;
  60 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  61 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  62 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  63 import org.openecomp.sdc.be.model.ArtifactType;
  64 import org.openecomp.sdc.be.model.BaseType;
  65 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  66 import org.openecomp.sdc.be.model.PropertyScope;
  67 import org.openecomp.sdc.be.model.Tag;
  68 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  69 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  70 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  71 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  72 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  73 import org.openecomp.sdc.be.resources.data.TagData;
  74 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  75 import org.openecomp.sdc.be.resources.data.category.GroupingData;
  76 import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
  77 import org.openecomp.sdc.common.log.wrappers.Logger;
  78 import org.openecomp.sdc.common.util.ValidationUtils;
  79 import org.springframework.beans.factory.annotation.Qualifier;
  80 import org.springframework.stereotype.Component;
  81
  82 @Component("element-operation")
  83 public class ElementOperation implements IElementOperation {
  84
  85     private static final String COULDN_T_FETCH_janusGraph_GRAPH = "Couldn't fetch janusgraph graph";
  86     private static final String UNKNOWN_CATEGORY_TYPE = "Unknown category type {}";
  87     private static final Logger log = Logger.getLogger(ElementOperation.class.getName());
  88     private static final String PROBLEM_WHILE_CREATING_CATEGORY_REASON = "Problem while creating category, reason {}";
  89     private JanusGraphGenericDao janusGraphGenericDao;
  90     private HealingJanusGraphDao janusGraphDao;
  91
  92     public ElementOperation(@Qualifier("janusgraph-generic-dao") JanusGraphGenericDao janusGraphGenericDao,
  93                             @Qualifier("janusgraph-dao") HealingJanusGraphDao janusGraphDao) {
  94         super();
  95         this.janusGraphGenericDao = janusGraphGenericDao;
  96         this.janusGraphDao = janusGraphDao;
  97     }
  98
  99     private static NodeTypeEnum getChildNodeType(NodeTypeEnum parentTypeEnum) {
 100         NodeTypeEnum res = null;
 101         switch (parentTypeEnum) {
 102             case ResourceNewCategory:
 103                 res = NodeTypeEnum.ResourceSubcategory;
 104                 break;
 105             case ProductCategory:
 106                 res = NodeTypeEnum.ProductSubcategory;
 107                 break;
 108             case ProductSubcategory:
 109                 res = NodeTypeEnum.ProductGrouping;
 110                 break;
 111             default:
 112                 break;
 113         }
 114         return res;
 115     }
 116
 117     /*
 118      * Old flow
 119      */
 120     @Override
 121     public Either<List<CategoryDefinition>, ActionStatus> getAllServiceCategories() {
 122         return getAllCategories(NodeTypeEnum.ServiceNewCategory, false);
 123     }
 124
 125     @Override
 126     public Either<List<CategoryDefinition>, ActionStatus> getAllResourceCategories() {
 127         return getAllCategories(NodeTypeEnum.ResourceNewCategory, false);
 128     }
 129
 130     @Override
 131     public Either<List<CategoryDefinition>, ActionStatus> getAllProductCategories() {
 132         return getAllCategories(NodeTypeEnum.ProductCategory, false);
 133     }
 134
 135     /*
 136      * New flow
 137      */
 138     @Override
 139     public Either<CategoryDefinition, ActionStatus> createCategory(CategoryDefinition category, NodeTypeEnum nodeType) {
 140         return createCategory(category, nodeType, false);
 141     }
 142
 143     @Override
 144     public Either<CategoryDefinition, ActionStatus> createCategory(CategoryDefinition category, NodeTypeEnum nodeType, boolean inTransaction) {
 145         Either<CategoryDefinition, ActionStatus> result = null;
 146         category.setUniqueId(UniqueIdBuilder.buildCategoryUid(category.getNormalizedName(), nodeType));
 147         CategoryData categoryData = new CategoryData(nodeType, category);
 148         try {
 149             Either<CategoryData, JanusGraphOperationStatus> createNode = janusGraphGenericDao.createNode(categoryData, CategoryData.class);
 150             if (createNode.isRight()) {
 151                 JanusGraphOperationStatus value = createNode.right().value();
 152                 ActionStatus actionStatus = ActionStatus.GENERAL_ERROR;
 153                 log.debug(PROBLEM_WHILE_CREATING_CATEGORY_REASON, value);
 154                 if (value == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) {
 155                     actionStatus = ActionStatus.COMPONENT_CATEGORY_ALREADY_EXISTS;
 156                 }
 157                 result = Either.right(actionStatus);
 158                 return result;
 159             }
 160             CategoryDefinition created = new CategoryDefinition(createNode.left().value().getCategoryDataDefinition());
 161             result = Either.left(created);
 162             return result;
 163         } finally {
 164             if (!inTransaction) {
 165                 if (result != null && result.isLeft()) {
 166                     janusGraphGenericDao.commit();
 167                 } else {
 168                     janusGraphGenericDao.rollback();
 169                 }
 170             }
 171         }
 172     }
 173
 174     @Override
 175     public Either<CategoryDefinition, ActionStatus> updateCategory(CategoryDefinition category, NodeTypeEnum nodeType) {
 176         return updateCategory(category, nodeType, false);
 177     }
 178
 179     @Override
 180     public Either<CategoryDefinition, ActionStatus> updateCategory(CategoryDefinition category, NodeTypeEnum nodeType, boolean inTransaction) {
 181         Either<CategoryDefinition, ActionStatus> result = null;
 182         category.setUniqueId(UniqueIdBuilder.buildCategoryUid(category.getNormalizedName(), nodeType));
 183         CategoryData categoryData = new CategoryData(nodeType, category);
 184         try {
 185             Either<CategoryData, JanusGraphOperationStatus> updatedNode = janusGraphGenericDao.updateNode(categoryData, CategoryData.class);
 186             if (updatedNode.isRight()) {
 187                 JanusGraphOperationStatus value = updatedNode.right().value();
 188                 ActionStatus actionStatus = ActionStatus.GENERAL_ERROR;
 189                 log.debug(PROBLEM_WHILE_CREATING_CATEGORY_REASON, value);
 190                 result = Either.right(actionStatus);
 191                 return result;
 192             }
 193             CategoryDefinition created = new CategoryDefinition(updatedNode.left().value().getCategoryDataDefinition());
 194             result = Either.left(created);
 195             return result;
 196         } finally {
 197             if (!inTransaction) {
 198                 if (result != null && result.isLeft()) {
 199                     janusGraphGenericDao.commit();
 200                 } else {
 201                     janusGraphGenericDao.rollback();
 202                 }
 203             }
 204         }
 205     }
 206
 207     @Override
 208     public Either<SubCategoryDefinition, ActionStatus> createSubCategory(String categoryId, SubCategoryDefinition subCategory,
 209                                                                          NodeTypeEnum nodeType) {
 210         return createSubCategory(categoryId, subCategory, nodeType, false);
 211     }
 212
 213     @Override
 214     public Either<SubCategoryDefinition, ActionStatus> createSubCategory(String categoryId, SubCategoryDefinition subCategory, NodeTypeEnum nodeType,
 215                                                                          boolean inTransaction) {
 216         Either<SubCategoryDefinition, ActionStatus> result = null;
 217         try {
 218             // create edge from category to sub-category
 219             Either<CategoryData, JanusGraphOperationStatus> categoryNode = janusGraphGenericDao
 220                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class);
 221             ActionStatus actionStatus = ActionStatus.GENERAL_ERROR;
 222             if (categoryNode.isRight()) {
 223                 JanusGraphOperationStatus janusGraphOperationStatus = categoryNode.right().value();
 224                 log.debug("Problem while fetching category, reason {}", janusGraphOperationStatus);
 225                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 226                     actionStatus = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND;
 227                 }
 228                 result = Either.right(actionStatus);
 229                 return result;
 230             }
 231             CategoryDataDefinition categoryDataDefinition = categoryNode.left().value().getCategoryDataDefinition();
 232             subCategory.setUniqueId(UniqueIdBuilder.buildSubCategoryUid(categoryDataDefinition.getUniqueId(), subCategory.getNormalizedName()));
 233             SubCategoryData subCategoryData = new SubCategoryData(nodeType, subCategory);
 234             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryNode = janusGraphGenericDao
 235                 .createNode(subCategoryData, SubCategoryData.class);
 236             if (subCategoryNode.isRight()) {
 237                 JanusGraphOperationStatus janusGraphOperationStatus = subCategoryNode.right().value();
 238                 log.debug(PROBLEM_WHILE_CREATING_CATEGORY_REASON, janusGraphOperationStatus);
 239                 if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) {
 240                     actionStatus = ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY;
 241                 }
 242                 result = Either.right(actionStatus);
 243                 return result;
 244             }
 245             Either<GraphRelation, JanusGraphOperationStatus> relation = janusGraphGenericDao
 246                 .createRelation(categoryNode.left().value(), subCategoryNode.left().value(), GraphEdgeLabels.SUB_CATEGORY, null);
 247             if (relation.isRight()) {
 248                 log.debug("Problem while create relation between category and sub-category ", relation.right().value());
 249                 result = Either.right(actionStatus);
 250                 return result;
 251             }
 252             SubCategoryDefinition subCategoryCreated = new SubCategoryDefinition(subCategoryNode.left().value().getSubCategoryDataDefinition());
 253             result = Either.left(subCategoryCreated);
 254             return result;
 255         } finally {
 256             if (!inTransaction) {
 257                 if (result != null && result.isLeft()) {
 258                     janusGraphGenericDao.commit();
 259                 } else {
 260                     janusGraphGenericDao.rollback();
 261                 }
 262             }
 263         }
 264     }
 265
 266     @Override
 267     public Either<SubCategoryDefinition, ActionStatus> updateSubCategory(String subCategoryId, SubCategoryDefinition subCategory,
 268                                                                          NodeTypeEnum nodeType) {
 269         return updateSubCategory(subCategoryId, subCategory, nodeType, false);
 270     }
 271
 272     @Override
 273     public Either<SubCategoryDefinition, ActionStatus> updateSubCategory(String subCategoryId, SubCategoryDefinition subCategory,
 274                                                                          NodeTypeEnum nodeType, boolean inTransaction) {
 275         Either<SubCategoryDefinition, ActionStatus> result = null;
 276         try {
 277             subCategory.setUniqueId(subCategoryId);
 278             SubCategoryData subCategoryData = new SubCategoryData(nodeType, subCategory);
 279             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryNode = janusGraphGenericDao
 280                 .updateNode(subCategoryData, SubCategoryData.class);
 281             if (subCategoryNode.isRight()) {
 282                 JanusGraphOperationStatus janusGraphOperationStatus = subCategoryNode.right().value();
 283                 log.debug("Problem while updating sub category, reason {}", janusGraphOperationStatus);
 284                 result = Either.right(ActionStatus.GENERAL_ERROR);
 285                 return result;
 286             }
 287             SubCategoryDefinition subCategoryUpdated = new SubCategoryDefinition(subCategoryNode.left().value().getSubCategoryDataDefinition());
 288             result = Either.left(subCategoryUpdated);
 289             return result;
 290         } finally {
 291             if (!inTransaction) {
 292                 if (result != null && result.isLeft()) {
 293                     janusGraphGenericDao.commit();
 294                 } else {
 295                     janusGraphGenericDao.rollback();
 296                 }
 297             }
 298         }
 299     }
 300
 301     @Override
 302     public Either<GroupingDefinition, ActionStatus> createGrouping(String subCategoryId, GroupingDefinition grouping, NodeTypeEnum nodeType) {
 303         Either<GroupingDefinition, ActionStatus> result = null;
 304         try {
 305             // create edge from sub-category to grouping
 306             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryNode = janusGraphGenericDao
 307                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class);
 308             ActionStatus actionStatus = ActionStatus.GENERAL_ERROR;
 309             if (subCategoryNode.isRight()) {
 310                 JanusGraphOperationStatus janusGraphOperationStatus = subCategoryNode.right().value();
 311                 log.debug("Problem while fetching category, reason {}", janusGraphOperationStatus);
 312                 if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) {
 313                     actionStatus = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND;
 314                 }
 315                 result = Either.right(actionStatus);
 316                 return result;
 317             }
 318             SubCategoryDataDefinition subCatData = subCategoryNode.left().value().getSubCategoryDataDefinition();
 319             grouping.setUniqueId(UniqueIdBuilder.buildGroupingUid(subCatData.getUniqueId(), grouping.getNormalizedName()));
 320             GroupingData groupingData = new GroupingData(nodeType, grouping);
 321             Either<GroupingData, JanusGraphOperationStatus> groupingNode = janusGraphGenericDao.createNode(groupingData, GroupingData.class);
 322             if (groupingNode.isRight()) {
 323                 JanusGraphOperationStatus janusGraphOperationStatus = groupingNode.right().value();
 324                 log.debug("Problem while creating grouping, reason {}", janusGraphOperationStatus);
 325                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 326                     actionStatus = ActionStatus.COMPONENT_GROUPING_EXISTS_FOR_SUB_CATEGORY;
 327                 }
 328                 result = Either.right(actionStatus);
 329                 return result;
 330             }
 331             Either<GraphRelation, JanusGraphOperationStatus> relation = janusGraphGenericDao
 332                 .createRelation(subCategoryNode.left().value(), groupingNode.left().value(), GraphEdgeLabels.GROUPING, null);
 333             if (relation.isRight()) {
 334                 log.debug("Problem while create relation between sub-category and grouping", relation.right().value());
 335                 result = Either.right(actionStatus);
 336                 return result;
 337             }
 338             GroupingDefinition groupingCreated = new GroupingDefinition(groupingNode.left().value().getGroupingDataDefinition());
 339             result = Either.left(groupingCreated);
 340             return result;
 341         } finally {
 342             if (result != null && result.isLeft()) {
 343                 janusGraphGenericDao.commit();
 344             } else {
 345                 janusGraphGenericDao.rollback();
 346             }
 347         }
 348     }
 349
 350     @Override
 351     public Either<List<CategoryDefinition>, ActionStatus> getAllCategories(NodeTypeEnum nodeType, boolean inTransaction) {
 352         try {
 353             if (nodeType != NodeTypeEnum.ResourceNewCategory && nodeType != NodeTypeEnum.ServiceNewCategory
 354                 && nodeType != NodeTypeEnum.ProductCategory) {
 355                 log.debug(UNKNOWN_CATEGORY_TYPE, nodeType.name());
 356                 return Either.right(ActionStatus.GENERAL_ERROR);
 357             }
 358             Either<List<org.openecomp.sdc.be.resources.data.category.CategoryData>, JanusGraphOperationStatus> either = janusGraphGenericDao
 359                 .getAll(nodeType, org.openecomp.sdc.be.resources.data.category.CategoryData.class);
 360             if (either.isRight() && (either.right().value() != JanusGraphOperationStatus.NOT_FOUND)) {
 361                 log.debug("Problem while get all categories. reason - {}", either.right().value());
 362                 return Either.right(ActionStatus.GENERAL_ERROR);
 363             }
 364             List<CategoryData> categoryDataList = either.isLeft() ? either.left().value() : null;
 365             List<CategoryDefinition> categoryList = new ArrayList<>();
 366             if (categoryDataList != null) {
 367                 for (CategoryData elem : categoryDataList) {
 368                     CategoryDataDefinition categoryDataDefinition = elem.getCategoryDataDefinition();
 369                     CategoryDefinition categoryDefinition = new CategoryDefinition(categoryDataDefinition);
 370                     String categoryName = categoryDataDefinition.getName();
 371                     log.trace("Found category {}, category type {}", categoryName, nodeType);
 372                     JanusGraphOperationStatus setSubCategories = setSubCategories(nodeType, categoryDefinition);
 373                     if (setSubCategories != JanusGraphOperationStatus.OK) {
 374                         log.debug("Failed to set sub-categories for category {}, category type {}, error {}", categoryName, nodeType,
 375                             setSubCategories);
 376                         return Either.right(ActionStatus.GENERAL_ERROR);
 377                     }
 378                     categoryList.add(categoryDefinition);
 379                 }
 380             }
 381             return Either.left(categoryList);
 382         } finally {
 383             if (!inTransaction) {
 384                 janusGraphGenericDao.commit();
 385             }
 386         }
 387     }
 388
 389     @Override
 390     public List<BaseType> getServiceBaseTypes(final String categoryName, final String modelName) {
 391
 392         final CategoryBaseTypeConfig categoryBaseTypeConfig = getCategoryBaseTypeConfig(categoryName).orElse(null);
 393         final List<String> baseToscaResourceNames;
 394         if (categoryBaseTypeConfig == null) {
 395             final String generalBaseType = getConfiguration().getGenericAssetNodeTypes().get("Service");
 396             baseToscaResourceNames = List.of(generalBaseType);
 397         } else {
 398             baseToscaResourceNames = getCategoryBaseTypes(categoryName);
 399         }
 400
 401         final ArrayList<BaseType> baseTypes = new ArrayList<>();
 402         baseToscaResourceNames.forEach(baseToscaResourceName -> {
 403             final Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 404             props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, baseToscaResourceName);
 405             props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 406             final Either<List<GraphVertex>, JanusGraphOperationStatus> baseTypeVertex = janusGraphDao
 407                 .getByCriteria(VertexTypeEnum.NODE_TYPE, props, null, JsonParseFlagEnum.ParseAll, modelName);
 408
 409             if (baseTypeVertex.isLeft()) {
 410                 BaseType baseType = new BaseType(baseToscaResourceName);
 411                 baseTypes.add(baseType);
 412
 413                 final Map<String, List<String>> typesDerivedFromBaseType = new LinkedHashMap<>();
 414                 baseTypeVertex.left().value().forEach(v -> {
 415                     baseType.addVersion((String) v.getMetadataProperty(GraphPropertyEnum.VERSION));
 416                     addTypesDerivedFromVertex(typesDerivedFromBaseType, v);
 417                 });
 418
 419                 typesDerivedFromBaseType.forEach((k, v) -> baseTypes.add(new BaseType(k, v)));
 420             }
 421         });
 422
 423         return baseTypes;
 424     }
 425
 426     private Configuration getConfiguration() {
 427         return ConfigurationManager.getConfigurationManager().getConfiguration();
 428     }
 429
 430     @Override
 431     public boolean isBaseTypeRequired(final String categoryName) {
 432         final Map<String, CategoryBaseTypeConfig> categoriesSpecificBaseTypeMap = getConfiguration().getServiceBaseNodeTypes();
 433         if (MapUtils.isEmpty(categoriesSpecificBaseTypeMap)) {
 434             return true;
 435         }
 436
 437         final CategoryBaseTypeConfig categoryBaseTypeConfig = categoriesSpecificBaseTypeMap.get(categoryName);
 438         if (categoryBaseTypeConfig == null) {
 439             return true;
 440         }
 441
 442         return categoryBaseTypeConfig.isRequired();
 443     }
 444
 445     private List<String> getCategoryBaseTypes(final String categoryName) {
 446         final Optional<CategoryBaseTypeConfig> categoryBaseTypeConfigOptional = getCategoryBaseTypeConfig(categoryName);
 447         if (categoryBaseTypeConfigOptional.isEmpty()) {
 448             return Collections.emptyList();
 449         }
 450
 451         final CategoryBaseTypeConfig categoryBaseTypeConfig = categoryBaseTypeConfigOptional.get();
 452         if (CollectionUtils.isEmpty(categoryBaseTypeConfig.getBaseTypes())) {
 453             return Collections.emptyList();
 454         }
 455
 456         return categoryBaseTypeConfig.getBaseTypes();
 457     }
 458
 459     private Optional<CategoryBaseTypeConfig> getCategoryBaseTypeConfig(final String categoryName) {
 460         final Map<String, CategoryBaseTypeConfig> categoriesSpecificBaseTypes = getConfiguration().getServiceBaseNodeTypes();
 461         if (categoriesSpecificBaseTypes == null) {
 462             return Optional.empty();
 463         }
 464
 465         return Optional.ofNullable(categoriesSpecificBaseTypes.get(categoryName));
 466     }
 467
 468     private Map<String, List<String>> addTypesDerivedFromVertex(final Map<String, List<String>> types, final GraphVertex vertex) {
 469         final Either<List<GraphVertex>, JanusGraphOperationStatus> derivedFromVertex =
 470             janusGraphDao.getParentVertices(vertex, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.ParseAll);
 471         if (derivedFromVertex.isLeft()) {
 472             derivedFromVertex.left().value().stream()
 473                 .filter(v -> v.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name()))
 474                 .forEach(v -> {
 475                     addBaseTypeVersion(types, (String) v.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME),
 476                         (String) v.getMetadataProperty(GraphPropertyEnum.VERSION));
 477                     addTypesDerivedFromVertex(types, v);
 478                 });
 479         }
 480         return types;
 481     }
 482
 483     private void addBaseTypeVersion(final Map<String, List<String>> baseTypes, final String baseTypeToscaResourceName, final String baseTypeVersion) {
 484         List<String> versions = baseTypes.get(baseTypeToscaResourceName) == null ? new ArrayList<>() : baseTypes.get(baseTypeToscaResourceName);
 485         versions.add(baseTypeVersion);
 486         baseTypes.put(baseTypeToscaResourceName, versions);
 487     }
 488
 489     private JanusGraphOperationStatus setSubCategories(NodeTypeEnum parentNodeType, CategoryDefinition parentCategory) {
 490         NodeTypeEnum childNodeType = getChildNodeType(parentNodeType);
 491         if (childNodeType != null) {
 492             String categoryName = parentCategory.getName();
 493             log.trace("Getting sub-categories for category {}, category type {}", categoryName, parentNodeType);
 494             Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, JanusGraphOperationStatus> parentNode = janusGraphGenericDao
 495                 .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentCategory.getUniqueId(), GraphEdgeLabels.SUB_CATEGORY,
 496                     childNodeType, SubCategoryData.class);
 497             if (parentNode.isRight()) {
 498                 JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value();
 499                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 500                     log.trace("Didn't find subcategories for category {}, category type {}", categoryName, parentNodeType);
 501                     janusGraphOperationStatus = JanusGraphOperationStatus.OK;
 502                 }
 503                 return janusGraphOperationStatus;
 504             }
 505             List<ImmutablePair<SubCategoryData, GraphEdge>> subsCategoriesData = parentNode.left().value();
 506             List<SubCategoryDefinition> subCategoriesDefinitions = new ArrayList<>();
 507             for (ImmutablePair<SubCategoryData, GraphEdge> subCatPair : subsCategoriesData) {
 508                 SubCategoryDataDefinition subCategoryDataDefinition = subCatPair.getLeft().getSubCategoryDataDefinition();
 509                 SubCategoryDefinition subCategoryDefinition = new SubCategoryDefinition(subCategoryDataDefinition);
 510                 log.trace("Found sub-category {} for category {}, category type {}", subCategoryDataDefinition.getName(), categoryName,
 511                     parentNodeType);
 512                 JanusGraphOperationStatus setGroupings = setGroupings(childNodeType, subCategoryDefinition);
 513                 if (setGroupings != JanusGraphOperationStatus.OK) {
 514                     log.debug("Failed to set groupings for sub-category {}, sub-category type {}, error {}", subCategoryDataDefinition.getName(),
 515                         childNodeType, setGroupings);
 516                     return JanusGraphOperationStatus.GENERAL_ERROR;
 517                 }
 518                 subCategoriesDefinitions.add(subCategoryDefinition);
 519             }
 520             parentCategory.setSubcategories(subCategoriesDefinitions);
 521         }
 522         return JanusGraphOperationStatus.OK;
 523     }
 524
 525     private JanusGraphOperationStatus setGroupings(NodeTypeEnum parentNodeType, SubCategoryDefinition parentSubCategory) {
 526         NodeTypeEnum childNodeType = getChildNodeType(parentNodeType);
 527         if (childNodeType != null) {
 528             String subCategoryName = parentSubCategory.getName();
 529             log.trace("Getting groupings for subcategory {}, subcategory type {}", subCategoryName, parentNodeType);
 530             Either<List<ImmutablePair<GroupingData, GraphEdge>>, JanusGraphOperationStatus> parentNode = janusGraphGenericDao
 531                 .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentSubCategory.getUniqueId(), GraphEdgeLabels.GROUPING,
 532                     childNodeType, GroupingData.class);
 533             if (parentNode.isRight()) {
 534                 JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value();
 535                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 536                     log.trace("Didn't find groupings for subcategory {}, subcategory type {}", subCategoryName, parentNodeType);
 537                     janusGraphOperationStatus = JanusGraphOperationStatus.OK;
 538                 }
 539                 return janusGraphOperationStatus;
 540             }
 541             List<ImmutablePair<GroupingData, GraphEdge>> groupingData = parentNode.left().value();
 542             List<GroupingDefinition> groupingDefinitions = new ArrayList<>();
 543             for (ImmutablePair<GroupingData, GraphEdge> groupPair : groupingData) {
 544                 GroupingDataDefinition groupingDataDefinition = groupPair.getLeft().getGroupingDataDefinition();
 545                 log.trace("Found grouping {} for sub-category {}, sub-category type {}", groupingDataDefinition.getName(), subCategoryName,
 546                     parentNodeType);
 547                 groupingDefinitions.add(new GroupingDefinition(groupingDataDefinition));
 548             }
 549             parentSubCategory.setGroupings(groupingDefinitions);
 550         }
 551         return JanusGraphOperationStatus.OK;
 552     }
 553
 554     @Override
 555     public Either<CategoryDefinition, ActionStatus> getCategory(NodeTypeEnum nodeType, String categoryId) {
 556         try {
 557             if (nodeType != NodeTypeEnum.ResourceNewCategory && nodeType != NodeTypeEnum.ServiceNewCategory
 558                 && nodeType != NodeTypeEnum.ProductCategory) {
 559                 log.debug(UNKNOWN_CATEGORY_TYPE, nodeType.name());
 560                 return Either.right(ActionStatus.GENERAL_ERROR);
 561             }
 562             Either<CategoryData, JanusGraphOperationStatus> categoryDataEither = janusGraphGenericDao
 563                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class);
 564             if (categoryDataEither.isRight()) {
 565                 JanusGraphOperationStatus janusGraphOperationStatus = categoryDataEither.right().value();
 566                 log.debug("Problem while get category by id {}. reason {}", categoryId, janusGraphOperationStatus);
 567                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 568                     return Either.right(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND);
 569                 }
 570                 return Either.right(ActionStatus.GENERAL_ERROR);
 571             }
 572             CategoryDataDefinition categoryDataDefinition = categoryDataEither.left().value().getCategoryDataDefinition();
 573             return Either.left(new CategoryDefinition(categoryDataDefinition));
 574         } finally {
 575             janusGraphGenericDao.commit();
 576         }
 577     }
 578
 579     @Override
 580     public Either<SubCategoryDefinition, ActionStatus> getSubCategory(NodeTypeEnum nodeType, String subCategoryId) {
 581         try {
 582             if (nodeType != NodeTypeEnum.ResourceSubcategory && nodeType != NodeTypeEnum.ProductSubcategory) {
 583                 log.debug("Unknown sub-category type {}", nodeType.name());
 584                 return Either.right(ActionStatus.GENERAL_ERROR);
 585             }
 586             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryDataEither = janusGraphGenericDao
 587                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class);
 588             if (subCategoryDataEither.isRight()) {
 589                 JanusGraphOperationStatus janusGraphOperationStatus = subCategoryDataEither.right().value();
 590                 log.debug("Problem while get sub-category by id {}. reason {}", subCategoryId, janusGraphOperationStatus);
 591                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 592                     return Either.right(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND);
 593                 }
 594                 return Either.right(ActionStatus.GENERAL_ERROR);
 595             }
 596             SubCategoryDataDefinition subCategoryDataDefinition = subCategoryDataEither.left().value().getSubCategoryDataDefinition();
 597             return Either.left(new SubCategoryDefinition(subCategoryDataDefinition));
 598         } finally {
 599             janusGraphGenericDao.commit();
 600         }
 601     }
 602
 603     @Override
 604     public Either<CategoryDefinition, ActionStatus> deleteCategory(NodeTypeEnum nodeType, String categoryId) {
 605         Either<CategoryDefinition, ActionStatus> result = null;
 606         try {
 607             if (nodeType != NodeTypeEnum.ResourceNewCategory && nodeType != NodeTypeEnum.ServiceNewCategory
 608                 && nodeType != NodeTypeEnum.ProductCategory) {
 609                 log.debug(UNKNOWN_CATEGORY_TYPE, nodeType.name());
 610                 result = Either.right(ActionStatus.GENERAL_ERROR);
 611                 return result;
 612             }
 613             Either<CategoryData, JanusGraphOperationStatus> categoryDataEither = janusGraphGenericDao
 614                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class);
 615             if (categoryDataEither.isRight()) {
 616                 log.debug("Failed to retrieve  category for id {} ", categoryId);
 617                 result = Either.right(ActionStatus.GENERAL_ERROR);
 618                 return result;
 619             }
 620             Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphGenericDao.getGraph();
 621             if (graph.isRight()) {
 622                 log.debug(COULDN_T_FETCH_janusGraph_GRAPH);
 623                 result = Either.right(ActionStatus.GENERAL_ERROR);
 624                 return result;
 625             }
 626             JanusGraph tGraph = graph.left().value();
 627             Iterable<JanusGraphVertex> verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId).vertices();
 628             Iterator<JanusGraphVertex> iterator = verticesArtifact.iterator();
 629             if (!iterator.hasNext()) {
 630                 log.debug("No category node for id = {}", categoryId);
 631                 result = Either.right(ActionStatus.GENERAL_ERROR);
 632                 return result;
 633             }
 634             Vertex artifactV = iterator.next();
 635             artifactV.remove();
 636             CategoryDefinition deleted = new CategoryDefinition(categoryDataEither.left().value().getCategoryDataDefinition());
 637             result = Either.left(deleted);
 638             return result;
 639         } finally {
 640             if (result != null && result.isLeft()) {
 641                 janusGraphGenericDao.commit();
 642             } else {
 643                 janusGraphGenericDao.rollback();
 644             }
 645         }
 646     }
 647
 648     @Override
 649     public Either<SubCategoryDefinition, ActionStatus> deleteSubCategory(NodeTypeEnum nodeType, String subCategoryId) {
 650         Either<SubCategoryDefinition, ActionStatus> result = null;
 651         try {
 652             if (nodeType != NodeTypeEnum.ResourceSubcategory && nodeType != NodeTypeEnum.ProductSubcategory) {
 653                 log.debug("Unknown sub-category type {}", nodeType.name());
 654                 result = Either.right(ActionStatus.GENERAL_ERROR);
 655                 return result;
 656             }
 657             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryDataEither = janusGraphGenericDao
 658                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class);
 659             if (subCategoryDataEither.isRight()) {
 660                 log.debug("Failed to retrieve  sub-category for id {}", subCategoryId);
 661                 result = Either.right(ActionStatus.GENERAL_ERROR);
 662                 return result;
 663             }
 664             Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphGenericDao.getGraph();
 665             if (graph.isRight()) {
 666                 log.debug(COULDN_T_FETCH_janusGraph_GRAPH);
 667                 result = Either.right(ActionStatus.GENERAL_ERROR);
 668                 return result;
 669             }
 670             JanusGraph tGraph = graph.left().value();
 671             Iterable<JanusGraphVertex> verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId).vertices();
 672             Iterator<JanusGraphVertex> iterator = verticesArtifact.iterator();
 673             if (!iterator.hasNext()) {
 674                 log.debug("No sub-category node for id {}", subCategoryId);
 675                 result = Either.right(ActionStatus.GENERAL_ERROR);
 676                 return result;
 677             }
 678             Vertex artifactV = iterator.next();
 679             artifactV.remove();
 680
 681             SubCategoryDefinition deleted = new SubCategoryDefinition(subCategoryDataEither.left().value().getSubCategoryDataDefinition());
 682             result = Either.left(deleted);
 683             return result;
 684         } finally {
 685             if (result != null && result.isLeft()) {
 686                 janusGraphGenericDao.commit();
 687             } else {
 688                 janusGraphGenericDao.rollback();
 689             }
 690         }
 691     }
 692
 693     @Override
 694     public Either<GroupingDefinition, ActionStatus> deleteGrouping(NodeTypeEnum nodeType, String groupingId) {
 695         Either<GroupingDefinition, ActionStatus> result = null;
 696         try {
 697             if (nodeType != NodeTypeEnum.ProductGrouping) {
 698                 log.debug("Unknown grouping type {}", nodeType.name());
 699                 result = Either.right(ActionStatus.GENERAL_ERROR);
 700                 return result;
 701             }
 702             Either<GroupingData, JanusGraphOperationStatus> groupingDataEither = janusGraphGenericDao
 703                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class);
 704             if (groupingDataEither.isRight()) {
 705                 log.debug("Failed to retrieve  grouping for id {}", groupingId);
 706                 result = Either.right(ActionStatus.GENERAL_ERROR);
 707                 return result;
 708             }
 709             Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphGenericDao.getGraph();
 710             if (graph.isRight()) {
 711                 log.debug(COULDN_T_FETCH_janusGraph_GRAPH);
 712                 result = Either.right(ActionStatus.GENERAL_ERROR);
 713                 return result;
 714             }
 715             JanusGraph tGraph = graph.left().value();
 716             Iterable<JanusGraphVertex> verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId).vertices();
 717             Iterator<JanusGraphVertex> iterator = verticesArtifact.iterator();
 718             if (!iterator.hasNext()) {
 719                 log.debug("No grouping node for id {}", groupingId);
 720                 result = Either.right(ActionStatus.GENERAL_ERROR);
 721                 return result;
 722             }
 723             Vertex artifactV = iterator.next();
 724             artifactV.remove();
 725
 726             GroupingDefinition deleted = new GroupingDefinition(groupingDataEither.left().value().getGroupingDataDefinition());
 727             result = Either.left(deleted);
 728             return result;
 729         } finally {
 730             if (result != null && result.isLeft()) {
 731                 janusGraphGenericDao.commit();
 732             } else {
 733                 janusGraphGenericDao.rollback();
 734             }
 735         }
 736     }
 737
 738     @Override
 739     public Either<Boolean, ActionStatus> isCategoryUniqueForType(NodeTypeEnum nodeType, String normalizedName) {
 740         Map<String, Object> properties = new HashMap<>();
 741         properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), normalizedName);
 742         try {
 743             Either<List<CategoryData>, JanusGraphOperationStatus> categoryEither = janusGraphGenericDao
 744                 .getByCriteria(nodeType, properties, CategoryData.class);
 745             if (categoryEither.isRight() && categoryEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 746                 log.debug("Failed to get categories, nodeType {}, normalizedName {}, error {}", nodeType, normalizedName,
 747                     categoryEither.right().value());
 748                 return Either.right(ActionStatus.GENERAL_ERROR);
 749             }
 750             List<CategoryData> categoryList = (categoryEither.isLeft() ? categoryEither.left().value() : null);
 751             if (categoryList != null && categoryList.size() > 0) {
 752                 log.debug("Found category for nodeType {} with normalizedName {}", nodeType, normalizedName);
 753                 if (categoryList.size() > 1) {
 754                     log.debug("Found more than 1 unique categories for nodeType {} with normalizedName", nodeType, normalizedName);
 755                     return Either.right(ActionStatus.GENERAL_ERROR);
 756                 }
 757                 return Either.left(false);
 758             } else {
 759                 log.debug("Category for nodeType {} with normalizedName {} doesn't exist in graph", nodeType, normalizedName);
 760                 return Either.left(true);
 761             }
 762         } finally {
 763             janusGraphGenericDao.commit();
 764         }
 765     }
 766
 767     @Override
 768     public Either<Boolean, ActionStatus> isSubCategoryUniqueForCategory(NodeTypeEnum nodeType, String subCategoryNormName, String parentCategoryId) {
 769         String subCategoryId = UniqueIdBuilder.buildSubCategoryUid(parentCategoryId, subCategoryNormName);
 770         try {
 771             Either<SubCategoryData, JanusGraphOperationStatus> subCategoryDataEither = janusGraphGenericDao
 772                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class);
 773             if (subCategoryDataEither.isRight() && subCategoryDataEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 774                 log.debug("Failed to get sub-category with id {}, error {}", subCategoryId, subCategoryDataEither.right().value());
 775                 return Either.right(ActionStatus.GENERAL_ERROR);
 776             }
 777             SubCategoryData subCategoryData = (subCategoryDataEither.isLeft() ? subCategoryDataEither.left().value() : null);
 778             if (subCategoryData != null) {
 779                 log.debug("Found sub-category with id {}", subCategoryId);
 780                 return Either.left(false);
 781             } else {
 782                 log.debug("Sub-category for id {} doesn't exist in graph", subCategoryId);
 783                 return Either.left(true);
 784             }
 785         } finally {
 786             janusGraphGenericDao.commit();
 787         }
 788     }
 789
 790     @Override
 791     public Either<Boolean, ActionStatus> isGroupingUniqueForSubCategory(NodeTypeEnum nodeType, String groupingNormName, String parentSubCategoryId) {
 792         String groupingId = UniqueIdBuilder.buildGroupingUid(parentSubCategoryId, groupingNormName);
 793         try {
 794             Either<GroupingData, JanusGraphOperationStatus> groupingDataEither = janusGraphGenericDao
 795                 .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class);
 796             if (groupingDataEither.isRight() && groupingDataEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 797                 log.debug("Failed to get grouping with id {}, error {}", groupingId, groupingDataEither.right().value());
 798                 return Either.right(ActionStatus.GENERAL_ERROR);
 799             }
 800             GroupingData groupingData = (groupingDataEither.isLeft() ? groupingDataEither.left().value() : null);
 801             if (groupingData != null) {
 802                 log.debug("Found grouping with id {}", groupingId);
 803                 return Either.left(false);
 804             } else {
 805                 log.debug("Grouping for id {} doesn't exist in graph", groupingId);
 806                 return Either.left(true);
 807             }
 808         } finally {
 809             janusGraphGenericDao.commit();
 810         }
 811     }
 812
 813     @Override
 814     public Either<SubCategoryDefinition, ActionStatus> getSubCategoryUniqueForType(NodeTypeEnum nodeType, String normalizedName) {
 815         Map<String, Object> properties = new HashMap<>();
 816         properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), normalizedName);
 817         try {
 818             Either<List<SubCategoryData>, JanusGraphOperationStatus> subCategoryEither = janusGraphGenericDao
 819                 .getByCriteria(nodeType, properties, SubCategoryData.class);
 820             if (subCategoryEither.isRight() && subCategoryEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 821                 log.debug("Failed to get sub-categories, nodeType {}, normalizedName {}, error {}", nodeType, normalizedName,
 822                     subCategoryEither.right().value());
 823                 return Either.right(ActionStatus.GENERAL_ERROR);
 824             }
 825             List<SubCategoryData> subCategoryList = (subCategoryEither.isLeft() ? subCategoryEither.left().value() : null);
 826             if (subCategoryList != null && subCategoryList.size() > 0) {
 827                 log.debug("Found sub-category for nodeType {} with normalizedName {}", nodeType, normalizedName);
 828                 SubCategoryData subCategoryData = subCategoryList.get(0);
 829                 SubCategoryDefinition subCategoryDefinition = new SubCategoryDefinition(subCategoryData.getSubCategoryDataDefinition());
 830                 return Either.left(subCategoryDefinition);
 831             } else {
 832                 log.debug("Sub-category for nodeType {} with normalizedName {} doesn't exist in graph", nodeType, normalizedName);
 833                 return Either.left(null);
 834             }
 835         } finally {
 836             janusGraphGenericDao.commit();
 837         }
 838     }
 839
 840     @Override
 841     public Either<GroupingDefinition, ActionStatus> getGroupingUniqueForType(NodeTypeEnum nodeType, String groupingNormalizedName) {
 842         Map<String, Object> properties = new HashMap<>();
 843         properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), groupingNormalizedName);
 844         try {
 845             Either<List<GroupingData>, JanusGraphOperationStatus> groupingEither = janusGraphGenericDao
 846                 .getByCriteria(nodeType, properties, GroupingData.class);
 847             if (groupingEither.isRight() && groupingEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
 848                 log.debug("Failed to get grouping, nodeType {}, normalizedName {}, error {}", nodeType, groupingNormalizedName,
 849                     groupingEither.right().value());
 850                 return Either.right(ActionStatus.GENERAL_ERROR);
 851             }
 852             List<GroupingData> groupingList = (groupingEither.isLeft() ? groupingEither.left().value() : null);
 853             if (groupingList != null && groupingList.size() > 0) {
 854                 log.debug("Found grouping for nodeType {} with normalizedName {}", nodeType, groupingNormalizedName);
 855                 GroupingData groupingData = groupingList.get(0);
 856                 GroupingDefinition groupingDefinition = new GroupingDefinition(groupingData.getGroupingDataDefinition());
 857                 return Either.left(groupingDefinition);
 858             } else {
 859                 log.debug("Grouping for nodeType {} with normalizedName {} doesn't exist in graph", nodeType, groupingNormalizedName);
 860                 return Either.left(null);
 861             }
 862         } finally {
 863             janusGraphGenericDao.commit();
 864         }
 865     }
 866
 867     /*
 868      *
 869      */
 870     @Override
 871     public Either<List<Tag>, ActionStatus> getAllTags() {
 872         try {
 873             Either<List<TagData>, JanusGraphOperationStatus> either = janusGraphGenericDao.getAll(NodeTypeEnum.Tag, TagData.class);
 874             if (either.isRight()) {
 875                 log.debug("Problem while get all tags. reason - {}", either.right().value());
 876                 return Either.right(ActionStatus.GENERAL_ERROR);
 877             }
 878             List<TagData> tagDataList = either.left().value();
 879             List<Tag> tagList = convertToListOfTag(tagDataList);
 880             return Either.left(tagList);
 881         } finally {
 882             janusGraphGenericDao.commit();
 883         }
 884     }
 885
 886     @Override
 887     public <T extends GraphNode> Either<org.openecomp.sdc.be.resources.data.CategoryData, StorageOperationStatus> getCategoryData(String name,
 888                                                                                                                                   NodeTypeEnum type,
 889                                                                                                                                   Class<T> clazz) {
 890         if (name != null) {
 891             String categoryUid = null;
 892             if (type == NodeTypeEnum.ResourceCategory) {
 893                 String[] categoryFields = name.split("/");
 894                 if (categoryFields.length != 2) {
 895                     return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND);
 896                 }
 897                 categoryUid = UniqueIdBuilder.buildResourceCategoryUid(categoryFields[0], categoryFields[1], type);
 898             } else {
 899                 categoryUid = UniqueIdBuilder.buildServiceCategoryUid(name, type);
 900             }
 901             Either<T, JanusGraphOperationStatus> either = janusGraphGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(type), categoryUid, clazz);
 902             if (either.isRight()) {
 903                 JanusGraphOperationStatus janusGraphOperationStatus = either.right().value();
 904                 log.debug("Problem while geting category with id {}. reason - {}", categoryUid, janusGraphOperationStatus.name());
 905                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 906                     return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND);
 907                 } else {
 908                     return Either.right(StorageOperationStatus.GENERAL_ERROR);
 909                 }
 910             }
 911             return Either.left((org.openecomp.sdc.be.resources.data.CategoryData) either.left().value());
 912         } else {
 913             return Either.right(StorageOperationStatus.GENERAL_ERROR);
 914         }
 915     }
 916
 917     private List<Tag> convertToListOfTag(List<TagData> tagDataList) {
 918         List<Tag> tagList = new ArrayList<>();
 919         for (TagData elem : tagDataList) {
 920             Tag tag = new Tag();
 921             tag.setName(elem.getName());
 922             tagList.add(tag);
 923         }
 924         return tagList;
 925     }
 926
 927     @Override
 928     public Either<List<PropertyScope>, ActionStatus> getAllPropertyScopes() {
 929         // Mock
 930         List<PropertyScope> propertyScopes = new ArrayList<>();
 931         PropertyScope propertyScope1 = new PropertyScope();
 932         propertyScope1.setName("A&AI");
 933         PropertyScope propertyScope2 = new PropertyScope();
 934         propertyScope2.setName("Order");
 935         PropertyScope propertyScope3 = new PropertyScope();
 936         propertyScope3.setName("Runtime");
 937         propertyScopes.add(propertyScope1);
 938         propertyScopes.add(propertyScope2);
 939         propertyScopes.add(propertyScope3);
 940         return Either.left(propertyScopes);
 941     }
 942
 943     @Override
 944     public List<ArtifactType> getAllArtifactTypes() {
 945         final List<ArtifactConfiguration> artifactTypesList = ArtifactConfigManager.getInstance().getConfiguration();
 946         return artifactTypesList.stream().map(artifactConfiguration -> {
 947             final ArtifactType artifactType = new ArtifactType();
 948             artifactType.setName(artifactConfiguration.getType());
 949             return artifactType;
 950         }).collect(Collectors.toList());
 951     }
 952
 953     @Override
 954     public Either<Configuration.HeatDeploymentArtifactTimeout, ActionStatus> getDefaultHeatTimeout() {
 955         return Either.left(getConfiguration().getHeatArtifactDeploymentTimeout());
 956     }
 957
 958     @Override
 959     public Either<Map<String, String>, ActionStatus> getResourceTypesMap() {
 960         ResourceTypeEnum[] enumConstants = ResourceTypeEnum.class.getEnumConstants();
 961         Map<String, String> resourceTypes = new HashMap<>();
 962         if (enumConstants != null) {
 963             for (int i = 0; i < enumConstants.length; ++i) {
 964                 resourceTypes.put(enumConstants[i].name(), enumConstants[i].getValue());
 965             }
 966         }
 967         return Either.left(resourceTypes);
 968     }
 969
 970     @Override
 971     public <T extends GraphNode> Either<CategoryData, StorageOperationStatus> getNewCategoryData(String name, NodeTypeEnum type, Class<T> clazz) {
 972         if (name != null) {
 973             String categoryUid = UniqueIdBuilder.buildServiceCategoryUid(name, type);
 974             Map props = new HashMap<>();
 975             props.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normalizeCategoryName4Uniqueness(name));
 976             Either<List<T>, JanusGraphOperationStatus> either = janusGraphGenericDao.getByCriteria(type, props, clazz);
 977             if (either.isRight()) {
 978                 JanusGraphOperationStatus janusGraphOperationStatus = either.right().value();
 979                 log.debug("Problem while geting category with id {}. reason - {}", categoryUid, janusGraphOperationStatus.name());
 980                 if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 981                     return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND);
 982                 } else {
 983                     return Either.right(StorageOperationStatus.GENERAL_ERROR);
 984                 }
 985             }
 986             return Either.left((CategoryData) either.left().value().get(0));
 987         } else {
 988             return Either.right(StorageOperationStatus.GENERAL_ERROR);
 989         }
 990     }
 991 }