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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/*
* Copyright © 2016-2018 European Support Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.openecomp.sdc.be.impl;
import org.javatuples.Pair;
import org.openecomp.sdc.be.components.impl.utils.DirectivesUtils;
import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.ui.model.UIConstraint;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
public class ServiceFilterUtils {
private ServiceFilterUtils() {
}
public static boolean isNodeFilterAffectedByPropertyRemoval(Service service, String ciName, String propertyName) {
return service.getComponentInstances().stream().filter(ci -> ci.getNodeFilter() != null)
.anyMatch(ci -> propertyIsUsedInCI(ci, ciName, propertyName));
}
private static boolean propertyIsUsedInCI(ComponentInstance ci, String ciName, String propertyName) {
final List<String> directives = ci.getDirectives();
if (!directives.contains(DirectivesUtils.SELECTABLE)) {
return false;
}
if (ci.getNodeFilter() == null || ci.getNodeFilter().getProperties() == null
|| ci.getNodeFilter().getProperties().getListToscaDataDefinition() == null) {
return false;
}
return ci.getNodeFilter().getProperties().getListToscaDataDefinition().stream()
.flatMap(prop -> prop.getConstraints().stream()).map(String::new)
.filter(constraint -> new ConstraintConvertor().convert(constraint).getSourceType()
.equals(ConstraintConvertor.PROPERTY_CONSTRAINT))
.anyMatch(constraintStr -> {
UIConstraint uiConstraint = new ConstraintConvertor().convert(constraintStr);
return uiConstraint.getSourceName().equals(ciName) && uiConstraint.getValue().equals(propertyName);
});
}
public static Map<String, CINodeFilterDataDefinition> getRenamedNodesFilter(Service service, String oldName,
String newName) {
return service.getComponentInstances().stream().filter(ci -> isNodeFilterUsingChangedCi(ci, oldName))
.map(ci -> renameOldCiNames(ci, oldName, newName))
.collect(Collectors.toMap(Pair::getValue0, Pair::getValue1));
}
private static Pair<String, CINodeFilterDataDefinition> renameOldCiNames(ComponentInstance ci, String oldName,
String newName) {
ci.getNodeFilter().getProperties().getListToscaDataDefinition().stream()
.filter(property -> isPropertyConstraintChangedByCi(property, oldName))
.forEach(property -> renamePropertyCiNames(property, oldName, newName));
return new Pair<>(ci.getUniqueId(), ci.getNodeFilter());
}
private static void renamePropertyCiNames(RequirementNodeFilterPropertyDataDefinition property, String oldName,
String newName) {
final List<String> constraints = property.getConstraints().stream().map(getConstraintString(oldName, newName))
.collect(Collectors.toList());
property.setConstraints(constraints);
}
private static Function<String, String> getConstraintString(String oldName, String newName) {
return constraint -> {
final ConstraintConvertor constraintConvertor = new ConstraintConvertor();
UIConstraint uiConstraint = constraintConvertor.convert(constraint);
if (uiConstraint.getSourceName().equals(oldName)) {
uiConstraint.setSourceName(newName);
}
return constraintConvertor.convert(uiConstraint);
};
}
public static Set<String> getNodesFiltersToBeDeleted(Service service, String ciName) {
return service.getComponentInstances().stream().filter(ci -> isNodeFilterUsingChangedCi(ci, ciName))
.map(ComponentInstance::getName).collect(Collectors.toSet());
}
public static Set<String> getNodesFiltersToBeDeleted(Service service, ComponentInstance inCi) {
return getNodesFiltersToBeDeleted(service, inCi.getName());
}
private static boolean isNodeFilterUsingChangedCi(ComponentInstance ci, String name) {
final List<String> directives = ci.getDirectives();
if (!directives.contains(DirectivesUtils.SELECTABLE)) {
return false;
}
if (ci.getNodeFilter() == null || ci.getNodeFilter().getProperties() == null
|| ci.getNodeFilter().getProperties().getListToscaDataDefinition() == null) {
return false;
}
return ci.getNodeFilter().getProperties().getListToscaDataDefinition().stream()
.anyMatch(property -> isPropertyConstraintChangedByCi(property, name));
}
private static boolean isPropertyConstraintChangedByCi(
RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition, String name) {
List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
if (constraints == null) {
return false;
}
return constraints.stream().anyMatch(constraint -> isConstraintChangedByCi(constraint, name));
}
private static boolean isConstraintChangedByCi(String constraint, String name) {
UIConstraint uiConstraint = new ConstraintConvertor().convert(constraint);
if (uiConstraint == null || uiConstraint.getSourceType() == null) {
return false;
}
if (!uiConstraint.getSourceType().equals(ConstraintConvertor.PROPERTY_CONSTRAINT)) {
return false;
}
return uiConstraint.getSourceName().equals(name);
}
public static Set<String> getNodesFiltersToBeDeleted(Service service, InputDefinition changedInput) {
return service.getComponentInstances().stream().filter(ci -> isNodeFilterUsingChangedInput(ci, changedInput))
.map(ComponentInstance::getName).collect(Collectors.toSet());
}
private static boolean isNodeFilterUsingChangedInput(ComponentInstance ci, InputDefinition changedInput) {
final List<String> directives = ci.getDirectives();
if (!directives.contains(DirectivesUtils.SELECTABLE)) {
return false;
}
return ci.getNodeFilter().getProperties().getListToscaDataDefinition().stream()
.anyMatch(property -> isPropertyConstraintChangedByInput(property, changedInput));
}
private static boolean isPropertyConstraintChangedByInput(
RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition,
InputDefinition changedInput) {
List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
return constraints.stream().anyMatch(constraint -> isConstraintChangedByInput(constraint, changedInput));
}
private static boolean isConstraintChangedByInput(String constraint, InputDefinition changedInput) {
UIConstraint uiConstraint = new ConstraintConvertor().convert(constraint);
if (!uiConstraint.getSourceType().equals(ConstraintConvertor.SERVICE_INPUT_CONSTRAINT)) {
return false;
}
return uiConstraint.getValue().equals(changedInput.getName());
}
}
|
