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.HashSet;
  46 import java.util.LinkedHashMap;
  47 import java.util.List;
  48 import java.util.Map;
  49 import java.util.Map.Entry;
  50 import java.util.Objects;
  51 import java.util.Optional;
  52 import java.util.Set;
  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;
  82
  83 /**
  84  * Handles interface definition TOSCA conversions
  85  */
  86 @Component("interfaceDefinitionHandler")
  87 public class InterfaceDefinitionHandler {
  88
  89     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
  90     private static final String WITH_ATTRIBUTE = "with attribute '{}': '{}'";
  91     private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
  92
  93     public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
  94         this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
  95     }
  96
  97     /**
  98      * Creates an interface definition based on a TOSCA map representing an interface definition.
  99      *
 100      * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
 101      * @return an interface definition representation
 102      */
 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);
 110             }
 111             final String type = (String) typeObj;
 112             interfaceDefinition.setType(type);
 113             interfaceDefinition.setUniqueId(type);
 114         }
 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);
 120         }
 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
 126         } else {
 127             operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
 128         }
 129         if (!operationMap.isEmpty()) {
 130             validateOperations(interfaceDefinition.getType(), operationMap, model);
 131             interfaceDefinition.setOperations(operationMap);
 132         }
 133         return interfaceDefinition;
 134     }
 135
 136     private void validateOperations(final String interfaceType, final Map<String, OperationDataDefinition> operationMap, final String model) {
 137         if (MapUtils.isEmpty(operationMap)) {
 138             return;
 139         }
 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);
 144         }
 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);
 151         }
 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);
 156             }
 157         });
 158     }
 159
 160     private Map<String, OperationDataDefinition> handleOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
 161         if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
 162             return Collections.emptyMap();
 163         }
 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));
 168     }
 169
 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));
 176     }
 177
 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);
 182
 183         if (MapUtils.isEmpty(operationDefinitionMap)) {
 184             return operation;
 185         }
 186         Object operationDescription = operationDefinitionMap.get(DESCRIPTION.getElementName());
 187         if (null != operationDescription) {
 188             operation.setDescription(operationDescription.toString());
 189         }
 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));
 194         }
 195         if (operationDefinitionMap.containsKey(MILESTONES.getElementName())) {
 196             final Map<String, Object> interfaceMilestones = (Map<String, Object>) operationDefinitionMap.get(MILESTONES.getElementName());
 197             operation.setMilestones(handleInterfaceOperationMilestones(interfaceMilestones));
 198         }
 199         return operation;
 200     }
 201
 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());
 209             }
 210             ListDataDefinition<FilterDataDefinition> filters = handleMilestoneFilters(interfaceInput.getValue());
 211             if (!filters.isEmpty()) {
 212                 operationMilestone.setFilters(filters);
 213             }
 214             operationMilestone.setActivities(activities);
 215             milestones.put(interfaceInput.getKey(), operationMilestone);
 216         }
 217         return milestones;
 218     }
 219
 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;
 230
 231                         Optional<Entry<String, Object>> filterOptional =
 232                             filterMap.entrySet().stream().filter(entrySet -> entrySet.getValue() instanceof Map).findAny();
 233                         if (filterOptional.isEmpty()) {
 234                             continue;
 235                         }
 236                         Entry<String, Object> filterValue = filterOptional.get();
 237                         if (!(filterValue.getValue() instanceof Map)) {
 238                             continue;
 239                         }
 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()) {
 244                             continue;
 245                         }
 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());
 258                                 }
 259                             }
 260                         }
 261                         filter.setFilterValue(value);
 262                         filters.add(filter);
 263                     } else {
 264                         return new ListDataDefinition<>();
 265                     }
 266                 }
 267             } else {
 268                 return new ListDataDefinition<>();
 269             }
 270         }
 271         return filters;
 272     }
 273
 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())));
 290                                 }
 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);
 296                                 } else {
 297                                     return new ListDataDefinition<>();
 298                                 }
 299                             } else {
 300                                 return new ListDataDefinition<>();
 301                             }
 302                         }
 303                     }
 304                 }
 305             } else {
 306                 return new ListDataDefinition<>();
 307             }
 308         }
 309         return activities;
 310     }
 311
 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);
 324             }
 325         }
 326         return inputs;
 327     }
 328
 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");
 336
 337             Map<String, Object> valueMap = (Map<String, Object>) value;
 338             return allowedKeys.containsAll(valueMap.keySet());
 339         }
 340         return false;
 341     }
 342
 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);
 352         }
 353         return inputs;
 354     }
 355
 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);
 364             }
 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);
 369             }
 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);
 374             }
 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);
 380             }
 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);
 385             }
 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);
 390             }
 391             return;
 392         }
 393         if (value instanceof String) {
 394             final String stringValue = (String) value;
 395             operationInput.setDefaultValue(stringValue);
 396             operationInput.setToscaDefaultValue(stringValue);
 397             operationInput.setValue(stringValue);
 398         }
 399     }
 400
 401     @SuppressWarnings("unchecked")
 402     private Optional<ArtifactDataDefinition> handleOperationImplementation(final Map<String, Object> operationDefinitionMap) {
 403         if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
 404             return Optional.empty();
 405         }
 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");
 410
 411             if (implDetails.get("file") != null) {
 412                 final String file = implDetails.get("file").toString();
 413                 artifactDataDefinition.setArtifactName(generateArtifactName(file));
 414             }
 415             if (implDetails.get("type") != null) {
 416                 artifactDataDefinition.setArtifactType(implDetails.get("type").toString());
 417             }
 418             if (implDetails.get("artifact_version") != null) {
 419                 artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString());
 420             }
 421
 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);
 428                     if (type != null) {
 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();
 439                             sd.setProperty(pdd);
 440                             propertyDef.setSchema(sd);
 441                         }
 442                         artifactDataDefinition.addProperty(propertyDef);
 443                     }
 444                 });
 445             }
 446         }
 447
 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);
 452         }
 453
 454         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) {
 455             final String implementation = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
 456             artifactDataDefinition.setArtifactName(generateArtifactName(implementation));
 457         }
 458         return Optional.of(artifactDataDefinition);
 459     }
 460
 461     private String generateArtifactName(final String name) {
 462         if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) {
 463             return name;
 464         } else {
 465             return QUOTE + name + QUOTE;
 466         }
 467     }
 468
 469     private ToscaPropertyType getTypeFromObject(final Object value) {
 470         if (value instanceof String) {
 471             return ToscaPropertyType.STRING;
 472         }
 473         if (value instanceof Integer) {
 474             return ToscaPropertyType.INTEGER;
 475         }
 476         if (value instanceof Boolean) {
 477             return ToscaPropertyType.BOOLEAN;
 478         }
 479         if (value instanceof Float || value instanceof Double) {
 480             return ToscaPropertyType.FLOAT;
 481         }
 482         if (value instanceof List) {
 483             return ToscaPropertyType.LIST;
 484         }
 485         return null;
 486     }
 487
 488
 489     private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
 490         if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
 491             return Collections.emptyMap();
 492         }
 493         final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither = ImportUtils.getInputs(interfaceDefinitionToscaMap);
 494         if (inputMapEither.isRight()) {
 495             return Collections.emptyMap();
 496         }
 497         return inputMapEither.left().value();
 498     }
 499 }