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

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