X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Fmain%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Fcomponents%2Fimpl%2FInterfaceDefinitionHandler.java;h=b850dfd567b4bc637cdf857116e7c385e87aa6e1;hb=133d8bbc63891a9c169b002c03be9ec27f8bc486;hp=b60e31a513addd0f8786ae09597809f5d24fd385;hpb=69bc5bdb7d464fa38705191f1495fb09474277a8;p=sdc.git diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java index b60e31a513..b850dfd567 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java @@ -16,11 +16,15 @@ * SPDX-License-Identifier: Apache-2.0 * ============LICENSE_END========================================================= */ + package org.openecomp.sdc.be.components.impl; import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE; +import static org.openecomp.sdc.be.utils.PropertyFilterConstraintDataDefinitionHelper.createToscaFunctionFromLegacyConstraintValue; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.ACTIVITIES; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.FILTERS; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IMPLEMENTATION; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS; @@ -28,29 +32,43 @@ import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS; import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.VALUE; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.WORKFLOW; import com.google.gson.Gson; import fj.data.Either; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.stream.Collectors; import org.apache.commons.collections.MapUtils; import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum; import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException; import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.elements.ActivityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.FilterDataDefinition; import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MilestoneDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; +import org.openecomp.sdc.be.datatypes.elements.ToscaFunction; +import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType; +import org.openecomp.sdc.be.datatypes.enums.ActivityTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; +import org.openecomp.sdc.be.datatypes.enums.MilestoneTypeEnum; import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; @@ -125,7 +143,8 @@ public class InterfaceDefinitionHandler { } final Map interfaceDefinitionMap = interfaceDefinitionMapEither.left().value(); final Optional interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream() - .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey().equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst(); + .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey() + .equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst(); if (interfaceDefinitionOptional.isEmpty()) { throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType); } @@ -159,14 +178,176 @@ public class InterfaceDefinitionHandler { final OperationDataDefinition operation = new OperationDataDefinition(); operation.setUniqueId(UUID.randomUUID().toString()); operation.setName(operationName); + + if (MapUtils.isEmpty(operationDefinitionMap)) { + return operation; + } + Object operationDescription = operationDefinitionMap.get(DESCRIPTION.getElementName()); + if (null != operationDescription) { + operation.setDescription(operationDescription.toString()); + } operation.setImplementation(handleOperationImplementation(operationDefinitionMap).orElse(new ArtifactDataDefinition())); if (operationDefinitionMap.containsKey(INPUTS.getElementName())) { final Map interfaceInputs = (Map) operationDefinitionMap.get(INPUTS.getElementName()); operation.setInputs(handleInterfaceOperationInputs(interfaceInputs)); } + for (MilestoneTypeEnum milestone : MilestoneTypeEnum.values()) { + String milestoneType = milestone.getValue(); + if (operationDefinitionMap.containsKey(milestone.getValue())) { + final Map interfaceMilestones = (Map) operationDefinitionMap.get(milestoneType); + if (operation.getMilestones() == null || operation.getMilestones().isEmpty()) { + operation.setMilestones(new HashMap<>()); + operation.getMilestones().put(milestoneType, handleInterfaceOperationMilestones(interfaceMilestones, milestoneType)); + continue; + } + operation.getMilestones().put(milestoneType, handleInterfaceOperationMilestones(interfaceMilestones, milestoneType)); + } + } return operation; } + public MilestoneDataDefinition handleInterfaceOperationMilestones(final Map interfaceMilestones, String key) { + final MilestoneDataDefinition operationMilestone = new MilestoneDataDefinition(); + if (interfaceMilestones != null && !interfaceMilestones.containsKey(ACTIVITIES.getElementName())) { + throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, key); + } + ListDataDefinition activities = handleMilestoneActivities(interfaceMilestones); + if (activities.isEmpty()) { + throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, key); + } + if (interfaceMilestones.containsKey(FILTERS.getElementName())) { + ListDataDefinition filters = handleMilestoneFilters(interfaceMilestones); + if (!filters.isEmpty()) { + operationMilestone.setFilters(filters); + } + } + operationMilestone.setActivities(activities); + return operationMilestone; + } + + private ListDataDefinition handleMilestoneFilters(Object milestone) { + ListDataDefinition filters = new ListDataDefinition<>(); + if (milestone instanceof Map) { + final LinkedHashMap milestoneValue = (LinkedHashMap) milestone; + if (milestoneValue.containsKey(FILTERS.getElementName())) { + final List milestoneFilters = (List) milestoneValue.get(FILTERS.getElementName()); + for (Object filtersValues : milestoneFilters) { + if (filtersValues instanceof Map) { + FilterDataDefinition filter = new FilterDataDefinition(); + Map filterMap = (Map) filtersValues; + + Optional> filterOptional = + filterMap.entrySet().stream().filter(entrySet -> entrySet.getValue() instanceof Map).findAny(); + if (filterOptional.isEmpty()) { + continue; + } + Entry filterValue = filterOptional.get(); + if (!(filterValue.getValue() instanceof Map)) { + continue; + } + Map valueMap = (Map) filterValue.getValue(); + Optional constraintTypeOptional = + valueMap.keySet().stream().filter(key -> ConstraintType.findByType(key).isPresent()).findAny(); + if (constraintTypeOptional.isEmpty()) { + continue; + } + String constraintType = constraintTypeOptional.get(); + filter.setName(filterValue.getKey()); + filter.setConstraint(constraintType); + Object value = valueMap.get(constraintType); + if (value instanceof Map) { + Map valueAsMap = (Map) value; + Optional toscaFunctionTypeOptional = + valueAsMap.keySet().stream().filter(key -> ToscaFunctionType.findType(key).isPresent()).findAny(); + if (toscaFunctionTypeOptional.isPresent()) { + Optional toscaValue = createToscaFunctionFromLegacyConstraintValue(valueAsMap); + if (toscaValue.isPresent()) { + filter.setToscaFunction(toscaValue.get()); + } + } + } + filter.setFilterValue(value); + filters.add(filter); + } else { + return new ListDataDefinition<>(); + } + } + } else { + return new ListDataDefinition<>(); + } + } + return filters; + } + + private ListDataDefinition handleMilestoneActivities(final Object value) { + ListDataDefinition activities = new ListDataDefinition<>(); + if (value instanceof Map) { + final LinkedHashMap activitiesValue = (LinkedHashMap) value; + if (activitiesValue.containsKey(ACTIVITIES.getElementName())) { + final List milestoneActivities = (List) activitiesValue.get(ACTIVITIES.getElementName()); + for (Object activity : milestoneActivities) { + if (activity instanceof Map) { + final Map activityMap = (Map) activity; + for (Entry activityValue : activityMap.entrySet()) { + if (activityValue.getValue() instanceof Map) { + ActivityDataDefinition activityDef = new ActivityDataDefinition(); + Map activityValueMap = (Map) activityValue.getValue(); + if (activityValueMap.containsKey(INPUTS.getElementName())) { + activityDef.setInputs( + handleActivityInterfaceOperationInputs((Map) activityValueMap.get(INPUTS.getElementName()))); + } + if (ActivityTypeEnum.getEnum(activityValue.getKey()).isPresent() && + activityValueMap.containsKey(WORKFLOW.getElementName())) { + activityDef.setWorkflow((String) activityValueMap.get(WORKFLOW.getElementName())); + activityDef.setType(activityValue.getKey()); + activities.add(activityDef); + } else { + return new ListDataDefinition<>(); + } + } else { + return new ListDataDefinition<>(); + } + } + } + } + } else { + return new ListDataDefinition<>(); + } + } + return activities; + } + + private ListDataDefinition handleActivityInterfaceOperationInputs(Map activityInputs) { + final ListDataDefinition inputs = new ListDataDefinition<>(); + final String defaultType = "tosca.dataTypes.tmf.milestoneJeopardyData"; + for (final Entry interfaceInput : activityInputs.entrySet()) { + if (isMilestoneJeopardyData(interfaceInput.getValue())) { + final OperationInputDefinition operationInput = new OperationInputDefinition(); + operationInput.setUniqueId(UUID.randomUUID().toString()); + operationInput.setInputId(operationInput.getUniqueId()); + operationInput.setName(interfaceInput.getKey()); + operationInput.setType(defaultType); + operationInput.setValue(new Gson().toJson(interfaceInput.getValue())); + inputs.add(operationInput); + } + } + return inputs; + } + + private boolean isMilestoneJeopardyData(Object value) { + if (value instanceof Map) { + Set allowedKeys = new HashSet<>(); + allowedKeys.add("jeopardyType"); + allowedKeys.add("name"); + allowedKeys.add("eventType"); + allowedKeys.add("message"); + + Map valueMap = (Map) value; + return allowedKeys.containsAll(valueMap.keySet()); + } + return false; + } + private ListDataDefinition handleInterfaceOperationInputs(final Map interfaceInputs) { final ListDataDefinition inputs = new ListDataDefinition<>(); for (final Entry interfaceInput : interfaceInputs.entrySet()) { @@ -205,6 +386,11 @@ public class InterfaceDefinitionHandler { LOGGER.debug(WITH_ATTRIBUTE, DEFAULT.getElementName(), json); operationInput.setToscaDefaultValue(json); } + if (inputPropertyValue.get(VALUE.getElementName()) != null) { + final Gson gson = new Gson(); + final String json = gson.toJson(inputPropertyValue.get(VALUE.getElementName())); + operationInput.setValue(json); + } if (inputPropertyValue.get(STATUS.getElementName()) != null) { final String status = inputPropertyValue.get(STATUS.getElementName()).toString(); LOGGER.debug(WITH_ATTRIBUTE, STATUS.getElementName(), status); @@ -226,12 +412,13 @@ public class InterfaceDefinitionHandler { return Optional.empty(); } final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition(); - if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map && - ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) { - Map implDetails = (Map) ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary"); - + if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map && + ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) { + Map implDetails = (Map) ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary"); + if (implDetails.get("file") != null) { - artifactDataDefinition.setArtifactName(implDetails.get("file").toString()); + final String file = implDetails.get("file").toString(); + artifactDataDefinition.setArtifactName(generateArtifactName(file)); } if (implDetails.get("type") != null) { artifactDataDefinition.setArtifactType(implDetails.get("type").toString()); @@ -239,33 +426,54 @@ public class InterfaceDefinitionHandler { if (implDetails.get("artifact_version") != null) { artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString()); } - - if(implDetails.get("properties") instanceof Map) { - List operationProperties = artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties(); + + if (implDetails.get("properties") instanceof Map) { + List operationProperties = + artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties(); Map properties = (Map) implDetails.get("properties"); - properties.forEach((k,v) -> { + properties.forEach((k, v) -> { ToscaPropertyType type = getTypeFromObject(v); if (type != null) { PropertyDataDefinition propertyDef = new PropertyDataDefinition(); propertyDef.setName(k); propertyDef.setType(type.getType()); propertyDef.setValue(v.toString()); + if (type.equals(ToscaPropertyType.LIST)) { + Gson gson = new Gson(); + propertyDef.setValue(gson.toJson(v)); + PropertyDataDefinition pdd = new PropertyDataDefinition(); + pdd.setType("string"); + SchemaDefinition sd = new SchemaDefinition(); + sd.setProperty(pdd); + propertyDef.setSchema(sd); + } artifactDataDefinition.addProperty(propertyDef); } }); } } + + if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map && + ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("timeout")) { + final Object timeOut = ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("timeout"); + artifactDataDefinition.setTimeout((Integer) timeOut); + } + if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) { - final String artifactName = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName()); - if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) { - artifactDataDefinition.setArtifactName(artifactName); - } else { - artifactDataDefinition.setArtifactName(QUOTE + artifactName + QUOTE); - } + final String implementation = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName()); + artifactDataDefinition.setArtifactName(generateArtifactName(implementation)); } return Optional.of(artifactDataDefinition); } - + + private String generateArtifactName(final String name) { + if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) { + return name; + } else { + return QUOTE + name + QUOTE; + } + } + private ToscaPropertyType getTypeFromObject(final Object value) { if (value instanceof String) { return ToscaPropertyType.STRING; @@ -279,9 +487,12 @@ public class InterfaceDefinitionHandler { if (value instanceof Float || value instanceof Double) { return ToscaPropertyType.FLOAT; } + if (value instanceof List) { + return ToscaPropertyType.LIST; + } return null; } - + private Map handleInputs(final Map interfaceDefinitionToscaMap) { if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {