1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
package org.openecomp.sdc.be.components.property;
import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.jsontitan.operations.PolicyOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import fj.data.Either;
@org.springframework.stereotype.Component
public class PolicyPropertyDecelerator extends DefaultPropertyDecelerator<PolicyDefinition, PropertyDataDefinition> {
private static final Logger log = LoggerFactory.getLogger(PolicyPropertyDecelerator.class);
private PolicyOperation policyOperation;
public PolicyPropertyDecelerator(ComponentsUtils componentsUtils, PropertyOperation propertyOperation, PolicyOperation policyOperation) {
super(componentsUtils, propertyOperation);
this.policyOperation = policyOperation;
}
@Override
PropertyDataDefinition createDeclaredProperty(PropertyDataDefinition prop) {
return new PropertyDataDefinition(prop);
}
@Override
Either<?, StorageOperationStatus> updatePropertiesValues(Component component, String policyId, List<PropertyDataDefinition> properties) {
log.debug("#updatePropertiesValues - updating policies properties for policy {} on component {}", policyId, component.getUniqueId());
StorageOperationStatus updateStatus = policyOperation.updatePolicyProperties(component, policyId, properties);
return updateStatus == StorageOperationStatus.OK ? Either.left(updateStatus) : Either.right(updateStatus);
}
@Override
Optional<PolicyDefinition> resolvePropertiesOwner(Component component, String policyId) {
log.debug("#resolvePropertiesOwner - fetching policy {} of component {}", policyId, component.getUniqueId());
return Optional.ofNullable(component.getPolicyById(policyId));
}
@Override
void addPropertiesListToInput(PropertyDataDefinition declaredProp, PropertyDataDefinition originalProp, InputDefinition input) {
List<ComponentInstanceProperty> propertiesList = input.getProperties();
if(propertiesList == null) {
propertiesList = new ArrayList<>(); // adding the property with the new value for UI
}
propertiesList.add(new ComponentInstanceProperty(declaredProp));
input.setProperties(propertiesList);
}
@Override
public StorageOperationStatus unDeclarePropertiesAsInputs(Component component, InputDefinition inputForDelete) {
return getPolicyPropertiesDeclaredAsInput(component, inputForDelete.getUniqueId())
.map(policyProperties -> unDeclarePolicyProperties(component, inputForDelete, policyProperties))
.orElse(StorageOperationStatus.OK);
}
private StorageOperationStatus unDeclarePolicyProperties(Component container, InputDefinition input, PolicyProperties policyProperties) {
String policyId = policyProperties.getPolicyId();
List<PropertyDataDefinition> propsDeclaredAsInput = policyProperties.getProperties();
propsDeclaredAsInput.forEach(policyProp -> prepareValueBeforeDelete(input, policyProp, Collections.emptyList()));
return policyOperation.updatePolicyProperties(container, policyId, propsDeclaredAsInput);
}
private Optional<PolicyProperties> getPolicyPropertiesDeclaredAsInput(Component container, String inputId) {
if (container.getPolicies() == null) {
return Optional.empty();
}
return container.getPolicies().values()
.stream()
.filter(policy -> Objects.nonNull(policy.getProperties()))
.collect(Collectors.toMap(PolicyDataDefinition::getUniqueId,
p -> getPolicyPropertiesDeclaredAsInput(p, inputId)))
.entrySet()
.stream()
.filter(entry -> !entry.getValue().isEmpty())
.map(entry -> new PolicyProperties(entry.getKey(), entry.getValue()))
.findFirst();
}
private boolean isPropertyDeclaredAsInputByInputId(PropertyDataDefinition property, String inputId) {
if (CollectionUtils.isEmpty(property.getGetInputValues())) {
return false;
}
return property.getGetInputValues().stream()
.filter(Objects::nonNull)
.anyMatch(getInputVal -> isGetInputValueForInput(getInputVal, inputId));
}
private List<PropertyDataDefinition> getPolicyPropertiesDeclaredAsInput(PolicyDefinition policy, String inputId) {
return policy.getProperties()
.stream()
.filter(prop -> isPropertyDeclaredAsInputByInputId(prop, inputId))
.collect(Collectors.toList());
}
private class PolicyProperties {
private String policyId;
private List<PropertyDataDefinition> properties;
PolicyProperties(String policyId, List<PropertyDataDefinition> properties) {
this.policyId = policyId;
this.properties = properties;
}
String getPolicyId() {
return policyId;
}
public List<PropertyDataDefinition> getProperties() {
return properties;
}
}
}
|
