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