catalog-be/src/main/java/org/openecomp/sdc/be/components/property/PolicyPropertyDecelerator.java

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