+ 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());
+ if (!filters.isEmpty()) {
+ operationMilestone.setFilters(filters);
+ }
+ operationMilestone.setActivities(activities);
+ milestones.put(interfaceInput.getKey(), operationMilestone);
+ }
+ return milestones;
+ }
+
+ private ListDataDefinition<FilterDataDefinition> handleMilestoneFilters(Object milestone) {
+ ListDataDefinition<FilterDataDefinition> filters = new ListDataDefinition<>();
+ if (milestone instanceof Map) {
+ final LinkedHashMap<String, Object> milestoneValue = (LinkedHashMap<String, Object>) milestone;
+ if (milestoneValue.containsKey(FILTERS.getElementName())) {
+ final List<Object> milestoneFilters = (List<Object>) milestoneValue.get(FILTERS.getElementName());
+ for (Object filtersValues : milestoneFilters) {
+ if (filtersValues instanceof Map) {
+ FilterDataDefinition filter = new FilterDataDefinition();
+ Map<String, Object> filterMap = (Map<String, Object>) filtersValues;
+
+ Optional<Entry<String, Object>> filterOptional =
+ filterMap.entrySet().stream().filter(entrySet -> entrySet.getValue() instanceof Map).findAny();
+ if (filterOptional.isEmpty()) {
+ continue;
+ }
+ Entry<String, Object> filterValue = filterOptional.get();
+ if (!(filterValue.getValue() instanceof Map)) {
+ continue;
+ }
+ Map<String, Object> valueMap = (Map<String, Object>) filterValue.getValue();
+ Optional<String> 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<String, Object> valueAsMap = (Map<String, Object>) value;
+ Optional<String> toscaFunctionTypeOptional =
+ valueAsMap.keySet().stream().filter(key -> ToscaFunctionType.findType(key).isPresent()).findAny();
+ if (toscaFunctionTypeOptional.isPresent()) {
+ Optional<ToscaFunction> 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<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 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<>();
+ }
+ }
+ return activities;
+ }
+
+ private ListDataDefinition<OperationInputDefinition> handleActivityInterfaceOperationInputs(Map<String, Object> activityInputs) {