2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.components.impl;
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.log.wrappers.Logger;
36 import org.openecomp.sdc.common.util.ValidationUtils;
37 import org.openecomp.sdc.exception.ResponseFormat;
38 import org.springframework.stereotype.Component;
39 import org.yaml.snakeyaml.Yaml;
41 import java.util.ArrayList;
42 import java.util.HashMap;
43 import java.util.Iterator;
44 import java.util.List;
46 import java.util.Map.Entry;
48 @Component("categoriesImportManager")
49 public class CategoriesImportManager {
51 @javax.annotation.Resource
52 private IElementOperation elementOperation;
54 @javax.annotation.Resource
55 private ComponentsUtils componentsUtils;
57 private static final Logger log = Logger.getLogger(CategoriesImportManager.class.getName());
59 public Either<Map<String, List<CategoryDefinition>>, ResponseFormat> createCategories(String categoriesTypesYml) {
61 Map<String, List<CategoryDefinition>> allCategories = createCategoriesFromYml(categoriesTypesYml);
62 return createCategoriesByDao(allCategories);
65 private Either<Map<String, List<CategoryDefinition>>, ResponseFormat> createCategoriesByDao(Map<String, List<CategoryDefinition>> allCategories) {
66 Map<String, List<CategoryDefinition>> result = new HashMap<>();
67 log.debug("createCategoriesByDao: starting to create Categories.");
68 for (Map.Entry<String, List<CategoryDefinition>> entry : allCategories.entrySet()) {
69 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(entry.getKey());
70 NodeTypeEnum nodeTypeCategory = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.CATEGORY);
71 NodeTypeEnum nodeTypeSubCategory = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.SUBCATEGORY);
72 NodeTypeEnum nodeTypeGroup = NodeTypeConvertUtils.getCategoryNodeTypeByComponentParam(componentType, CategoryTypeEnum.GROUPING);
73 log.debug("createCategoriesByDao: creating componentType:{} nodeTypeCategory:{} nodeTypeSubCategory:{} nodeTypeGroup:{}", componentType, nodeTypeCategory, nodeTypeSubCategory, nodeTypeGroup);
74 List<CategoryDefinition> newCategoriesvalue = new ArrayList<>();
75 for (CategoryDefinition category : entry.getValue()) {
77 Either<CategoryDefinition, ResponseFormat> createdCategoryRes = createCategorieDeo(entry, category, nodeTypeCategory);
78 if (createdCategoryRes.isRight()) {
79 return Either.right(createdCategoryRes.right().value());
82 CategoryDefinition newcategory = createdCategoryRes.left().value();
83 log.debug("createCategoriesByDao: create category was successful {}", newcategory);
84 List<SubCategoryDefinition> newsubcategories = new ArrayList<>();
85 List<SubCategoryDefinition> subcategories = category.getSubcategories();
86 if (subcategories != null) {
87 boolean createdNewSubCategory = isCreatedNewSubCategory(entry, nodeTypeSubCategory, nodeTypeGroup, category, newcategory, newsubcategories, subcategories);
88 if (!createdNewSubCategory) {
89 return Either.right(createdCategoryRes.right().value());
91 newcategory.setSubcategories(newsubcategories);
93 newCategoriesvalue.add(newcategory);
95 result.put(entry.getKey(), newCategoriesvalue);
97 return Either.left(result);
100 private boolean isCreatedNewSubCategory(Entry<String, List<CategoryDefinition>> entry, NodeTypeEnum nodeTypeSubCategory, NodeTypeEnum nodeTypeGroup, CategoryDefinition category, CategoryDefinition newcategory, List<SubCategoryDefinition> newsubcategories, List<SubCategoryDefinition> subcategories) {
101 for (SubCategoryDefinition subcategory : subcategories) {
102 Either<SubCategoryDefinition, ResponseFormat> createdSubCategory = createSubCategorieDeo(entry, newcategory, subcategory, nodeTypeSubCategory);
103 if (createdSubCategory.isRight()) {
106 SubCategoryDefinition newsubcategory = createdSubCategory.left().value();
107 List<GroupingDefinition> groupings = subcategory.getGroupings();
108 if (groupings != null) {
109 List<GroupingDefinition> newgroupings = new ArrayList<>();
110 for (GroupingDefinition grouping : groupings) {
111 Either<GroupingDefinition, ResponseFormat> createdGrouping = createGroupingDeo(entry, grouping, subcategory, category, nodeTypeGroup);
112 if (createdGrouping.isRight()) {
115 newgroupings.add(createdGrouping.left().value());
117 newsubcategory.setGroupings(newgroupings);
119 newsubcategories.add(newsubcategory);
124 private Either<GroupingDefinition, ResponseFormat> createGroupingDeo(Map.Entry<String, List<CategoryDefinition>> entry, GroupingDefinition grouping, SubCategoryDefinition subcategory, CategoryDefinition category, NodeTypeEnum nodeTypeGroup) {
126 log.debug("createGroupingDeo: creating grouping {}", grouping);
127 Either<GroupingDefinition, ActionStatus> createdGrouping = elementOperation.createGrouping(subcategory.getUniqueId(), grouping, nodeTypeGroup);
128 if (createdGrouping.isRight()) {
129 if (ActionStatus.COMPONENT_GROUPING_EXISTS_FOR_SUB_CATEGORY == createdGrouping.right().value()) {
130 log.debug(" create grouping for {} group {} already exists ", entry.getKey(), grouping.getName());
131 String groupingId = UniqueIdBuilder.buildGroupingUid(grouping.getUniqueId(), grouping.getNormalizedName());
132 createdGrouping = elementOperation.getGroupingUniqueForType(nodeTypeGroup, groupingId);
133 if (createdGrouping.isRight()) {
134 log.debug("failed to get grouping that exists groupingId: {} type: {}", groupingId, nodeTypeGroup);
135 return Either.right(componentsUtils.getResponseFormat(createdGrouping.right().value()));
138 log.debug("Failed to create groupingcategory for {} category {} subcategory {} grouping {} error {}", entry.getKey(),
139 category.getName(), subcategory.getName(), grouping != null ? grouping.getName() : null,
140 createdGrouping != null && createdGrouping.right() != null ? createdGrouping.right().value() : null);
142 return Either.right(componentsUtils.getResponseFormat(createdGrouping.right().value()));
144 log.debug("createGroupingDeo: create Grouping was successful {}", createdGrouping.left().value());
146 return Either.left(createdGrouping.left().value());
150 private Either<SubCategoryDefinition, ResponseFormat> createSubCategorieDeo(Map.Entry<String, List<CategoryDefinition>> entry, CategoryDefinition newcategory, SubCategoryDefinition subcategory, NodeTypeEnum nodeTypeSubCategory) {
151 log.debug("createSubCategorieDeo: creating subcategory {}", subcategory);
152 Either<SubCategoryDefinition, ActionStatus> createdSubCategory = elementOperation.createSubCategory(newcategory.getUniqueId(), subcategory, nodeTypeSubCategory);
153 if (createdSubCategory.isRight()) {
154 if (ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY == createdSubCategory.right().value()) {
155 log.debug(" create subcategory for {} category {} subcategory {} already exists retrieving", entry.getKey(), newcategory.getName(), subcategory.getName());
156 String subCategoryId = UniqueIdBuilder.buildSubCategoryUid(newcategory.getUniqueId(), subcategory.getNormalizedName());
157 createdSubCategory = elementOperation.getSubCategory(nodeTypeSubCategory, subCategoryId);
158 if (createdSubCategory.isRight()) {
159 log.debug("failed to get sub category that exists subCategoryId: {} type: {}", subCategoryId, nodeTypeSubCategory);
160 return Either.right(componentsUtils.getResponseFormat(createdSubCategory.right().value()));
163 log.debug("Failed to create subcategory for {} category: {} subcategory: {} error {}", entry.getKey(), newcategory.getName(), subcategory.getName(), createdSubCategory.right().value());
164 return Either.right(componentsUtils.getResponseFormat(createdSubCategory.right().value()));
167 log.debug("createSubCategorieDeo: create subcategory was successful {}", createdSubCategory.left().value());
169 return Either.left(createdSubCategory.left().value());
172 private Either<CategoryDefinition, ResponseFormat> createCategorieDeo(Map.Entry<String, List<CategoryDefinition>> entry, CategoryDefinition category, NodeTypeEnum nodeTypeCategory) {
173 log.debug("createCategorieDeo: creating category {}", category);
174 Either<CategoryDefinition, ActionStatus> createdCategory = elementOperation.createCategory(category, nodeTypeCategory);
175 if (createdCategory.isRight()) {
176 log.debug("Failed to create category for {} {} error {}", entry.getKey(), category.getName(), createdCategory.right().value());
177 if (ActionStatus.COMPONENT_CATEGORY_ALREADY_EXISTS != createdCategory.right().value()) {
178 return Either.right(componentsUtils.getResponseFormat(createdCategory.right().value()));
180 log.debug("createCategorieDeo: category exists {} retriving.", category);
181 String categoryId = UniqueIdBuilder.buildCategoryUid(category.getNormalizedName(), nodeTypeCategory);
182 createdCategory = elementOperation.getCategory(nodeTypeCategory, categoryId);
183 if (createdCategory.isRight()) {
184 log.debug("failed to get category that exists categoryId: {} type: {}", categoryId, nodeTypeCategory);
185 return Either.right(componentsUtils.getResponseFormat(createdCategory.right().value()));
189 log.debug("createCategorieDeo: create category was successful {}", createdCategory.left().value());
191 return Either.left(createdCategory.left().value());
194 private Map<String, List<CategoryDefinition>> createCategoriesFromYml(String categoriesTypesYml) {
195 Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(categoriesTypesYml);
196 Map<String, List<CategoryDefinition>> allCategories = new HashMap<>();
198 Iterator<Entry<String, Object>> categoryEntryItr = toscaJson.entrySet().iterator();
199 while (categoryEntryItr.hasNext()) {
200 Entry<String, Object> categoryTypeEntry = categoryEntryItr.next();
201 String categoryType = categoryTypeEntry.getKey();
202 List<CategoryDefinition> categoriesPerType = null;
203 Map<String, Object> categoryPerType = null;
204 switch (categoryType) {
205 case ComponentTypeEnum.SERVICE_PARAM_NAME:
206 categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
207 categoriesPerType = createServiceCategories(categoryPerType);
209 case ComponentTypeEnum.RESOURCE_PARAM_NAME:
210 categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
211 categoriesPerType = createResourceCategories(categoryPerType);
213 case ComponentTypeEnum.PRODUCT_PARAM_NAME:
217 log.debug("Not supported category type - {}", categoryType);
220 if (categoriesPerType != null) {
221 allCategories.put(categoryType, categoriesPerType);
224 return allCategories;
227 private List<CategoryDefinition> createServiceCategories(Map<String, Object> categories) {
228 List<CategoryDefinition> categroiesDef = new ArrayList<>();
229 String catName = null;
230 List<String> icons = null;
231 for (Entry<String, Object> entry : categories.entrySet()) {
232 CategoryDefinition catDef = new CategoryDefinition();
233 Map<String, Object> category = (Map<String, Object>) entry.getValue();
234 catName = (String) category.get("name");
235 catDef.setName(catName);
236 icons = (List<String>) category.get("icons");
237 catDef.setIcons(icons);
238 String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
239 catDef.setNormalizedName(normalizedName);
240 categroiesDef.add(catDef);
243 return categroiesDef;
246 private List<CategoryDefinition> createResourceCategories(Map<String, Object> categoryPerType) {
247 List<CategoryDefinition> categroiesDef = new ArrayList<>();
248 for (Map.Entry<String, Object> entry : categoryPerType.entrySet()) {
249 Map<String, Object> category = (Map<String, Object>) entry.getValue();
250 CategoryDefinition catDef = new CategoryDefinition();
251 String catName = (String) category.get("name");
252 catDef.setName(catName);
253 String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
254 catDef.setNormalizedName(normalizedName);
255 Map<String, Object> subcategories = (Map<String, Object>) category.get("subcategories");
256 List<SubCategoryDefinition> subcateDef = new ArrayList<>();
257 for (Entry<String, Object> subcategory : subcategories.entrySet()) {
258 Map<String, Object> subcategoryInfo = (Map<String, Object>) subcategory.getValue();
259 SubCategoryDefinition subDef = new SubCategoryDefinition();
260 String subcategoryName = (String) subcategoryInfo.get("name");
261 subDef.setName(subcategoryName);
262 List<String> subcategoryIcons = (List<String>) subcategoryInfo.get("icons");
263 subDef.setIcons(subcategoryIcons);
264 normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(subcategoryName);
265 subDef.setNormalizedName(normalizedName);
266 subcateDef.add(subDef);
269 catDef.setSubcategories(subcateDef);
270 categroiesDef.add(catDef);
272 return categroiesDef;