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