1 files changed, 177 insertions, 0 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/impl/ServiceFilterUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/impl/ServiceFilterUtils.java
new file mode 100644
index 0000000000..7faf89cb89
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/impl/ServiceFilterUtils.java
@@ -0,0 +1,177 @@
+/*
+ * 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 java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+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;
+
+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());
+    }
+
+}