* 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.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.IMPLEMENTATION;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.MILESTONES;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS;
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.LinkedHashMap;
import java.util.List;
import java.util.Map;
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.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.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
}
final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
final Optional<InterfaceDefinition> 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);
}
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<String, Object> interfaceInputs = (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
}
+ if (operationDefinitionMap.containsKey(MILESTONES.getElementName())) {
+ final Map<String, Object> interfaceMilestones = (Map<String, Object>) operationDefinitionMap.get(MILESTONES.getElementName());
+ operation.setMilestones(handleInterfaceOperationMilestones(interfaceMilestones));
+ }
return operation;
}
+ private Map<String, MilestoneDataDefinition> handleInterfaceOperationMilestones(final Map<String, Object> interfaceMilestones) {
+ final Map<String, MilestoneDataDefinition> milestones = new HashMap<>();
+ for (final Entry<String, Object> interfaceInput : interfaceMilestones.entrySet()) {
+ final MilestoneDataDefinition operationMilestone = new MilestoneDataDefinition();
+ ListDataDefinition<ActivityDataDefinition> activities = handleMilestoneActivities(interfaceInput.getValue());
+ if (activities.isEmpty()) {
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, interfaceInput.getKey());
+ }
+ operationMilestone.setActivities(activities);
+ milestones.put(interfaceInput.getKey(), operationMilestone);
+ }
+ return milestones;
+ }
+
+ private ListDataDefinition<ActivityDataDefinition> handleMilestoneActivities(final Object value) {
+ ListDataDefinition<ActivityDataDefinition> activities = new ListDataDefinition<>();
+ if (value instanceof Map) {
+ final LinkedHashMap<String, Object> activitiesValue = (LinkedHashMap<String, Object>) value;
+ if (activitiesValue.containsKey(ACTIVITIES.getElementName())) {
+ final List<Object> milestoneActivities = (List<Object>) activitiesValue.get(ACTIVITIES.getElementName());
+ for (Object activityValue : milestoneActivities) {
+ ActivityDataDefinition activity = new ActivityDataDefinition();
+ if (activityValue instanceof Map) {
+ Map<String, Object> activityMap = (Map<String, Object>) activityValue;
+ if (activityMap.containsKey(INPUTS.getElementName())) {
+ activity.setInputs(handleInterfaceOperationInputs((Map<String, Object>) activityMap.get(INPUTS.getElementName())));
+ }
+ if (activityMap.containsKey(TYPE.getElementName()) && activityMap.containsKey(WORKFLOW.getElementName())) {
+ activity.setType((String) activityMap.get(TYPE.getElementName()));
+ activity.setWorkflow((String) activityMap.get(WORKFLOW.getElementName()));
+ activities.add(activity);
+ } else {
+ return new ListDataDefinition<>();
+ }
+ } else {
+ return new ListDataDefinition<>();
+ }
+ }
+ } else {
+ return new ListDataDefinition<>();
+ }
+ }
+ return activities;
+ }
+
private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
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);
return Optional.empty();
}
final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
- if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
- ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) {
- Map<String, Object> implDetails = (Map) ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary");
-
+ if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
+ ((Map) operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) {
+ Map<String, Object> 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());
if (implDetails.get("artifact_version") != null) {
artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString());
}
-
- if(implDetails.get("properties") instanceof Map) {
- List<PropertyDataDefinition> operationProperties = artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties();
+
+ if (implDetails.get("properties") instanceof Map) {
+ List<PropertyDataDefinition> operationProperties =
+ artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties();
Map<String, Object> properties = (Map<String, Object>) 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;
if (value instanceof Float || value instanceof Double) {
return ToscaPropertyType.FLOAT;
}
+ if (value instanceof List) {
+ return ToscaPropertyType.LIST;
+ }
return null;
}
-
+
private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
Code Review / sdc.git / blobdiff