catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java

   1 /*
   2  * Copyright © 2016-2020 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.tosca;
  18
  19 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
  20 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
  21 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude;
  24 import com.fasterxml.jackson.databind.DeserializationFeature;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import com.fasterxml.jackson.databind.module.SimpleModule;
  27 import com.google.gson.Gson;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Map.Entry;
  33 import java.util.Objects;
  34 import java.util.Set;
  35 import java.util.stream.Collectors;
  36 import org.apache.commons.collections.MapUtils;
  37 import org.apache.commons.collections4.CollectionUtils;
  38 import org.apache.commons.lang3.StringUtils;
  39 import org.apache.commons.lang3.math.NumberUtils;
  40 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
  42 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  45 import org.openecomp.sdc.be.model.Component;
  46 import org.openecomp.sdc.be.model.ComponentInstance;
  47 import org.openecomp.sdc.be.model.DataTypeDefinition;
  48 import org.openecomp.sdc.be.model.InterfaceDefinition;
  49 import org.openecomp.sdc.be.model.Product;
  50 import org.openecomp.sdc.be.model.PropertyDefinition;
  51 import org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType;
  52 import org.openecomp.sdc.be.tosca.model.ToscaArtifactDefinition;
  53 import org.openecomp.sdc.be.tosca.model.ToscaInput;
  54 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
  55 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceNodeType;
  56 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceOperationImplementation;
  57 import org.openecomp.sdc.be.tosca.model.ToscaLifecycleOperationDefinition;
  58 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
  59 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
  60 import org.openecomp.sdc.be.tosca.model.ToscaPropertyAssignment;
  61 import org.openecomp.sdc.be.tosca.model.ToscaPropertyAssignmentJsonSerializer;
  62 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
  63 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
  64 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  65 import org.springframework.beans.factory.annotation.Autowired;
  66 import org.springframework.stereotype.Service;
  67
  68 @Service
  69 public class InterfacesOperationsConverter {
  70
  71     public static final String SELF = "SELF";
  72     private static final String DERIVED_FROM_STANDARD_INTERFACE = "tosca.interfaces.node.lifecycle.Standard";
  73     private static final String DERIVED_FROM_BASE_DEFAULT = "org.openecomp.interfaces.node.lifecycle.";
  74     private static final String DEFAULT_HAS_UNDERSCORE = "_default";
  75     private static final String DOT = ".";
  76     private static final String DEFAULTP = "defaultp";
  77     private static final String LOCAL_INTERFACE_TYPE = "Local";
  78     private final PropertyConvertor propertyConvertor;
  79
  80     @Autowired
  81     public InterfacesOperationsConverter(final PropertyConvertor propertyConvertor) {
  82         this.propertyConvertor = propertyConvertor;
  83     }
  84
  85     private static Object getDefaultValue(Map<String, Object> inputValueMap) {
  86         Object defaultValue = null;
  87         for (Map.Entry<String, Object> operationEntry : inputValueMap.entrySet()) {
  88             final Object value = operationEntry.getValue();
  89             if (value instanceof Map) {
  90                 getDefaultValue((Map<String, Object>) value);
  91             }
  92             final String key = operationEntry.getKey();
  93             if (key.equals(DEFAULTP)) {
  94                 defaultValue = inputValueMap.remove(key);
  95             }
  96         }
  97         return defaultValue;
  98     }
  99
 100     //Remove input type and copy default value directly into the proxy node template from the node type
 101     private static void handleOperationInputValue(Map<String, Object> operationsMap, String parentKey) {
 102         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
 103             final Object value = operationEntry.getValue();
 104             final String key = operationEntry.getKey();
 105             if (value instanceof Map) {
 106                 if (INPUTS.getElementName().equals(parentKey)) {
 107                     Object defaultValue = getDefaultValue((Map<String, Object>) value);
 108                     operationsMap.put(key, defaultValue);
 109                 } else {
 110                     handleOperationInputValue((Map<String, Object>) value, key);
 111                 }
 112             }
 113         }
 114     }
 115
 116     private static String getLastPartOfName(String toscaResourceName) {
 117         return toscaResourceName.substring(toscaResourceName.lastIndexOf(DOT) + 1);
 118     }
 119
 120     private static String getInputValue(final OperationInputDefinition input) {
 121         if (null != input.getToscaFunction()) {
 122             return input.getToscaFunction().getJsonObjectValue().toString();
 123         }
 124         String inputValue = input.getValue() == null ? input.getToscaDefaultValue() : input.getValue();
 125         if (inputValue != null && inputValue.contains(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) {
 126             Gson gson = new Gson();
 127             Map<String, List<String>> consumptionValue = gson.fromJson(inputValue, Map.class);
 128             List<String> mappedOutputValue = consumptionValue.get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName());
 129             //Extract the interface name from the interface type
 130             String interfaceType = mappedOutputValue.get(1);
 131             String interfaceName = interfaceType.substring(interfaceType.lastIndexOf('.') + 1);
 132             mappedOutputValue.remove(1);
 133             mappedOutputValue.add(1, interfaceName);
 134             inputValue = gson.toJson(consumptionValue);
 135         }
 136         return inputValue;
 137     }
 138
 139     private static String getInterfaceType(Component component, String interfaceType) {
 140         if (LOCAL_INTERFACE_TYPE.equals(interfaceType)) {
 141             return DERIVED_FROM_BASE_DEFAULT + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName();
 142         }
 143         return interfaceType;
 144     }
 145
 146     private static Map<String, Object> getObjectAsMap(final Object obj) {
 147         final Map<String, Object> objectAsMap;
 148         if (obj instanceof Map) {
 149             objectAsMap = (Map<String, Object>) obj;
 150         } else {
 151             final ObjectMapper objectMapper = new ObjectMapper();
 152             final SimpleModule module = new SimpleModule("ToscaPropertyAssignmentSerializer");
 153             module.addSerializer(ToscaPropertyAssignment.class, new ToscaPropertyAssignmentJsonSerializer());
 154             objectMapper.registerModule(module);
 155             if (obj instanceof ToscaInterfaceDefinition) {
 156                 //Prevent empty field serialization in interface definition
 157                 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 158             }
 159             objectAsMap = objectMapper.convertValue(obj, Map.class);
 160         }
 161
 162         final String defaultEntry = DEFAULT.getElementName();
 163         if (objectAsMap.containsKey(defaultEntry)) {
 164             objectAsMap.put(DEFAULT_HAS_UNDERSCORE, objectAsMap.remove(defaultEntry));
 165         }
 166         return objectAsMap;
 167     }
 168
 169     /**
 170      * Creates the interface_types element.
 171      *
 172      * @param component to work on
 173      * @return the added element
 174      */
 175     public Map<String, Object> addInterfaceTypeElement(Component component, List<String> allInterfaceTypes) {
 176         if (component instanceof Product) {
 177             return null;
 178         }
 179         final Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
 180         if (MapUtils.isEmpty(interfaces)) {
 181             return null;
 182         }
 183         Map<String, Object> toscaInterfaceTypes = new HashMap<>();
 184         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
 185             boolean isInterfaceTypeExistInGlobalType = allInterfaceTypes.stream()
 186                 .anyMatch(type -> type.equalsIgnoreCase(interfaceDefinition.getType()));
 187             if (!isInterfaceTypeExistInGlobalType) {
 188                 ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
 189                 toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
 190                 final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
 191                 Map<String, Object> toscaOperations = new HashMap<>();
 192                 for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
 193                     toscaOperations.put(operationEntry.getValue().getName(), null);
 194                 }
 195                 toscaInterfaceType.setOperations(toscaOperations);
 196                 Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
 197                 Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS.getElementName());
 198                 interfacesAsMap.putAll(operationsMap);
 199                 toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
 200             }
 201         }
 202         return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
 203     }
 204
 205     private boolean isArtifactPresent(final OperationDataDefinition operationDataDefinition) {
 206         return operationDataDefinition.getImplementation() != null
 207             && StringUtils.isNotEmpty(operationDataDefinition.getImplementation().getArtifactName());
 208     }
 209
 210     /**
 211      * Adds the 'interfaces' element to the node type provided.
 212      *
 213      * @param component to work on
 214      * @param nodeType  to which the interfaces element will be added
 215      */
 216     public void addInterfaceDefinitionElement(Component component, ToscaNodeType nodeType, Map<String, DataTypeDefinition> dataTypes,
 217                                               boolean isAssociatedComponent) {
 218         if (component instanceof Product) {
 219             return;
 220         }
 221         final Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
 222         if (MapUtils.isEmpty(interfaces)) {
 223             return;
 224         }
 225         Map<String, Object> toscaInterfaceDefinitions = getInterfacesMap(component, dataTypes, isAssociatedComponent);
 226         if (MapUtils.isNotEmpty(toscaInterfaceDefinitions)) {
 227             nodeType.setInterfaces(toscaInterfaceDefinitions);
 228         }
 229     }
 230
 231     private Map<String, Object> getInterfacesMap(Component component, Map<String, DataTypeDefinition> dataTypes, boolean isAssociatedComponent) {
 232         return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent);
 233     }
 234
 235     public Map<String, Object> getInterfacesMap(final Component component, final ComponentInstance componentInstance,
 236                                                 final Map<String, InterfaceDefinition> interfaces, final Map<String, DataTypeDefinition> dataTypes,
 237                                                 final boolean isAssociatedComponent) {
 238         if (MapUtils.isEmpty(interfaces)) {
 239             return null;
 240         }
 241         final Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
 242         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
 243             handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent,
 244                 toscaInterfaceDefinitions, interfaceDefinition);
 245         }
 246         return toscaInterfaceDefinitions;
 247     }
 248
 249     public Map<String, Object> getInterfacesMapFromComponentInstance(final Component component, final ComponentInstance componentInstance,
 250                                                                      final Map<String, DataTypeDefinition> dataTypes,
 251                                                                      final boolean isAssociatedComponent) {
 252         final Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
 253         final ObjectMapper objectMapper = new ObjectMapper();
 254         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 255         for (final Map.Entry<String, Object> interfaceEntry : componentInstance.getInterfaces().entrySet()) {
 256             final InterfaceDefinition interfaceDefinition = objectMapper.convertValue(interfaceEntry.getValue(), InterfaceDefinition.class);
 257             handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent,
 258                 toscaInterfaceDefinitions, interfaceDefinition);
 259         }
 260         return toscaInterfaceDefinitions;
 261     }
 262
 263     private void handleInterfaceOperations(final Component component, final ComponentInstance componentInstance,
 264                                            final Map<String, DataTypeDefinition> dataTypes, final boolean isAssociatedComponent,
 265                                            final Map<String, Object> toscaInterfaceDefinitions,
 266                                            final InterfaceDefinition interfaceDefinition) {
 267         final String interfaceType;
 268         if (componentInstance != null && LOCAL_INTERFACE_TYPE.equals(interfaceDefinition.getType())) {
 269             interfaceType = DERIVED_FROM_BASE_DEFAULT + componentInstance.getSourceModelName();
 270         } else {
 271             interfaceType = getInterfaceType(component, interfaceDefinition.getType());
 272         }
 273         final ToscaInterfaceDefinition toscaInterfaceDefinition = new ToscaInterfaceDefinition();
 274         if (componentInstance == null) {
 275             toscaInterfaceDefinition.setType(interfaceType);
 276         }
 277         final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
 278         final Map<String, Object> toscaOperationMap = new HashMap<>();
 279         for (final Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
 280             if (operationHasAnImplementation(operationEntry.getValue())) {
 281                 final ToscaLifecycleOperationDefinition toscaLifecycleOperationDefinition = new ToscaLifecycleOperationDefinition();
 282                 handleInterfaceOperationImplementation(component, componentInstance, isAssociatedComponent, operationEntry.getValue(),
 283                     toscaLifecycleOperationDefinition, dataTypes);
 284                 if (StringUtils.isNotEmpty(operationEntry.getValue().getDescription())) {
 285                     toscaLifecycleOperationDefinition.setDescription(operationEntry.getValue().getDescription());
 286                 }
 287                 fillToscaOperationInputs(operationEntry.getValue(), dataTypes, toscaLifecycleOperationDefinition);
 288                 toscaOperationMap.put(operationEntry.getValue().getName(), toscaLifecycleOperationDefinition);
 289             }
 290         }
 291         toscaInterfaceDefinition.setOperations(toscaOperationMap);
 292         final Map<String, Object> interfaceInputMap = createInterfaceInputMap(interfaceDefinition, dataTypes);
 293         if (MapUtils.isNotEmpty(interfaceInputMap)) {
 294             toscaInterfaceDefinition.setInputs(interfaceInputMap);
 295         }
 296         final Map<String, Object> interfaceDefinitionAsMap = getObjectAsMap(toscaInterfaceDefinition);
 297         if (interfaceDefinitionAsMap.containsKey(INPUTS.getElementName())) {
 298             handleDefaults((Map<String, Object>) interfaceDefinitionAsMap.get(INPUTS.getElementName()));
 299         }
 300         final Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefinitionAsMap.remove(OPERATIONS.getElementName());
 301         handleOperationInputValue(operationsMap, interfaceType);
 302         interfaceDefinitionAsMap.putAll(operationsMap);
 303         toscaInterfaceDefinitions.put(getLastPartOfName(interfaceType), interfaceDefinitionAsMap);
 304     }
 305
 306     private boolean operationHasAnImplementation(OperationDataDefinition operation) {
 307         return operation.getImplementation() != null && StringUtils.isNotEmpty(operation.getImplementation().getArtifactName()) &&
 308             !operation.getImplementation().getArtifactName().equals("''");
 309     }
 310
 311     private void handleInterfaceOperationImplementation(final Component component, final ComponentInstance componentInstance,
 312                                                         final boolean isAssociatedComponent,
 313                                                         final OperationDataDefinition operationDataDefinition,
 314                                                         final ToscaLifecycleOperationDefinition toscaOperation,
 315                                                         final Map<String, DataTypeDefinition> dataTypes) {
 316         final ArtifactDataDefinition implementation = operationDataDefinition.getImplementation();
 317         if (implementation == null) {
 318             return;
 319         }
 320
 321         if (isArtifactPresent(operationDataDefinition)) {
 322             final String operationArtifactPath =
 323                 OperationArtifactUtil.createOperationArtifactPath(component, componentInstance, operationDataDefinition, isAssociatedComponent);
 324             final ToscaInterfaceOperationImplementation toscaInterfaceOperationImplementation = new ToscaInterfaceOperationImplementation();
 325             if (implementation.getTimeout() != null && implementation.getTimeout() > 0) {
 326                 toscaInterfaceOperationImplementation.setTimeout(implementation.getTimeout());
 327             }
 328             if (implementation.getArtifactType() != null) {
 329                 final ToscaArtifactDefinition toscaArtifactDefinition = new ToscaArtifactDefinition();
 330                 toscaArtifactDefinition.setFile(operationArtifactPath);
 331                 final String artifactVersion = implementation.getArtifactVersion();
 332                 toscaArtifactDefinition.setArtifact_version(!artifactVersion.equals(NumberUtils.INTEGER_ZERO.toString()) ? artifactVersion : null);
 333                 toscaArtifactDefinition.setType(implementation.getArtifactType());
 334                 final Map<String, ToscaPropertyAssignment> propertiesMap = handleImplementationProperties(operationDataDefinition, dataTypes);
 335                 if (MapUtils.isNotEmpty(propertiesMap)) {
 336                     toscaArtifactDefinition.setProperties(propertiesMap);
 337                 }
 338                 toscaInterfaceOperationImplementation.setPrimary(toscaArtifactDefinition);
 339                 toscaOperation.setImplementation(toscaInterfaceOperationImplementation);
 340             } else {
 341                 if (toscaInterfaceOperationImplementation.getTimeout() != null) {
 342                     final ToscaArtifactDefinition toscaArtifactDefinition = new ToscaArtifactDefinition();
 343                     toscaArtifactDefinition.setFile(StringUtils.isBlank(operationArtifactPath) || "null".equals(operationArtifactPath) ? null : operationArtifactPath);
 344                     toscaInterfaceOperationImplementation.setPrimary(toscaArtifactDefinition);
 345                     toscaOperation.setImplementation(toscaInterfaceOperationImplementation);
 346                 } else {
 347                     toscaOperation.setImplementation(
 348                         StringUtils.isBlank(operationArtifactPath) || "null".equals(operationArtifactPath) ? null : operationArtifactPath);
 349                 }
 350             }
 351         }
 352     }
 353
 354     private Map<String, ToscaPropertyAssignment> handleImplementationProperties(final OperationDataDefinition operationDataDefinition,
 355                                                                                 final Map<String, DataTypeDefinition> dataTypes) {
 356         if (operationDataDefinition.getImplementation() == null) {
 357             return new HashMap<>();
 358         }
 359
 360         final List<PropertyDataDefinition> properties = operationDataDefinition.getImplementation().getProperties();
 361         if (CollectionUtils.isEmpty(properties)) {
 362             return new HashMap<>();
 363         }
 364
 365         final Map<String, ToscaPropertyAssignment> propertiesMap = new HashMap<>();
 366         properties.stream()
 367             .filter(propertyDataDefinition -> StringUtils.isNotEmpty(propertyDataDefinition.getValue()))
 368             .forEach(propertyDataDefinition -> {
 369                     final String propertyValue =
 370                         propertyDataDefinition.getValue() != null ? propertyDataDefinition.getValue() : propertyDataDefinition.getDefaultValue();
 371                     final ToscaPropertyAssignment toscaPropertyAssignment = new ToscaPropertyAssignment();
 372                     toscaPropertyAssignment.setValue(propertyConvertor.convertToToscaObject(propertyDataDefinition, propertyValue, dataTypes, false));
 373                     propertiesMap.put(propertyDataDefinition.getName(), toscaPropertyAssignment);
 374                 }
 375             );
 376
 377         return propertiesMap;
 378     }
 379
 380     public void removeInterfacesWithoutOperations(final Map<String, Object> interfaceMap) {
 381         if (MapUtils.isEmpty(interfaceMap)) {
 382             return;
 383         }
 384         final Set<String> emptyInterfaces = interfaceMap.entrySet().stream().filter(entry -> {
 385             final Object value = entry.getValue();
 386             if (value instanceof ToscaInterfaceDefinition) {
 387                 final ToscaInterfaceDefinition interfaceDefinition = (ToscaInterfaceDefinition) value;
 388                 return MapUtils.isEmpty(interfaceDefinition.getOperations());
 389             } else if (value instanceof Map) {
 390                 final Map<String, Object> interfaceDefMap = (Map<String, Object>) value;
 391                 return MapUtils.isEmpty(interfaceDefMap);
 392             }
 393             return false;
 394         }).map(Entry::getKey).collect(Collectors.toSet());
 395         emptyInterfaces.forEach(interfaceMap::remove);
 396     }
 397
 398     private Map<String, Object> createInterfaceInputMap(final InterfaceDefinition interfaceDefinition,
 399                                                         final Map<String, DataTypeDefinition> allDataTypeMap) {
 400         final Map<String, InputDataDefinition> inputMap = interfaceDefinition.getInputs();
 401         if (MapUtils.isEmpty(inputMap)) {
 402             return Collections.emptyMap();
 403         }
 404         final Map<String, Object> toscaInterfaceInputMap = new HashMap<>();
 405         for (final Entry<String, InputDataDefinition> inputEntry : inputMap.entrySet()) {
 406             final InputDataDefinition inputDataDefinition = inputEntry.getValue();
 407             final ToscaProperty toscaProperty = propertyConvertor
 408                 .convertProperty(allDataTypeMap, new PropertyDefinition(inputDataDefinition), PropertyType.INPUT);
 409             toscaInterfaceInputMap.put(inputEntry.getKey(), new ToscaInput(toscaProperty));
 410         }
 411         return toscaInterfaceInputMap;
 412     }
 413
 414     /*
 415      * workaround for : currently "defaultp" is not being converted to "default" by the relevant code in
 416      * ToscaExportHandler so, any string Map key named "defaultp" will have its named changed to "default"
 417      * @param operationsMap the map to update
 418      */
 419     private void handleDefaults(Map<String, Object> operationsMap) {
 420         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
 421             final Object value = operationEntry.getValue();
 422             if (value instanceof Map) {
 423                 handleDefaults((Map<String, Object>) value);
 424             }
 425             final String key = operationEntry.getKey();
 426             if (key.equals(DEFAULTP)) {
 427                 Object removed = operationsMap.remove(key);
 428                 operationsMap.put(ToscaTagNamesEnum.DEFAULT.getElementName(), removed);
 429             }
 430         }
 431     }
 432
 433     private void fillToscaOperationInputs(OperationDataDefinition operation, Map<String, DataTypeDefinition> dataTypes,
 434                                           ToscaLifecycleOperationDefinition toscaOperation) {
 435         if (Objects.isNull(operation.getInputs()) || operation.getInputs().isEmpty()) {
 436             toscaOperation.setInputs(null);
 437             return;
 438         }
 439         Map<String, ToscaProperty> toscaInputs = new HashMap<>();
 440         for (OperationInputDefinition input : operation.getInputs().getListToscaDataDefinition()) {
 441             ToscaProperty toscaInput = new ToscaProperty();
 442             toscaInput.setDescription(input.getDescription());
 443             toscaInput.setType(input.getType());
 444             toscaInput.setRequired(input.isRequired());
 445             toscaInput.setDefaultp(propertyConvertor.convertToToscaObject(input, getInputValue(input), dataTypes, false));
 446             toscaInputs.put(input.getName(), toscaInput);
 447         }
 448         toscaOperation.setInputs(toscaInputs);
 449     }
 450
 451 }