catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java

   1 /*
   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
   8  *
   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.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  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;
  38
  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.LinkedHashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Map.Entry;
  49 import java.util.Optional;
  50 import java.util.UUID;
  51 import java.util.stream.Collectors;
  52 import org.apache.commons.collections.MapUtils;
  53 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  54 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  55 import org.openecomp.sdc.be.dao.api.ActionStatus;
  56 import org.openecomp.sdc.be.datatypes.elements.ActivityDataDefinition;
  57 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  58 import org.openecomp.sdc.be.datatypes.elements.FilterDataDefinition;
  59 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
  60 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  61 import org.openecomp.sdc.be.datatypes.elements.MilestoneDataDefinition;
  62 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  63 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  64 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  65 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  66 import org.openecomp.sdc.be.datatypes.elements.ToscaFunction;
  67 import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType;
  68 import org.openecomp.sdc.be.datatypes.enums.ConstraintType;
  69 import org.openecomp.sdc.be.model.InputDefinition;
  70 import org.openecomp.sdc.be.model.InterfaceDefinition;
  71 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  72 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  73 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
  74 import org.openecomp.sdc.exception.ResponseFormat;
  75 import org.slf4j.Logger;
  76 import org.slf4j.LoggerFactory;
  77 import org.springframework.stereotype.Component;
  78
  79 /**
  80  * Handles interface definition TOSCA conversions
  81  */
  82 @Component("interfaceDefinitionHandler")
  83 public class InterfaceDefinitionHandler {
  84
  85     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
  86     private static final String WITH_ATTRIBUTE = "with attribute '{}': '{}'";
  87     private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
  88
  89     public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
  90         this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
  91     }
  92
  93     /**
  94      * Creates an interface definition based on a TOSCA map representing an interface definition.
  95      *
  96      * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
  97      * @return an interface definition representation
  98      */
  99     public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap, final String model) {
 100         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 101         interfaceDefinition.setModel(model);
 102         if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
 103             final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
 104             if (!(typeObj instanceof String)) {
 105                 throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
 106             }
 107             final String type = (String) typeObj;
 108             interfaceDefinition.setType(type);
 109             interfaceDefinition.setUniqueId(type);
 110         }
 111         final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
 112         if (!inputDefinitionMap.isEmpty()) {
 113             final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream()
 114                 .collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
 115             interfaceDefinition.setInputs(collect);
 116         }
 117         final Map<String, OperationDataDefinition> operationMap;
 118         if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
 119             .containsKey(NOTIFICATIONS.getElementName())) {
 120             operationMap = handleOperations(interfaceDefinitionToscaMap);
 121             //TODO handle notifications
 122         } else {
 123             operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
 124         }
 125         if (!operationMap.isEmpty()) {
 126             validateOperations(interfaceDefinition.getType(), operationMap, model);
 127             interfaceDefinition.setOperations(operationMap);
 128         }
 129         return interfaceDefinition;
 130     }
 131
 132     private void validateOperations(final String interfaceType, final Map<String, OperationDataDefinition> operationMap, final String model) {
 133         if (MapUtils.isEmpty(operationMap)) {
 134             return;
 135         }
 136         Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither = interfaceOperationBusinessLogic
 137             .getAllInterfaceLifecycleTypes(model);
 138         if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
 139             throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
 140         }
 141         final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
 142         final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
 143             .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey()
 144                 .equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst();
 145         if (interfaceDefinitionOptional.isEmpty()) {
 146             throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
 147         }
 148         final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
 149         operationMap.keySet().forEach(operation1 -> {
 150             if (!interfaceDefinition.hasOperation(operation1)) {
 151                 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED, operation1, interfaceType);
 152             }
 153         });
 154     }
 155
 156     private Map<String, OperationDataDefinition> handleOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
 157         if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
 158             return Collections.emptyMap();
 159         }
 160         final Map<String, Object> operationMap = (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
 161         return operationMap.entrySet().stream()
 162             .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
 163             .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
 164     }
 165
 166     private Map<String, OperationDataDefinition> handleLegacyOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
 167         final List<String> notALegacyOperationEntry = Arrays
 168             .asList(OPERATIONS.getElementName(), TYPE.getElementName(), INPUTS.getElementName(), NOTIFICATIONS.getElementName());
 169         return interfaceDefinitionToscaMap.entrySet().stream().filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
 170             .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
 171             .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
 172     }
 173
 174     private OperationDataDefinition createOperation(final String operationName, final Map<String, Object> operationDefinitionMap) {
 175         final OperationDataDefinition operation = new OperationDataDefinition();
 176         operation.setUniqueId(UUID.randomUUID().toString());
 177         operation.setName(operationName);
 178
 179         if (MapUtils.isEmpty(operationDefinitionMap)) {
 180             return operation;
 181         }
 182         Object operationDescription = operationDefinitionMap.get(DESCRIPTION.getElementName());
 183         if (null != operationDescription) {
 184             operation.setDescription(operationDescription.toString());
 185         }
 186         operation.setImplementation(handleOperationImplementation(operationDefinitionMap).orElse(new ArtifactDataDefinition()));
 187         if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
 188             final Map<String, Object> interfaceInputs = (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
 189             operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
 190         }
 191         if (operationDefinitionMap.containsKey(MILESTONES.getElementName())) {
 192             final Map<String, Object> interfaceMilestones = (Map<String, Object>) operationDefinitionMap.get(MILESTONES.getElementName());
 193             operation.setMilestones(handleInterfaceOperationMilestones(interfaceMilestones));
 194         }
 195         return operation;
 196     }
 197
 198     private Map<String, MilestoneDataDefinition> handleInterfaceOperationMilestones(final Map<String, Object> interfaceMilestones) {
 199         final Map<String, MilestoneDataDefinition> milestones = new HashMap<>();
 200         for (final Entry<String, Object> interfaceInput : interfaceMilestones.entrySet()) {
 201             final MilestoneDataDefinition operationMilestone = new MilestoneDataDefinition();
 202             ListDataDefinition<ActivityDataDefinition> activities = handleMilestoneActivities(interfaceInput.getValue());
 203             if (activities.isEmpty()) {
 204                 throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, interfaceInput.getKey());
 205             }
 206             ListDataDefinition<FilterDataDefinition> filters = handleMilestoneFilters(interfaceInput.getValue());
 207             if (!filters.isEmpty()) {
 208                 operationMilestone.setFilters(filters);
 209             }
 210             operationMilestone.setActivities(activities);
 211             milestones.put(interfaceInput.getKey(), operationMilestone);
 212         }
 213         return milestones;
 214     }
 215
 216     private ListDataDefinition<FilterDataDefinition> handleMilestoneFilters(Object milestone) {
 217         ListDataDefinition<FilterDataDefinition> filters = new ListDataDefinition<>();
 218         if (milestone instanceof Map) {
 219             final LinkedHashMap<String, Object> milestoneValue = (LinkedHashMap<String, Object>) milestone;
 220             if (milestoneValue.containsKey(FILTERS.getElementName())) {
 221                 final List<Object> milestoneFilters = (List<Object>) milestoneValue.get(FILTERS.getElementName());
 222                 for (Object filtersValues : milestoneFilters) {
 223                     if (filtersValues instanceof Map) {
 224                         FilterDataDefinition filter = new FilterDataDefinition();
 225                         Map<String, Object> filterMap = (Map<String, Object>) filtersValues;
 226
 227                         Optional<Entry<String, Object>> filterOptional =
 228                             filterMap.entrySet().stream().filter(entrySet -> entrySet.getValue() instanceof Map).findAny();
 229                         if (filterOptional.isEmpty()) {
 230                             continue;
 231                         }
 232                         Entry<String, Object> filterValue = filterOptional.get();
 233                         if (!(filterValue.getValue() instanceof Map)) {
 234                             continue;
 235                         }
 236                         Map<String, Object> valueMap = (Map<String, Object>) filterValue.getValue();
 237                         Optional<String> constraintTypeOptional =
 238                             valueMap.keySet().stream().filter(key -> ConstraintType.findByType(key).isPresent()).findAny();
 239                         if (constraintTypeOptional.isEmpty()) {
 240                             continue;
 241                         }
 242                         String constraintType = constraintTypeOptional.get();
 243                         filter.setName(filterValue.getKey());
 244                         filter.setConstraint(constraintType);
 245                         Object value = valueMap.get(constraintType);
 246                         if (value instanceof Map) {
 247                             Map<String, Object> valueAsMap = (Map<String, Object>) value;
 248                             Optional<String> toscaFunctionTypeOptional =
 249                                 valueAsMap.keySet().stream().filter(key -> ToscaFunctionType.findType(key).isPresent()).findAny();
 250                             if (toscaFunctionTypeOptional.isPresent()) {
 251                                 Optional<ToscaFunction> toscaValue = createToscaFunctionFromLegacyConstraintValue(valueAsMap);
 252                                 if (toscaValue.isPresent()) {
 253                                     filter.setToscaFunction(toscaValue.get());
 254                                 }
 255                             }
 256                         }
 257                         filter.setFilterValue(value);
 258                         filters.add(filter);
 259                     } else {
 260                         return new ListDataDefinition<>();
 261                     }
 262                 }
 263             } else {
 264                 return new ListDataDefinition<>();
 265             }
 266         }
 267         return filters;
 268     }
 269
 270     private ListDataDefinition<ActivityDataDefinition> handleMilestoneActivities(final Object value) {
 271         ListDataDefinition<ActivityDataDefinition> activities = new ListDataDefinition<>();
 272         if (value instanceof Map) {
 273             final LinkedHashMap<String, Object> activitiesValue = (LinkedHashMap<String, Object>) value;
 274             if (activitiesValue.containsKey(ACTIVITIES.getElementName())) {
 275                 final List<Object> milestoneActivities = (List<Object>) activitiesValue.get(ACTIVITIES.getElementName());
 276                 for (Object activityValue : milestoneActivities) {
 277                     ActivityDataDefinition activity = new ActivityDataDefinition();
 278                     if (activityValue instanceof Map) {
 279                         Map<String, Object> activityMap = (Map<String, Object>) activityValue;
 280                         if (activityMap.containsKey(INPUTS.getElementName())) {
 281                             activity.setInputs(handleInterfaceOperationInputs((Map<String, Object>) activityMap.get(INPUTS.getElementName())));
 282                         }
 283                         if (activityMap.containsKey(TYPE.getElementName()) && activityMap.containsKey(WORKFLOW.getElementName())) {
 284                             activity.setType((String) activityMap.get(TYPE.getElementName()));
 285                             activity.setWorkflow((String) activityMap.get(WORKFLOW.getElementName()));
 286                             activities.add(activity);
 287                         } else {
 288                             return new ListDataDefinition<>();
 289                         }
 290                     } else {
 291                         return new ListDataDefinition<>();
 292                     }
 293                 }
 294             } else {
 295                 return new ListDataDefinition<>();
 296             }
 297         }
 298         return activities;
 299     }
 300
 301     private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
 302         final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
 303         for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
 304             final OperationInputDefinition operationInput = new OperationInputDefinition();
 305             operationInput.setUniqueId(UUID.randomUUID().toString());
 306             operationInput.setInputId(operationInput.getUniqueId());
 307             operationInput.setName(interfaceInput.getKey());
 308             handleInputToscaDefinition(interfaceInput.getKey(), interfaceInput.getValue(), operationInput);
 309             inputs.add(operationInput);
 310         }
 311         return inputs;
 312     }
 313
 314     private void handleInputToscaDefinition(final String inputName, final Object value, final OperationInputDefinition operationInput) {
 315         if (value instanceof Map) {
 316             final LinkedHashMap<String, Object> inputPropertyValue = (LinkedHashMap<String, Object>) value;
 317             LOGGER.debug("Creating interface operation input '{}'", inputName);
 318             if (inputPropertyValue.get(TYPE.getElementName()) != null) {
 319                 final String type = inputPropertyValue.get(TYPE.getElementName()).toString();
 320                 LOGGER.debug(WITH_ATTRIBUTE, TYPE.getElementName(), type);
 321                 operationInput.setType(type);
 322             }
 323             if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
 324                 final String description = inputPropertyValue.get(DESCRIPTION.getElementName()).toString();
 325                 LOGGER.debug(WITH_ATTRIBUTE, DESCRIPTION.getElementName(), description);
 326                 operationInput.setDescription(description);
 327             }
 328             if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
 329                 final boolean required = Boolean.parseBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString());
 330                 LOGGER.debug(WITH_ATTRIBUTE, REQUIRED.getElementName(), required);
 331                 operationInput.setRequired(required);
 332             }
 333             if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
 334                 final Gson gson = new Gson();
 335                 final String json = gson.toJson(inputPropertyValue.get(DEFAULT.getElementName()));
 336                 LOGGER.debug(WITH_ATTRIBUTE, DEFAULT.getElementName(), json);
 337                 operationInput.setToscaDefaultValue(json);
 338             }
 339             if (inputPropertyValue.get(VALUE.getElementName()) != null) {
 340                 final Gson gson = new Gson();
 341                 final String json = gson.toJson(inputPropertyValue.get(VALUE.getElementName()));
 342                 operationInput.setValue(json);
 343             }
 344             if (inputPropertyValue.get(STATUS.getElementName()) != null) {
 345                 final String status = inputPropertyValue.get(STATUS.getElementName()).toString();
 346                 LOGGER.debug(WITH_ATTRIBUTE, STATUS.getElementName(), status);
 347                 operationInput.setStatus(status);
 348             }
 349             return;
 350         }
 351         if (value instanceof String) {
 352             final String stringValue = (String) value;
 353             operationInput.setDefaultValue(stringValue);
 354             operationInput.setToscaDefaultValue(stringValue);
 355             operationInput.setValue(stringValue);
 356         }
 357     }
 358
 359     @SuppressWarnings("unchecked")
 360     private Optional<ArtifactDataDefinition> handleOperationImplementation(final Map<String, Object> operationDefinitionMap) {
 361         if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
 362             return Optional.empty();
 363         }
 364         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 365         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
 366             ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) {
 367             Map<String, Object> implDetails = (Map) ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary");
 368
 369             if (implDetails.get("file") != null) {
 370                 final String file = implDetails.get("file").toString();
 371                 artifactDataDefinition.setArtifactName(generateArtifactName(file));
 372             }
 373             if (implDetails.get("type") != null) {
 374                 artifactDataDefinition.setArtifactType(implDetails.get("type").toString());
 375             }
 376             if (implDetails.get("artifact_version") != null) {
 377                 artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString());
 378             }
 379
 380             if (implDetails.get("properties") instanceof Map) {
 381                 List<PropertyDataDefinition> operationProperties =
 382                     artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties();
 383                 Map<String, Object> properties = (Map<String, Object>) implDetails.get("properties");
 384                 properties.forEach((k, v) -> {
 385                     ToscaPropertyType type = getTypeFromObject(v);
 386                     if (type != null) {
 387                         PropertyDataDefinition propertyDef = new PropertyDataDefinition();
 388                         propertyDef.setName(k);
 389                         propertyDef.setType(type.getType());
 390                         propertyDef.setValue(v.toString());
 391                         if (type.equals(ToscaPropertyType.LIST)) {
 392                             Gson gson = new Gson();
 393                             propertyDef.setValue(gson.toJson(v));
 394                             PropertyDataDefinition pdd = new PropertyDataDefinition();
 395                             pdd.setType("string");
 396                             SchemaDefinition sd = new SchemaDefinition();
 397                             sd.setProperty(pdd);
 398                             propertyDef.setSchema(sd);
 399                         }
 400                         artifactDataDefinition.addProperty(propertyDef);
 401                     }
 402                 });
 403             }
 404         }
 405
 406         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
 407             ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("timeout")) {
 408             final Object timeOut = ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("timeout");
 409             artifactDataDefinition.setTimeout((Integer)timeOut);
 410         }
 411
 412         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) {
 413             final String implementation = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
 414             artifactDataDefinition.setArtifactName(generateArtifactName(implementation));
 415         }
 416         return Optional.of(artifactDataDefinition);
 417     }
 418
 419     private String generateArtifactName(final String name) {
 420         if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) {
 421             return name;
 422         } else {
 423             return QUOTE + name + QUOTE;
 424         }
 425     }
 426
 427     private ToscaPropertyType getTypeFromObject(final Object value) {
 428         if (value instanceof String) {
 429             return ToscaPropertyType.STRING;
 430         }
 431         if (value instanceof Integer) {
 432             return ToscaPropertyType.INTEGER;
 433         }
 434         if (value instanceof Boolean) {
 435             return ToscaPropertyType.BOOLEAN;
 436         }
 437         if (value instanceof Float || value instanceof Double) {
 438             return ToscaPropertyType.FLOAT;
 439         }
 440         if (value instanceof List) {
 441             return ToscaPropertyType.LIST;
 442         }
 443         return null;
 444     }
 445
 446
 447     private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
 448         if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
 449             return Collections.emptyMap();
 450         }
 451         final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither = ImportUtils.getInputs(interfaceDefinitionToscaMap);
 452         if (inputMapEither.isRight()) {
 453             return Collections.emptyMap();
 454         }
 455         return inputMapEither.left().value();
 456     }
 457 }