Added InstantiationManager

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

diff --git a/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/core/execution/ExecutionParameterPostProcessor.java b/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/core/execution/ExecutionParameterPostProcessor.java
index d393d774f84c96de38737d93f6458e019fc64f96..e39e9fab78aec4798477daf7e707400111f6dc74 100644 (file)
--- a/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/core/execution/ExecutionParameterPostProcessor.java
+++ b/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/core/execution/ExecutionParameterPostProcessor.java
@@ -8,6 +8,7 @@ import java.util.Properties;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.argeo.slc.SlcException;
+import org.argeo.slc.execution.ExecutionContext;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.PropertyValue;
 import org.springframework.beans.PropertyValues;
@@ -17,9 +18,36 @@ import org.springframework.beans.factory.config.TypedStringValue;
 
 public class ExecutionParameterPostProcessor extends
                InstantiationAwareBeanPostProcessorAdapter {
+       
        private final static Log log = LogFactory
                        .getLog(ExecutionParameterPostProcessor.class);
 
+       private ExecutionContext executionContext;
+       
+       private ExecutionScope executionScope;
+       
+       private InstantiationManager instantiationManager;
+       
+       public InstantiationManager getInstantiationManager() {
+               return instantiationManager;
+       }
+
+       public void setInstantiationManager(InstantiationManager instantiationManager) {
+               this.instantiationManager = instantiationManager;
+       }
+
+       public void setExecutionScope(ExecutionScope executionScope) {
+               this.executionScope = executionScope;
+       }
+
+       public ExecutionContext getExecutionContext() {
+               return executionContext;
+       }
+
+       public void setExecutionContext(ExecutionContext executionContext) {
+               this.executionContext = executionContext;
+       }
+
        private String placeholderPrefix = "@{";
        private String placeholderSuffix = "}";
        private String nullValue;
@@ -28,48 +56,41 @@ public class ExecutionParameterPostProcessor extends
        public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                        PropertyDescriptor[] pds, Object bean, String beanName)
                        throws BeansException {
-               if (!ExecutionContext.isExecuting())
-                       return pvs;
-
-//             ExecutionFlow currentFlow = ExecutionContext.getCurrentFlow();
-//
-//             Properties props = new Properties();
-//             Map<String, Object> attributes = currentFlow.getAttributes();
-//             Map<String, ExecutionSpecAttribute> specAttributes = currentFlow
-//                             .getExecutionSpec().getAttributes();
-//
-//             for (String key : specAttributes.keySet()) {
-//                     ExecutionSpecAttribute obj = specAttributes.get(key);
-//                     if (!(obj instanceof RefSpecAttribute)) {
-//                             if (!attributes.containsKey(key))
-//                                     throw new SlcException("Specified attribute " + key
-//                                                     + " is not set in " + currentFlow);
-//
-//                             props.setProperty(key, attributes.get(key).toString());
-//                             // if (log.isTraceEnabled())
-//                             // log.trace("Use attribute " + key);
-//                     }
+               
+               
+//             boolean inFlowInitialization = DefaultExecutionSpec.isInFlowInitialization();
+                               
+//             if (((executionScope == null) || (!executionScope.hasExecutionContext()))
+//                             && !inFlowInitialization) {
+//                     //log.info("Skip parameter conversion for bean " + beanName);
+//                     return pvs;
+//             } else {
+//                     //log.info("Execute parameter conversion for bean " + beanName);
 //             }
 
                Properties props = new Properties();
                CustomPpc ppc = new CustomPpc(props);
 
                for (PropertyValue pv : pvs.getPropertyValues()) {
+//                     log.info("   PropertyValue pv " + pv.getValue() + " - "
+//                                     + pv.getValue().getClass());
+                       String originalValue = null;
+                       String convertedValue = null;
                        if (pv.getValue() instanceof TypedStringValue) {
                                TypedStringValue tsv = (TypedStringValue) pv.getValue();
-                               String originalValue = tsv.getValue();
-                               String convertedValue = ppc.process(originalValue);
+                               originalValue = tsv.getValue();
+                               convertedValue = ppc.process(originalValue);
                                tsv.setValue(convertedValue);
-                               if (log.isTraceEnabled()) {
-                                       if (!originalValue.equals(convertedValue))
-                                               log.trace("Converted field '" + pv.getName() + "': '"
-                                                               + originalValue + "' to '" + convertedValue
-                                                               + "' in bean " + beanName);
-                               }
-                       } else {
-                               // if (log.isTraceEnabled())
-                               // log.trace(beanName + "[" + pv.getName() + "]: "
-                               // + pv.getValue().getClass());
+                       } else if (pv.getValue() instanceof String) {
+                               originalValue = pv.getValue().toString();
+                               convertedValue = ppc.process(originalValue);
+                               pv.setConvertedValue(convertedValue);
+                       }
+                       if (convertedValue != null && log.isTraceEnabled()) {
+                               if (!originalValue.equals(convertedValue))
+                                       log.trace("Converted field '" + pv.getName() + "': '"
+                                                       + originalValue + "' to '" + convertedValue
+                                                       + "' in bean " + beanName);
                        }
                }
 
@@ -107,14 +128,27 @@ public class ExecutionParameterPostProcessor extends
 
                @Override
                protected String resolvePlaceholder(String placeholder, Properties props) {
-                       if (ExecutionContext.isExecuting())
-                               return ExecutionContext.getVariable(placeholder).toString();
-                       else if (SimpleExecutionSpec.isInFlowInitialization())
-                               return SimpleExecutionSpec.getInitializingFlowParameter(
-                                               placeholder).toString();
-                       else
-                               return super.resolvePlaceholder(placeholder, props);
+                       if ((executionScope != null) && (executionScope.hasExecutionContext())) {
+                               // if we have an execution context, look there for the placeholder
+                               return executionContext.getVariable(placeholder).toString();
+                       }
+                       else {
+                               // TODO: check scope of the bean
+                               // throw exception if trying to resolve placeholder on bean of scope singleton 
+                               
+                               if (instantiationManager.isInFlowInitialization()) {
+                                       String resolved = instantiationManager.getInitializingFlowParameter(
+                                                       placeholder).toString();
+//                                     log.info("Initialization placeholder resolution " + placeholder 
+//                                                     + ">>" + resolved);
+                                       return resolved;
+                               }
+                               else {
+       //                              return super.resolvePlaceholder(placeholder, props);
+                                       throw new SlcException("Placeholder '" + placeholder 
+                                                       + "' can not be resolved outside of Flow Initialization or Flow Execution.");
+                               }
+                       }
                }
-
        }
 }