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

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