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