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