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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.be.components.property;
  21
  22 import static org.openecomp.sdc.common.api.Constants.GET_INPUT;
  23 import static org.openecomp.sdc.common.api.Constants.GET_POLICY;
  24
  25 import com.google.gson.Gson;
  26 import fj.data.Either;
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.Collection;
  30 import java.util.HashMap;
  31 import java.util.HashSet;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Objects;
  35 import java.util.Optional;
  36 import java.util.Set;
  37 import java.util.stream.Collectors;
  38 import org.apache.commons.collections.CollectionUtils;
  39 import org.apache.commons.collections.MapUtils;
  40 import org.apache.commons.lang3.StringUtils;
  41 import org.json.simple.JSONObject;
  42 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
  43 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  44 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.PropertiesOwner;
  47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  48 import org.openecomp.sdc.be.impl.ComponentsUtils;
  49 import org.openecomp.sdc.be.model.CapabilityDefinition;
  50 import org.openecomp.sdc.be.model.Component;
  51 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
  52 import org.openecomp.sdc.be.model.IComponentInstanceConnectedElement;
  53 import org.openecomp.sdc.be.model.InputDefinition;
  54 import org.openecomp.sdc.be.model.PolicyDefinition;
  55 import org.openecomp.sdc.be.model.PropertyDefinition;
  56 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  57 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  58 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  59 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  60 import org.openecomp.sdc.common.log.wrappers.Logger;
  61 import org.openecomp.sdc.exception.ResponseFormat;
  62 import org.yaml.snakeyaml.Yaml;
  63
  64 public abstract class DefaultPropertyDeclarator<PROPERTYOWNER extends PropertiesOwner, PROPERTYTYPE extends PropertyDataDefinition> implements
  65     PropertyDeclarator {
  66
  67     private static final Logger log = Logger.getLogger(DefaultPropertyDeclarator.class);
  68     private static final short LOOP_PROTECTION_LEVEL = 10;
  69     private static final String UNDERSCORE = "_";
  70     private static final String GET_INPUT_INDEX = "INDEX";
  71     private final Gson gson = new Gson();
  72     private ComponentsUtils componentsUtils;
  73     private PropertyOperation propertyOperation;
  74
  75     protected DefaultPropertyDeclarator(ComponentsUtils componentsUtils, PropertyOperation propertyOperation) {
  76         this.componentsUtils = componentsUtils;
  77         this.propertyOperation = propertyOperation;
  78     }
  79
  80     @Override
  81     public Either<List<InputDefinition>, StorageOperationStatus> declarePropertiesAsInputs(Component component, String propertiesOwnerId,
  82                                                                                            List<ComponentInstancePropInput> propsToDeclare) {
  83         log.debug("#declarePropertiesAsInputs - declaring properties as inputs for component {} from properties owner {}", component.getUniqueId(),
  84             propertiesOwnerId);
  85         return resolvePropertiesOwner(component, propertiesOwnerId)
  86             .map(propertyOwner -> declarePropertiesAsInputs(component, propertyOwner, propsToDeclare))
  87             .orElse(Either.right(onPropertiesOwnerNotFound(component.getUniqueId(), propertiesOwnerId)));
  88     }
  89
  90     protected abstract PROPERTYTYPE createDeclaredProperty(PropertyDataDefinition prop);
  91
  92     protected abstract Either<?, StorageOperationStatus> updatePropertiesValues(Component component, String propertiesOwnerId,
  93                                                                                 List<PROPERTYTYPE> properties);
  94
  95     protected abstract Optional<PROPERTYOWNER> resolvePropertiesOwner(Component component, String propertiesOwnerId);
  96
  97     protected abstract void addPropertiesListToInput(PROPERTYTYPE declaredProp, InputDefinition input);
  98
  99     @Override
 100     public Either<List<PolicyDefinition>, StorageOperationStatus> declarePropertiesAsPolicies(Component component, String propertiesOwnerId,
 101                                                                                               List<ComponentInstancePropInput> propsToDeclare) {
 102         log.debug("#declarePropertiesAsPolicies - declaring properties as policies for component {} from properties owner {}",
 103             component.getUniqueId(), propertiesOwnerId);
 104         return resolvePropertiesOwner(component, propertiesOwnerId)
 105             .map(propertyOwner -> declarePropertiesAsPolicies(component, propertyOwner, propsToDeclare))
 106             .orElse(Either.right(onPropertiesOwnerNotFound(component.getUniqueId(), propertiesOwnerId)));
 107     }
 108
 109     @Override
 110     public Either<InputDefinition, StorageOperationStatus> declarePropertiesAsListInput(Component component, String propertiesOwnerId,
 111                                                                                         List<ComponentInstancePropInput> propsToDeclare,
 112                                                                                         InputDefinition input) {
 113         log.debug("#declarePropertiesAsListInput - declaring properties as inputs for component {} from properties owner {}", component.getUniqueId(),
 114             propertiesOwnerId);
 115         Optional<PROPERTYOWNER> propertyOwner = resolvePropertiesOwner(component, propertiesOwnerId);
 116         if (propertyOwner.isPresent()) {
 117             return declarePropertiesAsListInput(component, propertyOwner.get(), propsToDeclare, input);
 118         } else {
 119             return Either.right(onPropertiesOwnerNotFound(component.getUniqueId(), propertiesOwnerId));
 120         }
 121     }
 122
 123     public StorageOperationStatus unDeclarePropertiesAsPolicies(Component component, PolicyDefinition policy) {
 124         return StorageOperationStatus.OK;
 125     }
 126
 127     private Either<List<PolicyDefinition>, StorageOperationStatus> declarePropertiesAsPolicies(Component component, PROPERTYOWNER propertiesOwner,
 128                                                                                                List<ComponentInstancePropInput> propsToDeclare) {
 129         PropertiesDeclarationData policyProperties = createPoliciesAndOverridePropertiesValues(propertiesOwner.getUniqueId(), propertiesOwner,
 130             propsToDeclare);
 131         return updatePropertiesValues(component, propertiesOwner.getUniqueId(), policyProperties.getPropertiesToUpdate()).left()
 132             .map(updatePropsRes -> policyProperties.getPoliciesToCreate());
 133     }
 134
 135     private StorageOperationStatus onPropertiesOwnerNotFound(String componentId, String propertiesOwnerId) {
 136         log.debug("#declarePropertiesAsInputs - properties owner {} was not found on component {}", propertiesOwnerId, componentId);
 137         return StorageOperationStatus.NOT_FOUND;
 138     }
 139
 140     private Either<List<InputDefinition>, StorageOperationStatus> declarePropertiesAsInputs(Component component, PROPERTYOWNER propertiesOwner,
 141                                                                                             List<ComponentInstancePropInput> propsToDeclare) {
 142         PropertiesDeclarationData inputsProperties = createInputsAndOverridePropertiesValues(component, propertiesOwner, propsToDeclare);
 143         return updatePropertiesValues(component, propertiesOwner.getUniqueId(), inputsProperties.getPropertiesToUpdate()).left()
 144             .map(updatePropsRes -> inputsProperties.getInputsToCreate());
 145     }
 146
 147     private PropertiesDeclarationData createPoliciesAndOverridePropertiesValues(String componentId, PROPERTYOWNER propertiesOwner,
 148                                                                                 List<ComponentInstancePropInput> propsToDeclare) {
 149         List<PROPERTYTYPE> declaredProperties = new ArrayList<>();
 150         List<PolicyDefinition> policies = new ArrayList<>();
 151         propsToDeclare.forEach(property -> policies.add(declarePropertyPolicy(componentId, declaredProperties, property)));
 152         return new PropertiesDeclarationData(null, policies, declaredProperties);
 153     }
 154
 155     private PolicyDefinition declarePropertyPolicy(String componentId, List<PROPERTYTYPE> declaredProperties, ComponentInstancePropInput propInput) {
 156         PropertyDataDefinition prop = resolveProperty(declaredProperties, propInput);
 157         propInput.setOwnerId(null);
 158         propInput.setParentUniqueId(null);
 159         PolicyDefinition policyDefinition = new PolicyDefinition(prop);
 160         policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(componentId, prop.getName()));
 161         policyDefinition.setInputPath(prop.getName());
 162         policyDefinition.setInstanceUniqueId(componentId);
 163         policyDefinition.setPropertyId(prop.getUniqueId());
 164         changePropertyValueToGetPolicy(prop, policyDefinition);
 165         PROPERTYTYPE declaredProperty = createDeclaredProperty(prop);
 166         if (!declaredProperties.contains(declaredProperty)) {
 167             declaredProperties.add(declaredProperty);
 168         }
 169         return policyDefinition;
 170     }
 171
 172     private void changePropertyValueToGetPolicy(PropertyDataDefinition prop, PolicyDefinition policyDefinition) {
 173         JSONObject jsonObject = new JSONObject();
 174         String origValue = Objects.isNull(prop.getValue()) ? prop.getDefaultValue() : prop.getValue();
 175         jsonObject.put(GET_POLICY, null);
 176         prop.setValue(jsonObject.toJSONString());
 177         policyDefinition.setValue(jsonObject.toJSONString());
 178         if (CollectionUtils.isEmpty(prop.getGetPolicyValues())) {
 179             prop.setGetPolicyValues(new ArrayList<>());
 180         }
 181         List<GetPolicyValueDataDefinition> getPolicyValues = prop.getGetPolicyValues();
 182         GetPolicyValueDataDefinition getPolicyValueDataDefinition = new GetPolicyValueDataDefinition();
 183         getPolicyValueDataDefinition.setPolicyId(policyDefinition.getUniqueId());
 184         getPolicyValueDataDefinition.setPropertyName(prop.getName());
 185         getPolicyValueDataDefinition.setOrigPropertyValue(origValue);
 186         getPolicyValues.add(getPolicyValueDataDefinition);
 187         policyDefinition.setGetPolicyValues(getPolicyValues);
 188     }
 189
 190     private Either<InputDefinition, StorageOperationStatus> declarePropertiesAsListInput(Component component, PROPERTYOWNER propertiesOwner,
 191                                                                                          List<ComponentInstancePropInput> propsToDeclare,
 192                                                                                          InputDefinition input) {
 193         List<PROPERTYTYPE> declaredProperties = new ArrayList<>();
 194         for (ComponentInstancePropInput propInput : propsToDeclare) {
 195             if (StringUtils.isNotEmpty(propInput.getPropertiesName()) && propInput.getInput() != null) {
 196                 // sub-property in complex type is checked on UI. currently not supported.
 197                 log.debug("skip propInput (propertiesName={}) currently not supported.", propInput.getPropertiesName());
 198                 continue;
 199             }
 200             PROPERTYTYPE declaredProperty = createDeclaredProperty(propInput);
 201             JSONObject jsonObject = new JSONObject();
 202             jsonObject.put(GET_INPUT, Arrays.asList(input.getName(), GET_INPUT_INDEX, propInput.getName()));
 203             declaredProperty.setValue(jsonObject.toJSONString());
 204             GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
 205             getInputValueDataDefinition.setInputId(input.getUniqueId());
 206             getInputValueDataDefinition.setInputName(input.getName());
 207             List<GetInputValueDataDefinition> getInputValues = declaredProperty.getGetInputValues();
 208             if (getInputValues == null) {
 209                 getInputValues = new ArrayList<>();
 210                 declaredProperty.setGetInputValues(getInputValues);
 211             }
 212             getInputValues.add(getInputValueDataDefinition);
 213             if (!declaredProperties.contains(declaredProperty)) {
 214                 // Add property to the list if not contain in declareProperties.
 215                 declaredProperties.add(declaredProperty);
 216             }
 217         }
 218         return updatePropertiesValues(component, propertiesOwner.getUniqueId(), declaredProperties).left().map(x -> input);
 219     }
 220
 221     private PropertiesDeclarationData createInputsAndOverridePropertiesValues(Component component, PROPERTYOWNER propertiesOwner,
 222                                                                               List<ComponentInstancePropInput> propsToDeclare) {
 223         List<PROPERTYTYPE> declaredProperties = new ArrayList<>();
 224         List<InputDefinition> createdInputs = propsToDeclare.stream()
 225             .map(propInput -> declarePropertyInput(component, propertiesOwner, declaredProperties, propInput)).collect(Collectors.toList());
 226         return new PropertiesDeclarationData(createdInputs, null, declaredProperties);
 227     }
 228
 229     private InputDefinition declarePropertyInput(Component component, PROPERTYOWNER propertiesOwner, List<PROPERTYTYPE> declaredProperties,
 230                                                  ComponentInstancePropInput propInput) {
 231         PropertyDataDefinition prop = resolveProperty(declaredProperties, propInput);
 232         InputDefinition inputDefinition = createInput(component, propertiesOwner, propInput, prop);
 233         PROPERTYTYPE declaredProperty = createDeclaredProperty(prop);
 234         if (!declaredProperties.contains(declaredProperty)) {
 235             declaredProperties.add(declaredProperty);
 236         }
 237         addPropertiesListToInput(declaredProperty, inputDefinition);
 238         return inputDefinition;
 239     }
 240
 241     private InputDefinition createInput(Component component, PROPERTYOWNER propertiesOwner, ComponentInstancePropInput propInput,
 242                                         PropertyDataDefinition prop) {
 243         String generatedInputPrefix = propertiesOwner.getNormalizedName();
 244         if (component.getUniqueId().equals(propInput.getParentUniqueId())) {
 245             //Creating input from property create on self using add property..Do not add the prefix
 246             generatedInputPrefix = null;
 247         }
 248         Optional<CapabilityDefinition> propertyCapability = PropertiesUtils
 249             .getPropertyCapabilityOfChildInstance(propInput.getParentUniqueId(), component.getCapabilities());
 250         if (propertyCapability.isPresent()) {
 251             String capName = propertyCapability.get().getName();
 252             if (capName.contains(".")) {
 253                 capName = capName.replaceAll("\\.", UNDERSCORE);
 254             }
 255             generatedInputPrefix =
 256                 generatedInputPrefix == null || generatedInputPrefix.isEmpty() ? capName : generatedInputPrefix + UNDERSCORE + capName;
 257         }
 258         String generatedInputName = generateInputName(generatedInputPrefix, propInput);
 259         log.debug("createInput: propOwner.uniqueId={}, propInput.parentUniqueId={}", propertiesOwner.getUniqueId(), propInput.getParentUniqueId());
 260         return createInputFromProperty(component.getUniqueId(), propertiesOwner, generatedInputName, propInput, prop);
 261     }
 262
 263     private String generateInputName(String inputName, ComponentInstancePropInput propInput) {
 264         String declaredInputName;
 265         String[] parsedPropNames = propInput.getParsedPropNames();
 266         if (parsedPropNames != null) {
 267             declaredInputName = handleInputName(inputName, parsedPropNames);
 268         } else {
 269             String[] propName = {propInput.getName()};
 270             declaredInputName = handleInputName(inputName, propName);
 271         }
 272         return declaredInputName;
 273     }
 274
 275     private String handleInputName(String inputName, String[] parsedPropNames) {
 276         StringBuilder prefix = new StringBuilder();
 277         int startingIndex;
 278         if (Objects.isNull(inputName)) {
 279             prefix.append(parsedPropNames[0]);
 280             startingIndex = 1;
 281         } else {
 282             prefix.append(inputName);
 283             startingIndex = 0;
 284         }
 285         while (startingIndex < parsedPropNames.length) {
 286             prefix.append(UNDERSCORE);
 287             prefix.append(parsedPropNames[startingIndex]);
 288             startingIndex++;
 289         }
 290         return prefix.toString();
 291     }
 292
 293     private PropertyDataDefinition resolveProperty(List<PROPERTYTYPE> propertiesToCreate, ComponentInstancePropInput propInput) {
 294         Optional<PROPERTYTYPE> resolvedProperty = propertiesToCreate.stream().filter(p -> p.getName().equals(propInput.getName())).findFirst();
 295         return resolvedProperty.isPresent() ? resolvedProperty.get() : propInput;
 296     }
 297
 298     InputDefinition createInputFromProperty(String componentId, PROPERTYOWNER propertiesOwner, String inputName, ComponentInstancePropInput propInput,
 299                                             PropertyDataDefinition prop) {
 300         String propertiesName = propInput.getPropertiesName();
 301         PropertyDefinition selectedProp = propInput.getInput();
 302         String[] parsedPropNames = propInput.getParsedPropNames();
 303         InputDefinition input;
 304         boolean complexProperty = false;
 305
 306         if (propertiesName != null && !propertiesName.isEmpty() && selectedProp != null) {
 307             complexProperty = true;
 308             input = new InputDefinition(selectedProp);
 309             input.setDefaultValue(selectedProp.getValue());
 310         } else {
 311             input = new InputDefinition(prop);
 312             input.setDefaultValue(prop.getValue());
 313         }
 314
 315         input.setName(inputName);
 316         input.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(componentId, input.getName()));
 317         input.setInputPath(propertiesName);
 318         input.setInstanceUniqueId(propertiesOwner.getUniqueId());
 319         input.setPropertyId(propInput.getUniqueId());
 320
 321         if (Objects.isNull(input.getSubPropertyInputPath()) || (propertiesName != null && input.getSubPropertyInputPath()
 322             .substring(input.getSubPropertyInputPath().lastIndexOf('#')).equals(propertiesName.substring(propertiesName.lastIndexOf('#'))))) {
 323             input.setParentPropertyType(propInput.getType());
 324             input.setSubPropertyInputPath(propertiesName);
 325         }
 326
 327         changePropertyValueToGetInputValue(inputName, parsedPropNames, input, prop, complexProperty);
 328
 329         if (prop instanceof IComponentInstanceConnectedElement) {
 330             ((IComponentInstanceConnectedElement) prop).setComponentInstanceId(propertiesOwner.getUniqueId());
 331             ((IComponentInstanceConnectedElement) prop).setComponentInstanceName(propertiesOwner.getName());
 332         }
 333
 334         return input;
 335     }
 336
 337     private void changePropertyValueToGetInputValue(String inputName, String[] parsedPropNames, InputDefinition input, PropertyDataDefinition prop,
 338                                                     boolean complexProperty) {
 339         JSONObject jsonObject = new JSONObject();
 340         String value = prop.getValue();
 341         if (value == null || value.isEmpty()) {
 342             if (complexProperty) {
 343                 jsonObject = createJSONValueForProperty(parsedPropNames.length - 1, parsedPropNames, jsonObject, inputName);
 344                 prop.setValue(jsonObject.toJSONString());
 345             } else {
 346                 jsonObject.put(GET_INPUT, input.getName());
 347                 prop.setValue(jsonObject.toJSONString());
 348             }
 349         } else {
 350             Object objValue = new Yaml().load(value);
 351             if (objValue instanceof Map || objValue instanceof List) {
 352                 if (!complexProperty) {
 353                     jsonObject.put(GET_INPUT, input.getName());
 354                     prop.setValue(jsonObject.toJSONString());
 355                 } else {
 356                     Map<String, Object> mappedToscaTemplate = (Map<String, Object>) objValue;
 357                     createInputValue(mappedToscaTemplate, 1, parsedPropNames, inputName);
 358                     String json = gson.toJson(mappedToscaTemplate);
 359                     prop.setValue(json);
 360                 }
 361             } else {
 362                 jsonObject.put(GET_INPUT, input.getName());
 363                 prop.setValue(jsonObject.toJSONString());
 364             }
 365         }
 366         if (CollectionUtils.isEmpty(prop.getGetInputValues())) {
 367             prop.setGetInputValues(new ArrayList<>());
 368         }
 369         List<GetInputValueDataDefinition> getInputValues = prop.getGetInputValues();
 370         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
 371         getInputValueDataDefinition.setInputId(input.getUniqueId());
 372         getInputValueDataDefinition.setInputName(input.getName());
 373         getInputValues.add(getInputValueDataDefinition);
 374     }
 375
 376     private JSONObject createJSONValueForProperty(int i, String[] parsedPropNames, JSONObject ooj, String inputName) {
 377         while (i >= 1) {
 378             if (i == parsedPropNames.length - 1) {
 379                 JSONObject jobProp = new JSONObject();
 380                 jobProp.put(GET_INPUT, inputName);
 381                 ooj.put(parsedPropNames[i], jobProp);
 382                 i--;
 383                 return createJSONValueForProperty(i, parsedPropNames, ooj, inputName);
 384             } else {
 385                 JSONObject res = new JSONObject();
 386                 res.put(parsedPropNames[i], ooj);
 387                 i--;
 388                 res = createJSONValueForProperty(i, parsedPropNames, res, inputName);
 389                 return res;
 390             }
 391         }
 392         return ooj;
 393     }
 394
 395     private Map<String, Object> createInputValue(Map<String, Object> lhm1, int index, String[] inputNames, String inputName) {
 396         while (index < inputNames.length) {
 397             if (lhm1.containsKey(inputNames[index])) {
 398                 Object value = lhm1.get(inputNames[index]);
 399                 if (value instanceof Map) {
 400                     if (index == inputNames.length - 1) {
 401                         ((Map) value).put(GET_INPUT, inputName);
 402                         return (Map) value;
 403                     } else {
 404                         index++;
 405                         return createInputValue((Map) value, index, inputNames, inputName);
 406                     }
 407                 } else {
 408                     Map<String, Object> jobProp = new HashMap<>();
 409                     if (index == inputNames.length - 1) {
 410                         jobProp.put(GET_INPUT, inputName);
 411                         lhm1.put(inputNames[index], jobProp);
 412                         return lhm1;
 413                     } else {
 414                         lhm1.put(inputNames[index], jobProp);
 415                         index++;
 416                         return createInputValue(jobProp, index, inputNames, inputName);
 417                     }
 418                 }
 419             } else {
 420                 Map<String, Object> jobProp = new HashMap<>();
 421                 lhm1.put(inputNames[index], jobProp);
 422                 if (index == inputNames.length - 1) {
 423                     jobProp.put(GET_INPUT, inputName);
 424                     return jobProp;
 425                 } else {
 426                     index++;
 427                     return createInputValue(jobProp, index, inputNames, inputName);
 428                 }
 429             }
 430         }
 431         return lhm1;
 432     }
 433
 434     Either<InputDefinition, ResponseFormat> prepareValueBeforeDelete(InputDefinition inputForDelete, PropertyDataDefinition inputValue,
 435                                                                      List<String> pathOfComponentInstances) {
 436         Either<InputDefinition, ResponseFormat> deleteEither = prepareValueBeforeDelete(inputForDelete, inputValue);
 437         Either<String, JanusGraphOperationStatus> findDefaultValue = propertyOperation
 438             .findDefaultValueFromSecondPosition(pathOfComponentInstances, inputValue.getUniqueId(), (String) inputValue.getDefaultValue());
 439         if (findDefaultValue.isRight()) {
 440             deleteEither = Either.right(componentsUtils.getResponseFormat(componentsUtils
 441                 .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findDefaultValue.right().value()))));
 442             return deleteEither;
 443         }
 444         String defaultValue = findDefaultValue.left().value();
 445         inputValue.setDefaultValue(defaultValue);
 446         log.debug("The returned default value in ResourceInstanceProperty is {}", defaultValue);
 447         return deleteEither;
 448     }
 449
 450     Either<InputDefinition, ResponseFormat> prepareValueBeforeDeleteOfCapProp(InputDefinition inputForDelete, PropertyDataDefinition inputValue) {
 451         Either<InputDefinition, ResponseFormat> deleteEither = prepareValueBeforeDelete(inputForDelete, inputValue);
 452         inputValue.setDefaultValue(inputForDelete.getDefaultValue());
 453         log.debug("The returned default value in ResourceInstanceProperty is {}", inputForDelete.getDefaultValue());
 454         return deleteEither;
 455     }
 456
 457     private Either<InputDefinition, ResponseFormat> prepareValueBeforeDelete(InputDefinition inputForDelete, PropertyDataDefinition inputValue) {
 458         Either<InputDefinition, ResponseFormat> deleteEither = Either.left(inputForDelete);
 459         String value = inputValue.getValue();
 460         Map<String, Object> mappedToscaTemplate = (Map<String, Object>) new Yaml().load(value);
 461         resetInputName(mappedToscaTemplate, inputForDelete.getName());
 462         value = "";
 463         if (!mappedToscaTemplate.isEmpty()) {
 464             Either result = cleanNestedMap(mappedToscaTemplate, true);
 465             Map modifiedMappedToscaTemplate = mappedToscaTemplate;
 466             if (result.isLeft()) {
 467                 modifiedMappedToscaTemplate = (Map) result.left().value();
 468             } else {
 469                 log.warn("Map cleanup failed -> " + result.right().value()
 470                     .toString());    //continue, don't break operation
 471             }
 472             value = gson.toJson(modifiedMappedToscaTemplate);
 473         }
 474         inputValue.setValue(value);
 475         List<GetInputValueDataDefinition> getInputsValues = inputValue.getGetInputValues();
 476         if (getInputsValues != null && !getInputsValues.isEmpty()) {
 477             Optional<GetInputValueDataDefinition> op = getInputsValues.stream().filter(gi -> gi.getInputId().equals(inputForDelete.getUniqueId()))
 478                 .findAny();
 479             op.ifPresent(getInputsValues::remove);
 480         }
 481         inputValue.setGetInputValues(getInputsValues);
 482         return deleteEither;
 483     }
 484
 485     private void resetInputName(Map<String, Object> lhm1, String inputName) {
 486         for (Map.Entry<String, Object> entry : lhm1.entrySet()) {
 487             String key = entry.getKey();
 488             Object value = entry.getValue();
 489             if (value instanceof String && ((String) value).equalsIgnoreCase(inputName) && key.equals(GET_INPUT)) {
 490                 lhm1.remove(key);
 491             } else if (value instanceof Map) {
 492                 Map<String, Object> subMap = (Map<String, Object>) value;
 493                 resetInputName(subMap, inputName);
 494             } else if (value instanceof List && ((List) value).contains(inputName) && key.equals(GET_INPUT)) {
 495                 lhm1.remove(key);
 496             }
 497         }
 498     }
 499
 500     private Either cleanNestedMap(Map mappedToscaTemplate, boolean deepClone) {
 501         if (MapUtils.isNotEmpty(mappedToscaTemplate)) {
 502             if (deepClone) {
 503                 if (!(mappedToscaTemplate instanceof HashMap)) {
 504                     return Either.right("expecting mappedToscaTemplate as HashMap ,recieved " + mappedToscaTemplate.getClass().getSimpleName());
 505                 } else {
 506                     mappedToscaTemplate = (HashMap) ((HashMap) mappedToscaTemplate).clone();
 507                 }
 508             }
 509             return Either.left((Map) cleanEmptyNestedValuesInMap(mappedToscaTemplate, LOOP_PROTECTION_LEVEL));
 510         } else {
 511             log.debug("mappedToscaTemplate is empty ");
 512             return Either.right("mappedToscaTemplate is empty ");
 513         }
 514     }
 515
 516     /*        Mutates the object
 517      *        Tail recurse -> traverse the tosca elements and remove nested empty map properties
 518      *        this only handles nested maps, other objects are left untouched (even a Set containing a map) since behaviour is unexpected
 519      *
 520      *        @param  toscaElement - expected map of tosca values
 521      *        @return mutated @param toscaElement , where empty maps are deleted , return null for empty map.
 522      **/
 523     private Object cleanEmptyNestedValuesInMap(Object toscaElement, short loopProtectionLevel) {
 524         if (loopProtectionLevel <= 0 || toscaElement == null || !(toscaElement instanceof Map)) {
 525             return toscaElement;
 526         }
 527         if (MapUtils.isNotEmpty((Map) toscaElement)) {
 528             Object ret;
 529             Set<Object> keysToRemove = new HashSet<>();                                                                 // use different set to avoid ConcurrentModificationException
 530             for (Object key : ((Map) toscaElement).keySet()) {
 531                 Object value = ((Map) toscaElement).get(key);
 532                 ret = cleanEmptyNestedValuesInMap(value, --loopProtectionLevel);
 533                 if (ret == null) {
 534                     keysToRemove.add(key);
 535                 }
 536             }
 537             Collection set = ((Map) toscaElement).keySet();
 538             if (CollectionUtils.isNotEmpty(set)) {
 539                 set.removeAll(keysToRemove);
 540             }
 541             if (isEmptyNestedMap(toscaElement)) {
 542                 return null;
 543             }
 544         } else {
 545             return null;
 546         }
 547         return toscaElement;
 548     }
 549
 550     //ignores other collection objects
 551     private boolean isEmptyNestedMap(Object element) {
 552         boolean isEmpty = true;
 553         if (element != null) {
 554             if (element instanceof Map) {
 555                 if (MapUtils.isEmpty((Map) element)) {
 556                     isEmpty = true;
 557                 } else {
 558                     for (Object key : ((Map) (element)).keySet()) {
 559                         Object value = ((Map) (element)).get(key);
 560                         isEmpty &= isEmptyNestedMap(value);
 561                     }
 562                 }
 563             } else {
 564                 isEmpty = false;
 565             }
 566         }
 567         return isEmpty;
 568     }
 569     //@returns true iff map nested maps are all empty
 570
 571     private class PropertiesDeclarationData {
 572
 573         private List<InputDefinition> inputsToCreate;
 574         private List<PolicyDefinition> policiesToCreate;
 575         private List<PROPERTYTYPE> propertiesToUpdate;
 576
 577         PropertiesDeclarationData(List<InputDefinition> inputsToCreate, List<PolicyDefinition> policiesToCreate,
 578                                   List<PROPERTYTYPE> propertiesToUpdate) {
 579             this.inputsToCreate = inputsToCreate;
 580             this.policiesToCreate = policiesToCreate;
 581             this.propertiesToUpdate = propertiesToUpdate;
 582         }
 583
 584         List<InputDefinition> getInputsToCreate() {
 585             return inputsToCreate;
 586         }
 587
 588         public List<PolicyDefinition> getPoliciesToCreate() {
 589             return policiesToCreate;
 590         }
 591
 592         List<PROPERTYTYPE> getPropertiesToUpdate() {
 593             return propertiesToUpdate;
 594         }
 595     }
 596 }