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