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