Flowdescriptor ordering

[gpl/argeo-slc.git] / runtime / org.argeo.slc.core / src / main / java / org / argeo / slc / core / execution / DefaultExecutionFlowDescriptorConverter.java

diff --git a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
index 0e51cfeaa9b959b624f9c6e815e73c3334d9d7b2..1ff50e0db9c0f1c7caf8d54f0993ba7458197798 100644 (file)
--- a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
+++ b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
@@ -1,8 +1,11 @@
 package org.argeo.slc.core.execution;
 
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.SortedSet;
 import java.util.TreeMap;
+import java.util.TreeSet;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -22,13 +25,14 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
 
 public class DefaultExecutionFlowDescriptorConverter implements
                ExecutionFlowDescriptorConverter, ApplicationContextAware {
        public final static String REF_VALUE_TYPE_BEAN_NAME = "beanName";
 
        /** Workaround for https://www.spartadn.com/bugzilla/show_bug.cgi?id=206 */
-       private final static String REF_VALUE_IS_FROZEN = "[internal]";
+       private final static String REF_VALUE_INTERNAL = "[internal]";
 
        private final static Log log = LogFactory
                        .getLog(DefaultExecutionFlowDescriptorConverter.class);
@@ -61,17 +65,19 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                } else if (value instanceof RefValue) {
                                        RefValue refValue = (RefValue) value;
 
-                                       if (REF_VALUE_TYPE_BEAN_NAME.equals(refValue.getType()))
-                                               if (refValue.getRef() != null) {
+                                       if (REF_VALUE_TYPE_BEAN_NAME.equals(refValue.getType())) {
+                                               String ref = refValue.getRef();
+                                               if (ref != null && !ref.equals(REF_VALUE_INTERNAL)) {
                                                        Object obj = applicationContext.getBean(refValue
                                                                        .getRef());
                                                        convertedValues.put(key, obj);
                                                } else {
                                                        log.warn("Cannot interpret " + refValue);
                                                }
-                                       else
+                                       } else {
                                                throw new UnsupportedException("Ref value type",
                                                                refValue.getType());
+                                       }
                                }
                        }
                }
@@ -80,6 +86,8 @@ public class DefaultExecutionFlowDescriptorConverter implements
 
        public void addFlowsToDescriptor(ExecutionModuleDescriptor md,
                        Map<String, ExecutionFlow> executionFlows) {
+               SortedSet<ExecutionFlowDescriptor> set = new TreeSet<ExecutionFlowDescriptor>(
+                               new ExecutionFlowDescriptorComparator());
                for (String name : executionFlows.keySet()) {
                        ExecutionFlow executionFlow = executionFlows.get(name);
 
@@ -110,7 +118,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                        }
                                } else if (attribute instanceof RefSpecAttribute) {
                                        if (attribute.getIsFrozen()) {
-                                               values.put(key, new RefValue(REF_VALUE_IS_FROZEN));
+                                               values.put(key, new RefValue(REF_VALUE_INTERNAL));
                                        } else
                                                values.put(key, buildRefValue(
                                                                (RefSpecAttribute) attribute, executionFlow,
@@ -126,6 +134,8 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                        values, executionSpec);
                        if (executionFlow.getPath() != null)
                                efd.setPath(executionFlow.getPath());
+                       else
+                               efd.setPath("");
 
                        // Takes description from spring
                        BeanDefinition bd = getBeanFactory().getBeanDefinition(name);
@@ -136,8 +146,10 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                md.getExecutionSpecs().add(executionSpec);
 
                        // Add execution flow
-                       md.getExecutionFlows().add(efd);
+                       set.add(efd);
+                       // md.getExecutionFlows().add(efd);
                }
+               md.getExecutionFlows().addAll(set);
        }
 
        @SuppressWarnings(value = { "unchecked" })
@@ -180,6 +192,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                log.warn("Cannot define reference for ref spec attribute "
                                                + key + " in " + executionFlow + " (" + rsa + ")."
                                                + " If it is an inner bean consider put it frozen.");
+                               ref = REF_VALUE_INTERNAL;
                        } else {
                                if (log.isDebugEnabled())
                                        log.debug(ref + " is the reference for ref spec attribute "
@@ -201,4 +214,26 @@ public class DefaultExecutionFlowDescriptorConverter implements
                this.applicationContext = applicationContext;
        }
 
+       private static class ExecutionFlowDescriptorComparator implements
+                       Comparator<ExecutionFlowDescriptor> {
+               public int compare(ExecutionFlowDescriptor o1,
+                               ExecutionFlowDescriptor o2) {
+                       if (StringUtils.hasText(o1.getPath())
+                                       && StringUtils.hasText(o2.getPath())) {
+                               return o1.getPath().compareTo(o2.getPath());
+                       } else if (!StringUtils.hasText(o1.getPath())
+                                       && StringUtils.hasText(o2.getPath())) {
+                               return 1;
+                       } else if (StringUtils.hasText(o1.getPath())
+                                       && !StringUtils.hasText(o2.getPath())) {
+                               return -1;
+                       } else if (!StringUtils.hasText(o1.getPath())
+                                       && !StringUtils.hasText(o2.getPath())) {
+                               return o1.getName().compareTo(o2.getName());
+                       } else {
+                               return 0;
+                       }
+               }
+
+       }
 }