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=========================================================
20 package org.openecomp.sdc.be.datamodel.utils;
22 import static java.util.stream.Collectors.groupingBy;
23 import static java.util.stream.Collectors.toList;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.List;
33 import java.util.stream.Collectors;
34 import org.apache.commons.collections.CollectionUtils;
35 import org.apache.commons.collections.MapUtils;
36 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
37 import org.openecomp.sdc.be.components.impl.PolicyTypeBusinessLogic;
38 import org.openecomp.sdc.be.components.validation.PolicyUtils;
39 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
40 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
41 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
42 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
43 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
44 import org.openecomp.sdc.be.model.CapabilityDefinition;
45 import org.openecomp.sdc.be.model.Component;
46 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
47 import org.openecomp.sdc.be.model.GroupDefinition;
48 import org.openecomp.sdc.be.model.PolicyDefinition;
49 import org.openecomp.sdc.be.model.Resource;
50 import org.openecomp.sdc.be.model.Service;
51 import org.openecomp.sdc.be.tosca.utils.NodeFilterConverter;
52 import org.openecomp.sdc.be.tosca.utils.SubstitutionFilterConverter;
53 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
54 import org.openecomp.sdc.be.ui.model.UiComponentMetadata;
55 import org.openecomp.sdc.be.ui.model.UiResourceDataTransfer;
56 import org.openecomp.sdc.be.ui.model.UiResourceMetadata;
57 import org.openecomp.sdc.be.ui.model.UiServiceDataTransfer;
58 import org.openecomp.sdc.be.ui.model.UiServiceMetadata;
59 import org.openecomp.sdc.common.log.wrappers.Logger;
61 @org.springframework.stereotype.Component("uiComponentDataConverter")
62 public class UiComponentDataConverter {
64 public static final String INVALID_INPUT_GIVEN_TO_DATA_CONVERTER = "Invalid input given to data converter: {}";
65 private static final Logger log = Logger.getLogger(UiComponentDataConverter.class);
66 private final GroupTypeBusinessLogic groupTypeBusinessLogic;
67 private final PolicyTypeBusinessLogic policyTypeBusinessLogic;
69 public UiComponentDataConverter(GroupTypeBusinessLogic groupTypeBusinessLogic, PolicyTypeBusinessLogic policyTypeBusinessLogic) {
70 this.groupTypeBusinessLogic = groupTypeBusinessLogic;
71 this.policyTypeBusinessLogic = policyTypeBusinessLogic;
74 public static UiComponentMetadata convertToUiComponentMetadata(Component component) {
75 UiComponentMetadata uiComponentMetadata = null;
76 switch (component.getComponentType()) {
78 Resource resource = (Resource) component;
79 uiComponentMetadata = new UiResourceMetadata(component.getCategories(), resource.getDerivedFrom(),
80 (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
83 uiComponentMetadata = new UiServiceMetadata(component.getCategories(),
84 (ServiceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition());
89 return uiComponentMetadata;
92 private void setUiTranferDataByFieldName(UiComponentDataTransfer dataTransfer, Component component, String fieldName) {
93 ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
95 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
100 setInputs(dataTransfer, component);
103 setOutputs(dataTransfer, component);
105 case COMPONENT_INSTANCE_RELATION:
106 setComponentInstanceRelation(dataTransfer, component);
109 setGroups(dataTransfer, component);
111 case NON_EXCLUDED_GROUPS:
112 setNonExcludedGroups(dataTransfer, component);
114 case COMPONENT_INSTANCES:
115 setComponentInstances(dataTransfer, component);
117 case COMPONENT_INSTANCES_PROPERTIES:
118 setComponentInstanceProperties(dataTransfer, component);
121 setCapabilities(dataTransfer, component);
124 setPolicies(dataTransfer, component);
126 case NON_EXCLUDED_POLICIES:
127 setNonExcludedPolicies(dataTransfer, component);
130 setRequirements(dataTransfer, component);
132 case DEPLOYMENT_ARTIFACTS:
133 setDeploymentArtifacts(dataTransfer, component);
135 case TOSCA_ARTIFACTS:
136 setToscaArtifacts(dataTransfer, component);
139 setArtifacts(dataTransfer, component);
141 case COMPONENT_INSTANCES_ATTRIBUTES:
142 setComponentInstanceAttributes(dataTransfer, component);
144 case COMPONENT_INSTANCE_INPUTS:
145 setComponentInstanceInputs(dataTransfer, component);
148 setNodeFilter(dataTransfer, component);
150 case SUBSTITUTION_FILTER:
151 setSubstitutionFilter(dataTransfer, component);
153 case COMPONENT_INSTANCES_INTERFACES:
154 setComponentInstanceInterfaces(dataTransfer, component);
157 setProperties(dataTransfer, component);
160 setAttributes(dataTransfer, component);
163 setInterfaces(dataTransfer, component);
170 private void setNodeFilter(UiComponentDataTransfer dataTransfer, Component component) {
171 if (component.getNodeFilterComponents() == null) {
172 dataTransfer.setNodeFilter(null);
174 dataTransfer.setNodeFilter(component.getNodeFilterComponents());
178 private void setSubstitutionFilter(final UiComponentDataTransfer dataTransfer, final Component component) {
179 if (component.getSubstitutionFilter() == null) {
180 dataTransfer.setSubstitutionFilters(null);
182 final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
183 dataTransfer.setSubstitutionFilters(substitutionFilterConverter.convertToUi(component.getSubstitutionFilter()));
187 private void setPolicies(UiComponentDataTransfer dataTransfer, Component component) {
188 Map<String, PolicyDefinition> policies = component.getPolicies();
189 Set<PolicyDefinition> policyDefinitions = MapUtils.isEmpty(policies) ? new HashSet<>() : new HashSet<>(policies.values());
190 policyDefinitions.addAll(getDeclaredPolicies(component.getComponentInstancesProperties()));
191 dataTransfer.setPolicies(new ArrayList<>(policyDefinitions));
194 private Set<PolicyDefinition> getDeclaredPolicies(Map<String, List<ComponentInstanceProperty>> componentInstanceProperties) {
195 if (MapUtils.isEmpty(componentInstanceProperties)) {
196 return new HashSet<>();
198 Set<PolicyDefinition> declaredPolicies = new HashSet<>();
199 for (Map.Entry<String, List<ComponentInstanceProperty>> instancePropertyEntry : componentInstanceProperties.entrySet()) {
200 declaredPolicies.addAll(
201 instancePropertyEntry.getValue().stream().filter(property -> CollectionUtils.isNotEmpty(property.getGetPolicyValues()))
202 .map(instanceProperty -> PolicyUtils.getDeclaredPolicyDefinition(instancePropertyEntry.getKey(), instanceProperty))
203 .collect(Collectors.toSet()));
205 return declaredPolicies;
208 private void setComponentInstanceRelation(UiComponentDataTransfer dataTransfer, Component component) {
209 if (component.getComponentInstancesRelations() == null) {
210 dataTransfer.setComponentInstancesRelations(new ArrayList<>());
212 dataTransfer.setComponentInstancesRelations(component.getComponentInstancesRelations());
216 private void setInputs(UiComponentDataTransfer dataTransfer, Component component) {
217 if (component.getInputs() == null) {
218 dataTransfer.setInputs(new ArrayList<>());
220 dataTransfer.setInputs(component.getInputs());
224 private void setOutputs(final UiComponentDataTransfer dataTransfer, final Component component) {
225 dataTransfer.setOutputs(component.getOutputs() == null ? Collections.emptyList() : component.getOutputs());
228 private void setComponentInstanceInputs(UiComponentDataTransfer dataTransfer, Component component) {
229 if (component.getComponentInstancesInputs() == null) {
230 dataTransfer.setComponentInstancesInputs(new HashMap<>());
232 dataTransfer.setComponentInstancesInputs(component.getComponentInstancesInputs());
236 private void setComponentInstanceAttributes(UiComponentDataTransfer dataTransfer, Component component) {
237 if (component.getComponentInstancesAttributes() == null) {
238 dataTransfer.setComponentInstancesAttributes(new HashMap<>());
240 dataTransfer.setComponentInstancesAttributes(component.getComponentInstancesAttributes());
244 private void setArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
245 if (component.getArtifacts() == null) {
246 dataTransfer.setArtifacts(new HashMap<>());
248 dataTransfer.setArtifacts(component.getArtifacts());
252 private void setToscaArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
253 if (component.getToscaArtifacts() == null) {
254 dataTransfer.setToscaArtifacts(new HashMap<>());
256 dataTransfer.setToscaArtifacts(component.getToscaArtifacts());
260 private void setDeploymentArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
261 if (component.getDeploymentArtifacts() == null) {
262 dataTransfer.setDeploymentArtifacts(new HashMap<>());
264 dataTransfer.setDeploymentArtifacts(component.getDeploymentArtifacts());
268 private void setRequirements(UiComponentDataTransfer dataTransfer, Component component) {
269 if (component.getRequirements() == null) {
270 dataTransfer.setRequirements(new HashMap<>());
272 dataTransfer.setRequirements(component.getRequirements());
276 private void setCapabilities(UiComponentDataTransfer dataTransfer, Component component) {
277 if (component.getCapabilities() == null) {
278 dataTransfer.setCapabilities(new HashMap<>());
280 dataTransfer.setCapabilities(getFilteredCapabilities(component));
284 private Map<String, List<CapabilityDefinition>> getFilteredCapabilities(Component component) {
285 if (component.getComponentType() != ComponentTypeEnum.SERVICE) {
286 return component.getCapabilities().values().stream().flatMap(Collection::stream)
287 .filter(c -> c.getOwnerType() != CapabilityDataDefinition.OwnerType.GROUP)
288 .collect(groupingBy(CapabilityDefinition::getType, toList()));
290 return component.getCapabilities();
293 private void setComponentInstanceProperties(UiComponentDataTransfer dataTransfer, Component component) {
294 if (component.getComponentInstancesProperties() == null) {
295 dataTransfer.setComponentInstancesProperties(new HashMap<>());
297 dataTransfer.setComponentInstancesProperties(component.getComponentInstancesProperties());
301 private void setComponentInstances(UiComponentDataTransfer dataTransfer, Component component) {
302 if (component.getComponentInstances() == null) {
303 dataTransfer.setComponentInstances(new ArrayList<>());
305 dataTransfer.setComponentInstances(component.getComponentInstances());
309 private void setGroups(UiComponentDataTransfer dataTransfer, Component component) {
310 if (component.getGroups() == null) {
311 dataTransfer.setGroups(new ArrayList<>());
313 dataTransfer.setGroups(component.getGroups());
317 private void setProperties(UiComponentDataTransfer dataTransfer, Component component) {
318 if (component.getProperties() == null) {
319 dataTransfer.setProperties(new ArrayList<>());
321 dataTransfer.setProperties(component.getProperties());
325 private void setAttributes(final UiComponentDataTransfer dataTransfer, final Component component) {
326 if (component.getAttributes() == null) {
327 dataTransfer.setAttributes(new ArrayList<>());
329 dataTransfer.setAttributes(component.getAttributes());
333 private void setInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
334 if (component.getInterfaces() == null) {
335 dataTransfer.setInterfaces(new HashMap<>());
337 dataTransfer.setInterfaces(component.getInterfaces());
341 private void setComponentInstanceInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
342 if (component.getComponentInstancesInterfaces() == null) {
343 dataTransfer.setComponentInstancesInterfaces(new HashMap<>());
345 dataTransfer.setComponentInstancesInterfaces(component.getComponentInstancesInterfaces());
349 private void setNonExcludedGroups(UiComponentDataTransfer dataTransfer, Component component) {
350 List<GroupDefinition> groups = component.getGroups();
351 if (groups == null) {
352 dataTransfer.setGroups(new ArrayList<>());
354 Set<String> nonExcludedGroupTypes = groupTypeBusinessLogic.getExcludedGroupTypes(component.getActualComponentType());
355 List<GroupDefinition> nonExcludedGroups = groups.stream().filter(gd -> !nonExcludedGroupTypes.contains(gd.getType())).collect(toList());
356 dataTransfer.setGroups(nonExcludedGroups);
360 private void setNonExcludedPolicies(UiComponentDataTransfer dataTransfer, Component component) {
361 List<PolicyDefinition> policyDefinitions = component.resolvePoliciesList();
362 Set<String> nonExcludedPolicyTypes = policyTypeBusinessLogic.getExcludedPolicyTypes(component.getActualComponentType());
363 List<PolicyDefinition> nonExcludedPolicies = policyDefinitions.stream().filter(pd -> !nonExcludedPolicyTypes.contains(pd.getPolicyTypeName()))
365 dataTransfer.setPolicies(nonExcludedPolicies);
368 public UiComponentDataTransfer getUiDataTransferFromResourceByParams(Resource resource, List<String> paramsToReturn) {
369 UiResourceDataTransfer dataTransfer = new UiResourceDataTransfer();
370 for (String fieldName : paramsToReturn) {
371 ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
373 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
378 setDerivedFrom(resource, dataTransfer);
380 case ADDITIONAL_INFORMATION:
381 setAdditionalInfo(resource, dataTransfer);
384 UiResourceMetadata metadata = new UiResourceMetadata(resource.getCategories(), resource.getDerivedFrom(),
385 (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
386 dataTransfer.setMetadata(metadata);
388 case SUBSTITUTION_FILTER:
389 if (resource.getSubstitutionFilter() == null) {
390 dataTransfer.setSubstitutionFilters(null);
392 final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
393 dataTransfer.setSubstitutionFilters(substitutionFilterConverter.convertToUi(resource.getSubstitutionFilter()));
397 if (resource.getNodeFilterComponents() == null) {
398 dataTransfer.setNodeFilterforNode(null);
400 final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
401 dataTransfer.setNodeFilterforNode(nodeFilterConverter.convertDataMapToUI(resource.getNodeFilterComponents()));
405 setUiTranferDataByFieldName(dataTransfer, resource, fieldName);
411 private void setDerivedFrom(Resource resource, UiResourceDataTransfer dataTransfer) {
412 if (resource.getDerivedFrom() == null) {
413 dataTransfer.setDerivedFrom(new ArrayList<>());
415 dataTransfer.setDerivedFrom(resource.getDerivedFrom());
419 private void setAdditionalInfo(Resource resource, UiResourceDataTransfer dataTransfer) {
420 if (resource.getAdditionalInformation() == null) {
421 dataTransfer.setAdditionalInformation(new ArrayList<>());
423 dataTransfer.setAdditionalInformation(resource.getAdditionalInformation());
427 public UiComponentDataTransfer getUiDataTransferFromServiceByParams(Service service, List<String> paramsToReturn) {
428 UiServiceDataTransfer dataTransfer = new UiServiceDataTransfer();
429 for (String fieldName : paramsToReturn) {
430 ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
432 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
436 case SERVICE_API_ARTIFACTS:
437 setServiceApiArtifacts(service, dataTransfer);
439 case FORWARDING_PATHS:
440 setForwardingPaths(service, dataTransfer);
443 UiServiceMetadata metadata = new UiServiceMetadata(service.getCategories(),
444 (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition().getMetadataDataDefinition());
445 dataTransfer.setMetadata(metadata);
446 dataTransfer.setDerivedFromGenericType(service.getDerivedFromGenericType());
447 dataTransfer.setDerivedFromGenericVersion(service.getDerivedFromGenericVersion());
448 dataTransfer.setModel(service.getModel());
451 if (service.getNodeFilterComponents() == null) {
452 dataTransfer.setNodeFilterforNode(null);
454 final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
455 dataTransfer.setNodeFilterforNode(nodeFilterConverter.convertDataMapToUI(service.getNodeFilterComponents()));
458 case SUBSTITUTION_FILTER:
459 if (service.getSubstitutionFilter() == null) {
460 dataTransfer.setSubstitutionFilters(null);
462 final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
463 dataTransfer.setSubstitutionFilters(substitutionFilterConverter.convertToUi(service.getSubstitutionFilter()));
467 setUiTranferDataByFieldName(dataTransfer, service, fieldName);
473 private void setServiceApiArtifacts(Service service, UiServiceDataTransfer dataTransfer) {
474 if (service.getServiceApiArtifacts() == null) {
475 dataTransfer.setServiceApiArtifacts(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
477 dataTransfer.setServiceApiArtifacts(service.getServiceApiArtifacts());
481 private void setForwardingPaths(Service service, UiServiceDataTransfer dataTransfer) {
482 if (service.getForwardingPaths() == null) {
483 dataTransfer.setForwardingPaths(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
485 dataTransfer.setForwardingPaths(service.getForwardingPaths());