2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2020 Nordix Foundation
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * SPDX-License-Identifier: Apache-2.0
17 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.components.impl;
22 import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
23 import static org.openecomp.sdc.be.utils.PropertyFilterConstraintDataDefinitionHelper.createToscaFunctionFromLegacyConstraintValue;
24 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.ACTIVITIES;
25 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
26 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
27 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.FILTERS;
28 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IMPLEMENTATION;
29 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
30 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.MILESTONES;
31 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS;
32 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
33 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
34 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS;
35 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
36 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.VALUE;
37 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.WORKFLOW;
39 import com.google.gson.Gson;
40 import fj.data.Either;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.Collections;
44 import java.util.HashMap;
45 import java.util.HashSet;
46 import java.util.LinkedHashMap;
47 import java.util.List;
49 import java.util.Map.Entry;
50 import java.util.Objects;
51 import java.util.Optional;
53 import java.util.UUID;
54 import java.util.stream.Collectors;
55 import org.apache.commons.collections.MapUtils;
56 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
57 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
58 import org.openecomp.sdc.be.dao.api.ActionStatus;
59 import org.openecomp.sdc.be.datatypes.elements.ActivityDataDefinition;
60 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
61 import org.openecomp.sdc.be.datatypes.elements.FilterDataDefinition;
62 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
63 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
64 import org.openecomp.sdc.be.datatypes.elements.MilestoneDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.ToscaFunction;
70 import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType;
71 import org.openecomp.sdc.be.datatypes.enums.ActivityTypeEnum;
72 import org.openecomp.sdc.be.datatypes.enums.ConstraintType;
73 import org.openecomp.sdc.be.model.InputDefinition;
74 import org.openecomp.sdc.be.model.InterfaceDefinition;
75 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
76 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
77 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
78 import org.openecomp.sdc.exception.ResponseFormat;
79 import org.slf4j.Logger;
80 import org.slf4j.LoggerFactory;
81 import org.springframework.stereotype.Component;
84 * Handles interface definition TOSCA conversions
86 @Component("interfaceDefinitionHandler")
87 public class InterfaceDefinitionHandler {
89 private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
90 private static final String WITH_ATTRIBUTE = "with attribute '{}': '{}'";
91 private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
93 public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
94 this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
98 * Creates an interface definition based on a TOSCA map representing an interface definition.
100 * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
101 * @return an interface definition representation
103 public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap, final String model) {
104 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
105 interfaceDefinition.setModel(model);
106 if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
107 final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
108 if (!(typeObj instanceof String)) {
109 throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
111 final String type = (String) typeObj;
112 interfaceDefinition.setType(type);
113 interfaceDefinition.setUniqueId(type);
115 final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
116 if (!inputDefinitionMap.isEmpty()) {
117 final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream()
118 .collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
119 interfaceDefinition.setInputs(collect);
121 final Map<String, OperationDataDefinition> operationMap;
122 if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
123 .containsKey(NOTIFICATIONS.getElementName())) {
124 operationMap = handleOperations(interfaceDefinitionToscaMap);
125 //TODO handle notifications
127 operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
129 if (!operationMap.isEmpty()) {
130 validateOperations(interfaceDefinition.getType(), operationMap, model);
131 interfaceDefinition.setOperations(operationMap);
133 return interfaceDefinition;
136 private void validateOperations(final String interfaceType, final Map<String, OperationDataDefinition> operationMap, final String model) {
137 if (MapUtils.isEmpty(operationMap)) {
140 Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither = interfaceOperationBusinessLogic
141 .getAllInterfaceLifecycleTypes(model);
142 if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
143 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
145 final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
146 final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
147 .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey()
148 .equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst();
149 if (interfaceDefinitionOptional.isEmpty()) {
150 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
152 final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
153 operationMap.keySet().forEach(operation1 -> {
154 if (!interfaceDefinition.hasOperation(operation1)) {
155 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED, operation1, interfaceType);
160 private Map<String, OperationDataDefinition> handleOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
161 if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
162 return Collections.emptyMap();
164 final Map<String, Object> operationMap = (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
165 return operationMap.entrySet().stream()
166 .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
167 .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
170 private Map<String, OperationDataDefinition> handleLegacyOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
171 final List<String> notALegacyOperationEntry = Arrays
172 .asList(OPERATIONS.getElementName(), TYPE.getElementName(), INPUTS.getElementName(), NOTIFICATIONS.getElementName());
173 return interfaceDefinitionToscaMap.entrySet().stream().filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
174 .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
175 .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
178 private OperationDataDefinition createOperation(final String operationName, final Map<String, Object> operationDefinitionMap) {
179 final OperationDataDefinition operation = new OperationDataDefinition();
180 operation.setUniqueId(UUID.randomUUID().toString());
181 operation.setName(operationName);
183 if (MapUtils.isEmpty(operationDefinitionMap)) {
186 Object operationDescription = operationDefinitionMap.get(DESCRIPTION.getElementName());
187 if (null != operationDescription) {
188 operation.setDescription(operationDescription.toString());
190 operation.setImplementation(handleOperationImplementation(operationDefinitionMap).orElse(new ArtifactDataDefinition()));
191 if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
192 final Map<String, Object> interfaceInputs = (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
193 operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
195 if (operationDefinitionMap.containsKey(MILESTONES.getElementName())) {
196 final Map<String, Object> interfaceMilestones = (Map<String, Object>) operationDefinitionMap.get(MILESTONES.getElementName());
197 operation.setMilestones(handleInterfaceOperationMilestones(interfaceMilestones));
202 public Map<String, MilestoneDataDefinition> handleInterfaceOperationMilestones(final Map<String, Object> interfaceMilestones) {
203 final Map<String, MilestoneDataDefinition> milestones = new HashMap<>();
204 for (final Entry<String, Object> interfaceInput : interfaceMilestones.entrySet()) {
205 final MilestoneDataDefinition operationMilestone = new MilestoneDataDefinition();
206 ListDataDefinition<ActivityDataDefinition> activities = handleMilestoneActivities(interfaceInput.getValue());
207 if (activities.isEmpty()) {
208 throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, interfaceInput.getKey());
210 ListDataDefinition<FilterDataDefinition> filters = handleMilestoneFilters(interfaceInput.getValue());
211 if (!filters.isEmpty()) {
212 operationMilestone.setFilters(filters);
214 operationMilestone.setActivities(activities);
215 milestones.put(interfaceInput.getKey(), operationMilestone);
220 private ListDataDefinition<FilterDataDefinition> handleMilestoneFilters(Object milestone) {
221 ListDataDefinition<FilterDataDefinition> filters = new ListDataDefinition<>();
222 if (milestone instanceof Map) {
223 final LinkedHashMap<String, Object> milestoneValue = (LinkedHashMap<String, Object>) milestone;
224 if (milestoneValue.containsKey(FILTERS.getElementName())) {
225 final List<Object> milestoneFilters = (List<Object>) milestoneValue.get(FILTERS.getElementName());
226 for (Object filtersValues : milestoneFilters) {
227 if (filtersValues instanceof Map) {
228 FilterDataDefinition filter = new FilterDataDefinition();
229 Map<String, Object> filterMap = (Map<String, Object>) filtersValues;
231 Optional<Entry<String, Object>> filterOptional =
232 filterMap.entrySet().stream().filter(entrySet -> entrySet.getValue() instanceof Map).findAny();
233 if (filterOptional.isEmpty()) {
236 Entry<String, Object> filterValue = filterOptional.get();
237 if (!(filterValue.getValue() instanceof Map)) {
240 Map<String, Object> valueMap = (Map<String, Object>) filterValue.getValue();
241 Optional<String> constraintTypeOptional =
242 valueMap.keySet().stream().filter(key -> ConstraintType.findByType(key).isPresent()).findAny();
243 if (constraintTypeOptional.isEmpty()) {
246 String constraintType = constraintTypeOptional.get();
247 filter.setName(filterValue.getKey());
248 filter.setConstraint(constraintType);
249 Object value = valueMap.get(constraintType);
250 if (value instanceof Map) {
251 Map<String, Object> valueAsMap = (Map<String, Object>) value;
252 Optional<String> toscaFunctionTypeOptional =
253 valueAsMap.keySet().stream().filter(key -> ToscaFunctionType.findType(key).isPresent()).findAny();
254 if (toscaFunctionTypeOptional.isPresent()) {
255 Optional<ToscaFunction> toscaValue = createToscaFunctionFromLegacyConstraintValue(valueAsMap);
256 if (toscaValue.isPresent()) {
257 filter.setToscaFunction(toscaValue.get());
261 filter.setFilterValue(value);
264 return new ListDataDefinition<>();
268 return new ListDataDefinition<>();
274 private ListDataDefinition<ActivityDataDefinition> handleMilestoneActivities(final Object value) {
275 ListDataDefinition<ActivityDataDefinition> activities = new ListDataDefinition<>();
276 if (value instanceof Map) {
277 final LinkedHashMap<String, Object> activitiesValue = (LinkedHashMap<String, Object>) value;
278 if (activitiesValue.containsKey(ACTIVITIES.getElementName())) {
279 final List<Object> milestoneActivities = (List<Object>) activitiesValue.get(ACTIVITIES.getElementName());
280 for (Object activity : milestoneActivities) {
281 if (activity instanceof Map) {
282 final Map<String, Object> activityMap = (Map<String, Object>) activity;
283 for (Entry<String, Object> activityValue : activityMap.entrySet()) {
284 if (activityValue.getValue() instanceof Map) {
285 ActivityDataDefinition activityDef = new ActivityDataDefinition();
286 Map<String, Object> activityValueMap = (Map<String, Object>) activityValue.getValue();
287 if (activityValueMap.containsKey(INPUTS.getElementName())) {
288 activityDef.setInputs(
289 handleActivityInterfaceOperationInputs((Map<String, Object>) activityValueMap.get(INPUTS.getElementName())));
291 if (ActivityTypeEnum.getEnum(activityValue.getKey()).isPresent() &&
292 activityValueMap.containsKey(WORKFLOW.getElementName())) {
293 activityDef.setWorkflow((String) activityValueMap.get(WORKFLOW.getElementName()));
294 activityDef.setType(activityValue.getKey());
295 activities.add(activityDef);
297 return new ListDataDefinition<>();
300 return new ListDataDefinition<>();
306 return new ListDataDefinition<>();
312 private ListDataDefinition<OperationInputDefinition> handleActivityInterfaceOperationInputs(Map<String, Object> activityInputs) {
313 final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
314 final String defaultType = "tosca.dataTypes.tmf.milestoneJeopardyData";
315 for (final Entry<String, Object> interfaceInput : activityInputs.entrySet()) {
316 if (isMilestoneJeopardyData(interfaceInput.getValue())) {
317 final OperationInputDefinition operationInput = new OperationInputDefinition();
318 operationInput.setUniqueId(UUID.randomUUID().toString());
319 operationInput.setInputId(operationInput.getUniqueId());
320 operationInput.setName(interfaceInput.getKey());
321 operationInput.setType(defaultType);
322 operationInput.setValue(new Gson().toJson(interfaceInput.getValue()));
323 inputs.add(operationInput);
329 private boolean isMilestoneJeopardyData(Object value) {
330 if (value instanceof Map) {
331 Set<String> allowedKeys = new HashSet<>();
332 allowedKeys.add("jeopardyType");
333 allowedKeys.add("name");
334 allowedKeys.add("eventType");
335 allowedKeys.add("message");
337 Map<String, Object> valueMap = (Map<String, Object>) value;
338 return allowedKeys.containsAll(valueMap.keySet());
343 private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
344 final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
345 for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
346 final OperationInputDefinition operationInput = new OperationInputDefinition();
347 operationInput.setUniqueId(UUID.randomUUID().toString());
348 operationInput.setInputId(operationInput.getUniqueId());
349 operationInput.setName(interfaceInput.getKey());
350 handleInputToscaDefinition(interfaceInput.getKey(), interfaceInput.getValue(), operationInput);
351 inputs.add(operationInput);
356 private void handleInputToscaDefinition(final String inputName, final Object value, final OperationInputDefinition operationInput) {
357 if (value instanceof Map) {
358 final LinkedHashMap<String, Object> inputPropertyValue = (LinkedHashMap<String, Object>) value;
359 LOGGER.debug("Creating interface operation input '{}'", inputName);
360 if (inputPropertyValue.get(TYPE.getElementName()) != null) {
361 final String type = inputPropertyValue.get(TYPE.getElementName()).toString();
362 LOGGER.debug(WITH_ATTRIBUTE, TYPE.getElementName(), type);
363 operationInput.setType(type);
365 if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
366 final String description = inputPropertyValue.get(DESCRIPTION.getElementName()).toString();
367 LOGGER.debug(WITH_ATTRIBUTE, DESCRIPTION.getElementName(), description);
368 operationInput.setDescription(description);
370 if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
371 final boolean required = Boolean.parseBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString());
372 LOGGER.debug(WITH_ATTRIBUTE, REQUIRED.getElementName(), required);
373 operationInput.setRequired(required);
375 if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
376 final Gson gson = new Gson();
377 final String json = gson.toJson(inputPropertyValue.get(DEFAULT.getElementName()));
378 LOGGER.debug(WITH_ATTRIBUTE, DEFAULT.getElementName(), json);
379 operationInput.setToscaDefaultValue(json);
381 if (inputPropertyValue.get(VALUE.getElementName()) != null) {
382 final Gson gson = new Gson();
383 final String json = gson.toJson(inputPropertyValue.get(VALUE.getElementName()));
384 operationInput.setValue(json);
386 if (inputPropertyValue.get(STATUS.getElementName()) != null) {
387 final String status = inputPropertyValue.get(STATUS.getElementName()).toString();
388 LOGGER.debug(WITH_ATTRIBUTE, STATUS.getElementName(), status);
389 operationInput.setStatus(status);
393 if (value instanceof String) {
394 final String stringValue = (String) value;
395 operationInput.setDefaultValue(stringValue);
396 operationInput.setToscaDefaultValue(stringValue);
397 operationInput.setValue(stringValue);
401 @SuppressWarnings("unchecked")
402 private Optional<ArtifactDataDefinition> handleOperationImplementation(final Map<String, Object> operationDefinitionMap) {
403 if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
404 return Optional.empty();
406 final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
407 if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
408 ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) {
409 Map<String, Object> implDetails = (Map) ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary");
411 if (implDetails.get("file") != null) {
412 final String file = implDetails.get("file").toString();
413 artifactDataDefinition.setArtifactName(generateArtifactName(file));
415 if (implDetails.get("type") != null) {
416 artifactDataDefinition.setArtifactType(implDetails.get("type").toString());
418 if (implDetails.get("artifact_version") != null) {
419 artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString());
422 if (implDetails.get("properties") instanceof Map) {
423 List<PropertyDataDefinition> operationProperties =
424 artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties();
425 Map<String, Object> properties = (Map<String, Object>) implDetails.get("properties");
426 properties.forEach((k, v) -> {
427 ToscaPropertyType type = getTypeFromObject(v);
429 PropertyDataDefinition propertyDef = new PropertyDataDefinition();
430 propertyDef.setName(k);
431 propertyDef.setType(type.getType());
432 propertyDef.setValue(v.toString());
433 if (type.equals(ToscaPropertyType.LIST)) {
434 Gson gson = new Gson();
435 propertyDef.setValue(gson.toJson(v));
436 PropertyDataDefinition pdd = new PropertyDataDefinition();
437 pdd.setType("string");
438 SchemaDefinition sd = new SchemaDefinition();
440 propertyDef.setSchema(sd);
442 artifactDataDefinition.addProperty(propertyDef);
448 if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
449 ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("timeout")) {
450 final Object timeOut = ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("timeout");
451 artifactDataDefinition.setTimeout((Integer) timeOut);
454 if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) {
455 final String implementation = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
456 artifactDataDefinition.setArtifactName(generateArtifactName(implementation));
458 return Optional.of(artifactDataDefinition);
461 private String generateArtifactName(final String name) {
462 if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) {
465 return QUOTE + name + QUOTE;
469 private ToscaPropertyType getTypeFromObject(final Object value) {
470 if (value instanceof String) {
471 return ToscaPropertyType.STRING;
473 if (value instanceof Integer) {
474 return ToscaPropertyType.INTEGER;
476 if (value instanceof Boolean) {
477 return ToscaPropertyType.BOOLEAN;
479 if (value instanceof Float || value instanceof Double) {
480 return ToscaPropertyType.FLOAT;
482 if (value instanceof List) {
483 return ToscaPropertyType.LIST;
489 private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
490 if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
491 return Collections.emptyMap();
493 final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither = ImportUtils.getInputs(interfaceDefinitionToscaMap);
494 if (inputMapEither.isRight()) {
495 return Collections.emptyMap();
497 return inputMapEither.left().value();