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.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 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.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;
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));
+ for (MilestoneTypeEnum milestone : MilestoneTypeEnum.values()) {
+ String milestoneType = milestone.getValue();
+ if (operationDefinitionMap.containsKey(milestone.getValue())) {
+ final Map<String, Object> interfaceMilestones = (Map<String, Object>) 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;
}
- 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());
- }
- ListDataDefinition<FilterDataDefinition> filters = handleMilestoneFilters(interfaceInput.getValue());
+ public MilestoneDataDefinition handleInterfaceOperationMilestones(final Map<String, Object> interfaceMilestones, String key) {
+ final MilestoneDataDefinition operationMilestone = new MilestoneDataDefinition();
+ if (interfaceMilestones != null && !interfaceMilestones.containsKey(ACTIVITIES.getElementName())) {
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, key);
+ }
+ ListDataDefinition<ActivityDataDefinition> activities = handleMilestoneActivities(interfaceMilestones);
+ if (activities.isEmpty()) {
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_OPERATION_MILESTONE, key);
+ }
+ if (interfaceMilestones.containsKey(FILTERS.getElementName())) {
+ ListDataDefinition<FilterDataDefinition> filters = handleMilestoneFilters(interfaceMilestones);
if (!filters.isEmpty()) {
operationMilestone.setFilters(filters);
}
- operationMilestone.setActivities(activities);
- milestones.put(interfaceInput.getKey(), operationMilestone);
}
- return milestones;
+ operationMilestone.setActivities(activities);
+ return operationMilestone;
}
private ListDataDefinition<FilterDataDefinition> handleMilestoneFilters(Object milestone) {
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<>();
+ for (Object activity : milestoneActivities) {
+ if (activity instanceof Map) {
+ final Map<String, Object> activityMap = (Map<String, Object>) activity;
+ for (Entry<String, Object> activityValue : activityMap.entrySet()) {
+ if (activityValue.getValue() instanceof Map) {
+ ActivityDataDefinition activityDef = new ActivityDataDefinition();
+ Map<String, Object> activityValueMap = (Map<String, Object>) activityValue.getValue();
+ if (activityValueMap.containsKey(INPUTS.getElementName())) {
+ activityDef.setInputs(
+ handleActivityInterfaceOperationInputs((Map<String, Object>) 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<>();
}
}
} else {
return activities;
}
+ private ListDataDefinition<OperationInputDefinition> handleActivityInterfaceOperationInputs(Map<String, Object> activityInputs) {
+ final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+ final String defaultType = "tosca.dataTypes.tmf.milestoneJeopardyData";
+ for (final Entry<String, Object> 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<String> allowedKeys = new HashSet<>();
+ allowedKeys.add("jeopardyType");
+ allowedKeys.add("name");
+ allowedKeys.add("eventType");
+ allowedKeys.add("message");
+
+ Map<String, Object> valueMap = (Map<String, Object>) value;
+ return allowedKeys.containsAll(valueMap.keySet());
+ }
+ return false;
+ }
+
private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
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);
+ artifactDataDefinition.setTimeout((Integer) timeOut);
}
if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) {
Code Review / sdc.git / blobdiff