catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/CategoriesImportManager.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.components.impl;
  22
  23 import fj.data.Either;
  24 import org.openecomp.sdc.be.dao.api.ActionStatus;
  25 import org.openecomp.sdc.be.datamodel.api.CategoryTypeEnum;
  26 import org.openecomp.sdc.be.datamodel.utils.NodeTypeConvertUtils;
  27 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  28 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  29 import org.openecomp.sdc.be.impl.ComponentsUtils;
  30 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  31 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  32 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  33 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  34 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  35 import org.openecomp.sdc.common.util.ValidationUtils;
  36 import org.openecomp.sdc.exception.ResponseFormat;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39 import org.springframework.stereotype.Component;
  40 import org.yaml.snakeyaml.Yaml;
  41
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.Iterator;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Map.Entry;
  48
  49 @Component("categoriesImportManager")
  50 public class CategoriesImportManager {
  51
  52     @javax.annotation.Resource
  53     private IElementOperation elementOperation;
  54
  55     @javax.annotation.Resource
  56     private ComponentsUtils componentsUtils;
  57
  58     private static final Logger log = LoggerFactory.getLogger(CategoriesImportManager.class);
  59
  60     public Either<Map<String, List<CategoryDefinition>>, ResponseFormat> createCategories(String categoriesTypesYml) {
  61
  62         Map<String, List<CategoryDefinition>> allCategories = createCategoriesFromYml(categoriesTypesYml);
  63         return createCategoriesByDao(allCategories);
  64     }
  65
  66     private Either<Map<String, List<CategoryDefinition>>, ResponseFormat> createCategoriesByDao(Map<String, List<CategoryDefinition>> allCategories) {
  67         Map<String, List<CategoryDefinition>> result = new HashMap<>();
  68         log.debug("createCategoriesByDao: starting to create Categories.");
  69         for (Map.Entry<String, List<CategoryDefinition>> entry : allCategories.entrySet()) {
  70             ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(entry.getKey());
  71             NodeTypeEnum nodeTypeCategory = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.CATEGORY);
  72             NodeTypeEnum nodeTypeSubCategory = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.SUBCATEGORY);
  73             NodeTypeEnum nodeTypeGroup = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.GROUPING);
  74             log.debug("createCategoriesByDao: creating componentType:{}  nodeTypeCategory:{} nodeTypeSubCategory:{} nodeTypeGroup:{}", componentType, nodeTypeCategory, nodeTypeSubCategory, nodeTypeGroup);
  75             List<CategoryDefinition> newCategoriesvalue = new ArrayList<>();
  76             for (CategoryDefinition category : entry.getValue()) {
  77
  78                 Either<CategoryDefinition, ResponseFormat> createdCategoryRes = createCategorieDeo(entry, category, nodeTypeCategory);
  79                 if (createdCategoryRes.isRight()) {
  80                     return Either.right(createdCategoryRes.right().value());
  81                 }
  82
  83                 CategoryDefinition newcategory = createdCategoryRes.left().value();
  84                 log.debug("createCategoriesByDao: create category was successful {}", newcategory);
  85                 List<SubCategoryDefinition> newsubcategories = new ArrayList<>();
  86                 List<SubCategoryDefinition> subcategories = category.getSubcategories();
  87                 if (subcategories != null) {
  88                     for (SubCategoryDefinition subcategory : subcategories) {
  89                         Either<SubCategoryDefinition, ResponseFormat> createdSubCategory = createSubCategorieDeo(entry, newcategory, subcategory, nodeTypeSubCategory);
  90                         if (createdSubCategory.isRight()) {
  91                             return Either.right(createdCategoryRes.right().value());
  92                         }
  93                         SubCategoryDefinition newsubcategory = createdSubCategory.left().value();
  94                         List<GroupingDefinition> groupings = subcategory.getGroupings();
  95                         if (groupings != null) {
  96                             List<GroupingDefinition> newgroupings = new ArrayList<>();
  97                             for (GroupingDefinition grouping : groupings) {
  98                                 Either<GroupingDefinition, ResponseFormat> createdGrouping = createGroupingDeo(entry, grouping, subcategory, category, nodeTypeGroup);
  99                                 if (createdGrouping.isRight()) {
 100                                     return Either.right(createdCategoryRes.right().value());
 101                                 }
 102                                 newgroupings.add(createdGrouping.left().value());
 103                             }
 104                             newsubcategory.setGroupings(newgroupings);
 105                         }
 106                         newsubcategories.add(newsubcategory);
 107                     }
 108                     newcategory.setSubcategories(newsubcategories);
 109                 }
 110                 newCategoriesvalue.add(newcategory);
 111             }
 112             result.put(entry.getKey(), newCategoriesvalue);
 113         }
 114         return Either.left(result);
 115     }
 116
 117     private Either<GroupingDefinition, ResponseFormat> createGroupingDeo(Map.Entry<String, List<CategoryDefinition>> entry, GroupingDefinition grouping, SubCategoryDefinition subcategory, CategoryDefinition category, NodeTypeEnum nodeTypeGroup) {
 118
 119         log.debug("createGroupingDeo: creating grouping  {}", grouping);
 120         Either<GroupingDefinition, ActionStatus> createdGrouping = elementOperation.createGrouping(subcategory.getUniqueId(), grouping, nodeTypeGroup);
 121         if (createdGrouping.isRight()) {
 122             if (ActionStatus.COMPONENT_GROUPING_EXISTS_FOR_SUB_CATEGORY.equals(createdGrouping.right().value())) {
 123                 log.debug(" create grouping for {}  group {} already exists ", entry.getKey(), grouping.getName());
 124                 String groupingId = UniqueIdBuilder.buildGroupingUid(grouping.getUniqueId(), grouping.getNormalizedName());
 125                 createdGrouping = elementOperation.getGroupingUniqueForType(nodeTypeGroup, groupingId);
 126                 if (createdGrouping.isRight()) {
 127                     log.debug("failed to get grouping that exists groupingId: {} type: {}", groupingId, nodeTypeGroup);
 128                     return Either.right(componentsUtils.getResponseFormat(createdGrouping.right().value()));
 129                 }
 130             }
 131             log.debug("Failed to create groupingcategory for {}  category {} subcategory {} grouping {} error {}", entry.getKey(),
 132                     category.getName(), subcategory.getName(), grouping != null ? grouping.getName() : null,
 133                             createdGrouping != null && createdGrouping.right() != null ? createdGrouping.right().value() : null);
 134
 135             return Either.right(componentsUtils.getResponseFormat(createdGrouping.right().value()));
 136         } else {
 137             log.debug("createGroupingDeo: create Grouping was successful {}", createdGrouping.left().value());
 138         }
 139         return Either.left(createdGrouping.left().value());
 140
 141     }
 142
 143     private Either<SubCategoryDefinition, ResponseFormat> createSubCategorieDeo(Map.Entry<String, List<CategoryDefinition>> entry, CategoryDefinition newcategory, SubCategoryDefinition subcategory, NodeTypeEnum nodeTypeSubCategory) {
 144         log.debug("createSubCategorieDeo: creating subcategory  {}", subcategory);
 145         Either<SubCategoryDefinition, ActionStatus> createdSubCategory = elementOperation.createSubCategory(newcategory.getUniqueId(), subcategory, nodeTypeSubCategory);
 146         if (createdSubCategory.isRight()) {
 147             if (ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY.equals(createdSubCategory.right().value())) {
 148                 log.debug(" create subcategory for {}  category {} subcategory {} already exists retrieving", entry.getKey(), newcategory.getName(), subcategory.getName());
 149                 String subCategoryId = UniqueIdBuilder.buildSubCategoryUid(newcategory.getUniqueId(), subcategory.getNormalizedName());
 150                 createdSubCategory = elementOperation.getSubCategory(nodeTypeSubCategory, subCategoryId);
 151                 if (createdSubCategory.isRight()) {
 152                     log.debug("failed to get sub category that exists subCategoryId: {} type: {}", subCategoryId, nodeTypeSubCategory);
 153                     return Either.right(componentsUtils.getResponseFormat(createdSubCategory.right().value()));
 154                 }
 155             } else {
 156                 log.debug("Failed to create subcategory for {}  category: {} subcategory: {} error {}", entry.getKey(), newcategory.getName(), subcategory.getName(), createdSubCategory.right().value());
 157                 return Either.right(componentsUtils.getResponseFormat(createdSubCategory.right().value()));
 158             }
 159         } else {
 160             log.debug("createSubCategorieDeo: create subcategory was successful {}", createdSubCategory.left().value());
 161         }
 162         return Either.left(createdSubCategory.left().value());
 163     }
 164
 165     private Either<CategoryDefinition, ResponseFormat> createCategorieDeo(Map.Entry<String, List<CategoryDefinition>> entry, CategoryDefinition category, NodeTypeEnum nodeTypeCategory) {
 166         log.debug("createCategorieDeo: creating category {}", category);
 167         Either<CategoryDefinition, ActionStatus> createdCategory = elementOperation.createCategory(category, nodeTypeCategory);
 168         if (createdCategory.isRight()) {
 169             log.debug("Failed to create category for {}  {} error {}", entry.getKey(), category.getName(), createdCategory.right().value());
 170             if (!ActionStatus.COMPONENT_CATEGORY_ALREADY_EXISTS.equals(createdCategory.right().value())) {
 171                 return Either.right(componentsUtils.getResponseFormat(createdCategory.right().value()));
 172             } else {
 173                 log.debug("createCategorieDeo: category exists {} retriving.", category);
 174                 String categoryId = UniqueIdBuilder.buildCategoryUid(category.getNormalizedName(), nodeTypeCategory);
 175                 createdCategory = elementOperation.getCategory(nodeTypeCategory, categoryId);
 176                 if (createdCategory.isRight()) {
 177                     log.debug("failed to get category that exists categoryId: {} type: {}", categoryId, nodeTypeCategory);
 178                     return Either.right(componentsUtils.getResponseFormat(createdCategory.right().value()));
 179                 }
 180             }
 181         } else {
 182             log.debug("createCategorieDeo: create category was successful {}", createdCategory.left().value());
 183         }
 184         return Either.left(createdCategory.left().value());
 185     }
 186
 187     private Map<String, List<CategoryDefinition>> createCategoriesFromYml(String categoriesTypesYml) {
 188         Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(categoriesTypesYml);
 189         Map<String, List<CategoryDefinition>> allCategories = new HashMap<>();
 190
 191         Iterator<Entry<String, Object>> categoryEntryItr = toscaJson.entrySet().iterator();
 192         while (categoryEntryItr.hasNext()) {
 193             Entry<String, Object> categoryTypeEntry = categoryEntryItr.next();
 194             String categoryType = categoryTypeEntry.getKey();
 195             List<CategoryDefinition> categoriesPerType = null;
 196             Map<String, Object> categoryPerType = null;
 197             switch (categoryType) {
 198             case ComponentTypeEnum.SERVICE_PARAM_NAME:
 199                 categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
 200                 categoriesPerType = createServiceCategories(categoryPerType);
 201                 break;
 202             case ComponentTypeEnum.RESOURCE_PARAM_NAME:
 203                 categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
 204                 categoriesPerType = createResourceCategories(categoryPerType);
 205                 break;
 206             case ComponentTypeEnum.PRODUCT_PARAM_NAME:
 207                 // TODO
 208                 break;
 209             default:
 210                 log.debug("Not supported category type - {}", categoryType);
 211                 break;
 212             }
 213             if (categoriesPerType != null) {
 214                 allCategories.put(categoryType, categoriesPerType);
 215             }
 216         }
 217         return allCategories;
 218     }
 219
 220     private List<CategoryDefinition> createServiceCategories(Map<String, Object> categories) {
 221         List<CategoryDefinition> categroiesDef = new ArrayList<>();
 222         String catName = null;
 223         List<String> icons = null;
 224         for (Entry<String, Object> entry : categories.entrySet()) {
 225             CategoryDefinition catDef = new CategoryDefinition();
 226             Map<String, Object> category = (Map<String, Object>) entry.getValue();
 227             catName = (String) category.get("name");
 228             catDef.setName(catName);
 229             icons = (List<String>) category.get("icons");
 230             catDef.setIcons(icons);
 231             String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
 232             catDef.setNormalizedName(normalizedName);
 233             categroiesDef.add(catDef);
 234         }
 235
 236         return categroiesDef;
 237     }
 238
 239     private List<CategoryDefinition> createResourceCategories(Map<String, Object> categoryPerType) {
 240         List<CategoryDefinition> categroiesDef = new ArrayList<>();
 241         for (Map.Entry<String, Object> entry : categoryPerType.entrySet()) {
 242             Map<String, Object> category = (Map<String, Object>) entry.getValue();
 243             CategoryDefinition catDef = new CategoryDefinition();
 244             String catName = (String) category.get("name");
 245             catDef.setName(catName);
 246             String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
 247             catDef.setNormalizedName(normalizedName);
 248             Map<String, Object> subcategories = (Map<String, Object>) category.get("subcategories");
 249             List<SubCategoryDefinition> subcateDef = new ArrayList<>();
 250             for (Entry<String, Object> subcategory : subcategories.entrySet()) {
 251                 Map<String, Object> subcategoryInfo = (Map<String, Object>) subcategory.getValue();
 252                 SubCategoryDefinition subDef = new SubCategoryDefinition();
 253                 String subcategoryName = (String) subcategoryInfo.get("name");
 254                 subDef.setName(subcategoryName);
 255                 List<String> subcategoryIcons = (List<String>) subcategoryInfo.get("icons");
 256                 subDef.setIcons(subcategoryIcons);
 257                 normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(subcategoryName);
 258                 subDef.setNormalizedName(normalizedName);
 259                 subcateDef.add(subDef);
 260             }
 261
 262             catDef.setSubcategories(subcateDef);
 263             categroiesDef.add(catDef);
 264         }
 265         return categroiesDef;
 266     }
 267 }