/*
- * Copyright (C) 2001, 2002 The Mir-coders group
+ * Copyright (C) 2001-2006 The Mir-coders group
*
* This file is part of Mir.
*
*
* In addition, as a special exception, The Mir-coders gives permission to link
* the code of this program with any library licensed under the Apache Software License,
- * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
- * (or with modified versions of the above that use the same license as the above),
* and distribute linked combinations including the two. You must obey the
* GNU General Public License in all respects for all of the code used other than
* the above mentioned libraries. If you modify this file, you may extend this
*/
package mir.producer.reader;
+import java.io.File;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import mir.generator.Generator;
import mir.generator.WriterEngine;
import mir.log.LoggerWrapper;
+import mir.producer.BundleProducerNode;
import mir.producer.ConditionalProducerNode;
import mir.producer.DirCopyingProducerNode;
import mir.producer.EntityBatchingProducerNode;
import mir.producer.EntityListProducerNode;
import mir.producer.EntityModifyingProducerNode;
import mir.producer.EvaluatedAssignmentProducerNode;
+import mir.producer.ExecuteProgramProducerNode;
import mir.producer.ExpandedAssignmentProducerNode;
+import mir.producer.ExternalDbProducerNode;
import mir.producer.FileDateSettingProducerNode;
import mir.producer.FileDeletingProducerNode;
import mir.producer.FreeQueryProducerNode;
import mir.producer.ProducerNode;
import mir.producer.RDFAggregatorProducerNode;
import mir.producer.RSSProducerNode;
-import mir.producer.ResourceBundleProducerNode;
-import mir.producer.ScriptCallingProducerNode;
-import mir.util.XMLReader;
-import mir.util.XMLReaderTool;
+import mir.util.StringRoutines;
+import mir.util.xml.XMLParserExc;
+import mir.util.xml.XMLReaderTool;
public class DefaultProducerNodeBuilders {
public static void registerBuilders(ProducerNodeBuilderLibrary aBuilderLibrary,
- EntityAdapterModel aModel, Generator.GeneratorLibrary aGeneratorLibrary,
- WriterEngine aWriterEngine, String aSourceBasePath, String aDestinationBasePath) throws ProducerConfigExc {
+ EntityAdapterModel aModel, Generator.Library aGeneratorLibrary,
+ Generator.Interceptor anInterceptor,
+ WriterEngine aWriterEngine, File aSourceBasePath, File aDestinationBasePath) throws ProducerConfigExc {
aBuilderLibrary.registerBuilder("Set", EvaluatedAssignmentProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Define", ExpandedAssignmentProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Log", LoggingProducerNodeBuilder.class);
- aBuilderLibrary.registerBuilder("Execute", ScriptCallingProducerNodeBuilder.class);
- aBuilderLibrary.registerBuilder("Resource", ResourceBundleProducerNodeBuilder.class);
- aBuilderLibrary.registerFactory("CopyDir", new DirCopyProducerNodeBuilder.factory( aSourceBasePath, aDestinationBasePath));
+ aBuilderLibrary.registerBuilder("Execute", ExecuteProgramProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("Resource", BundleProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("Bundle", BundleProducerNodeBuilder.class);
+ aBuilderLibrary.registerFactory("CopyDir", new DirCopyProducerNodeBuilder.factory(aSourceBasePath, aDestinationBasePath));
aBuilderLibrary.registerBuilder("DeleteFile", FileDeletingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("SetFileDate", FileDateSettingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("RDFAggregate", RDFAggregatorProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("FreeQuery", FreeQueryProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("ExternalDbQuery", ExternalDbProducerNodeBuilder.class);
aBuilderLibrary.registerFactory("Enumerate", new EnumeratingProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("List", new ListProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("CreateEntity", new CreateEntityProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("DeleteEntity", new DeleteEntityProducerNodeBuilder.factory(aModel));
- aBuilderLibrary.registerFactory("Generate",
- new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary, aWriterEngine));
+ aBuilderLibrary.registerFactory("Generate", new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary,
+ aWriterEngine, anInterceptor));
}
public static abstract class AbstractProducerNodeBuilder implements ProducerNodeBuilder {
- private Map attributes;
private Map subNodes;
private Set availableSubnodes;
public AbstractProducerNodeBuilder(String anAvailableSubNodes[]) {
- attributes = new HashMap();
subNodes = new HashMap();
availableSubnodes = new HashSet(Arrays.asList(anAvailableSubNodes));
}
public void setSubNode(String aName, ProducerNode aNode) {
subNodes.put(aName, aNode);
- };
+ }
public Set getAvailableSubNodes() {
return availableSubnodes;
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
// general attribute names, specifc builders reference these, to keep attribute
// names consistent
+ public final static String EXTRA_TABLES_ATTRIBUTE = "extratables";
public final static String SELECTION_ATTRIBUTE = "selection";
public final static String ORDER_ATTRIBUTE = "order";
public final static String DEFINITION_ATTRIBUTE = "table";
super(ASSIGNMENT_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new ExpandedAssignmentProducerNode(key, value);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
super(ASSIGNMENT_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new EvaluatedAssignmentProducerNode(key, value);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
private final static String ENUMERATION_DEFAULT_SUBNODE = "default";
private final static String ENUMERATION_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
private final static String ENUMERATION_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
+ private final static String ENUMERATION_EXTRATABLES_ATTRIBUTE = EXTRA_TABLES_ATTRIBUTE;
private final static String[] ENUMERATION_LIST_REQUIRED_ATTRIBUTES = { ENUMERATION_LIST_ATTRIBUTE, ENUMERATION_KEY_ATTRIBUTE };
private final static String[] ENUMERATION_LIST_OPTIONAL_ATTRIBUTES = { };
private final static String[] ENUMERATION_QUERY_REQUIRED_ATTRIBUTES = { ENUMERATION_DEFINITION_ATTRIBUTE, ENUMERATION_KEY_ATTRIBUTE };
- private final static String[] ENUMERATION_QUERY_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE};
+ private final static String[] ENUMERATION_QUERY_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE,ENUMERATION_EXTRATABLES_ATTRIBUTE};
private final static String[] ENUMERATION_SUBNODES = {ENUMERATION_DEFAULT_SUBNODE};
private String key;
private String definition;
+ private String mainTablePrefix;
+ private String extraTables;
private String list;
private String selection;
private String order;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE);
list = (String) anAttributes.get(ENUMERATION_LIST_ATTRIBUTE);
key = (String) anAttributes.get(ENUMERATION_KEY_ATTRIBUTE);
- selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, "");
- order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, "");
+ selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, "");
+ order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, "");
limit = (String) anAttributes.get(ENUMERATION_LIMIT_ATTRIBUTE);
skip = (String) anAttributes.get(ENUMERATION_SKIP_ATTRIBUTE);
- };
+ extraTables = XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_EXTRATABLES_ATTRIBUTE,"");
+ if (definition!=null) {
+ List parts = StringRoutines.splitString(definition.trim(), " ");
+ if (parts.size() > 0)
+ definition = (String) parts.get(0);
+ if (parts.size() > 1)
+ mainTablePrefix = (String) parts.get(1);
+ }
+ }
public ProducerNode constructNode() {
if (definition!=null)
- return new EntityEnumeratingProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
- else
- return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
- };
+ return new EntityEnumeratingProducerNode(key, model, mainTablePrefix, extraTables, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
+ return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
fieldValues = new HashMap();
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
key = (String) anAttributes.get(UPDATE_KEY_ATTRIBUTE);
if (key == null)
- throw new XMLReader.XMLReaderExc("missing required attribute '" + UPDATE_KEY_ATTRIBUTE + "'" );
+ throw new XMLParserExc("missing required attribute '" + UPDATE_KEY_ATTRIBUTE + "'" );
definition = (String) anAttributes.get(UPDATE_DEFINITION_ATTRIBUTE);
fieldValues.putAll(anAttributes);
fieldValues.remove(UPDATE_KEY_ATTRIBUTE);
fieldValues.remove(UPDATE_DEFINITION_ATTRIBUTE);
- };
-
+ }
public ProducerNode constructNode() {
return new EntityModifyingProducerNode(model, false, definition, key, fieldValues);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
fieldValues = new HashMap();
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
key = (String) anAttributes.get(CREATEENTITY_KEY_ATTRIBUTE);
definition = (String) anAttributes.get(CREATEENTITY_DEFINITION_ATTRIBUTE);
if (key == null)
- throw new XMLReader.XMLReaderExc("missing required attribute '" + CREATEENTITY_KEY_ATTRIBUTE + "'" );
+ throw new XMLParserExc("missing required attribute '" + CREATEENTITY_KEY_ATTRIBUTE + "'" );
if (definition == null)
- throw new XMLReader.XMLReaderExc("missing required attribute '" + CREATEENTITY_DEFINITION_ATTRIBUTE + "'" );
+ throw new XMLParserExc("missing required attribute '" + CREATEENTITY_DEFINITION_ATTRIBUTE + "'" );
fieldValues.putAll(anAttributes);
fieldValues.remove(CREATEENTITY_KEY_ATTRIBUTE);
fieldValues.remove(CREATEENTITY_DEFINITION_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new EntityModifyingProducerNode(model, true, definition, key, fieldValues);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
super(LOOP_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, LOOP_REQUIRED_ATTRIBUTES, LOOP_OPTIONAL_ATTRIBUTES);
condition = (String) anAttributes.get(LOOP_CONDITION_ATTRIBUTE);
- limit = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, "");
- };
+ limit = XMLReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, "");
+ }
public ProducerNode constructNode() {
return new LoopProducerNode(condition, limit, getSubNode( LOOP_DEFAULT_SUBNODE ));
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
private final static String LIST_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String LIST_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
private final static String LIST_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
+ private final static String LIST_EXTRATABLES_ATTRIBUTE = EXTRA_TABLES_ATTRIBUTE;
private final static String LIST_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
- private final static String LIST_DEFAULT_SUBNODE = "default";
private final static String LIST_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
private final static String LIST_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
private final static String[] LIST_REQUIRED_ATTRIBUTES = { LIST_KEY_ATTRIBUTE, LIST_DEFINITION_ATTRIBUTE };
- private final static String[] LIST_OPTIONAL_ATTRIBUTES = { LIST_SELECTION_ATTRIBUTE, LIST_ORDER_ATTRIBUTE, LIST_SKIP_ATTRIBUTE, LIST_LIMIT_ATTRIBUTE};
+ private final static String[] LIST_OPTIONAL_ATTRIBUTES = { LIST_SELECTION_ATTRIBUTE, LIST_ORDER_ATTRIBUTE, LIST_SKIP_ATTRIBUTE, LIST_LIMIT_ATTRIBUTE,LIST_EXTRATABLES_ATTRIBUTE};
private final static String[] LIST_SUBNODES = {};
private String key;
private String definition;
+ private String mainTablePrefix;
+ private String extraTables;
private String selection;
private String order;
private String limit;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(LIST_KEY_ATTRIBUTE);
definition = (String) anAttributes.get(LIST_DEFINITION_ATTRIBUTE);
- selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, "");
- order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, "");
+ selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, "");
+ order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, "");
limit = (String) anAttributes.get(LIST_LIMIT_ATTRIBUTE);
skip = (String) anAttributes.get(LIST_SKIP_ATTRIBUTE);
- };
+ extraTables = XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_EXTRATABLES_ATTRIBUTE,"");
+ List parts = StringRoutines.splitString(definition.trim()," ");
+ if (parts.size()>0) definition=(String)parts.get(0);
+ if (parts.size()>1) mainTablePrefix=(String)parts.get(1);
+
+ }
public ProducerNode constructNode() {
- return new EntityListProducerNode(key, model, definition, selection, order, limit, skip, null );
- };
+ return new EntityListProducerNode(key, model, mainTablePrefix, extraTables, definition, selection, order, limit, skip, null );
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, DELETEENTITY_REQUIRED_ATTRIBUTES, DELETEENTITY_OPTIONAL_ATTRIBUTES);
definition = (String) anAttributes.get(DELETEENTITY_DEFINITION_ATTRIBUTE);
- selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, DELETEENTITY_SELECTION_ATTRIBUTE, "");
- };
+ selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, DELETEENTITY_SELECTION_ATTRIBUTE, "");
+ }
public ProducerNode constructNode() {
return new EntityDeletingProducerNode(model, definition, selection);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
super(LOG_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
String typeString;
XMLReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
}
else
type = LoggerWrapper.INFO_MESSAGE;
- };
+ }
public ProducerNode constructNode() {
return new LoggingProducerNode(message, type);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
super(FREEQUERY_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
String typeString;
XMLReaderTool.checkAttributes(anAttributes, FREEQUERY_REQUIRED_ATTRIBUTES, FREEQUERY_OPTIONAL_ATTRIBUTES);
}
else
type = FreeQueryProducerNode.QUERY_TYPE_SET;
- };
+ }
public ProducerNode constructNode() {
return new FreeQueryProducerNode(key, query, limit, type);
- };
+ }
+ }
+////////////////////////////////////////////////////////////////////////////////
+
+ public static class ExternalDbProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String EXTDB_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String EXTDB_DRIVER_ATTRIBUTE = "driver";
+ private final static String EXTDB_HOST_ATTRIBUTE = "host";
+ private final static String EXTDB_PORT_ATTRIBUTE = "port";
+ private final static String EXTDB_DATABASE_ATTRIBUTE = "database";
+ private final static String EXTDB_USERNAME_ATTRIBUTE = "username";
+ private final static String EXTDB_PASSWORD_ATTRIBUTE = "password";
+ private final static String EXTDB_QUERY_ATTRIBUTE = "query";
+ private final static String EXTDB_DEFAULT_SUBNODE = "default";
+ private final static String[] EXTDB_REQUIRED_ATTRIBUTES = { KEY_ATTRIBUTE, EXTDB_DRIVER_ATTRIBUTE, EXTDB_HOST_ATTRIBUTE, EXTDB_PORT_ATTRIBUTE, EXTDB_DATABASE_ATTRIBUTE, EXTDB_USERNAME_ATTRIBUTE, EXTDB_PASSWORD_ATTRIBUTE, EXTDB_QUERY_ATTRIBUTE };
+ private final static String[] EXTDB_OPTIONAL_ATTRIBUTES = { };
+ private final static String[] EXTDB_SUBNODES = {EXTDB_DEFAULT_SUBNODE};
+
+ private String key;
+ private String driver;
+ private String host;
+ private String port;
+ private String database;
+ private String username;
+ private String password;
+ private String query;
+
+
+ public ExternalDbProducerNodeBuilder() {
+ super(EXTDB_SUBNODES);
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
+ XMLReaderTool.checkAttributes(anAttributes, EXTDB_REQUIRED_ATTRIBUTES, EXTDB_OPTIONAL_ATTRIBUTES);
+
+ key = (String) anAttributes.get(EXTDB_KEY_ATTRIBUTE);
+ driver = (String) anAttributes.get(EXTDB_DRIVER_ATTRIBUTE);
+ host = (String) anAttributes.get(EXTDB_HOST_ATTRIBUTE);
+ port = (String) anAttributes.get(EXTDB_PORT_ATTRIBUTE);
+ database = (String) anAttributes.get(EXTDB_DATABASE_ATTRIBUTE);
+ username = (String) anAttributes.get(EXTDB_USERNAME_ATTRIBUTE);
+ password = (String) anAttributes.get(EXTDB_PASSWORD_ATTRIBUTE);
+ query = (String) anAttributes.get(EXTDB_QUERY_ATTRIBUTE);
+ }
+
+ public ProducerNode constructNode() {
+ return new ExternalDbProducerNode(key, driver, host, port, database, username, password, query, getSubNode(EXTDB_DEFAULT_SUBNODE));
+ }
}
////////////////////////////////////////////////////////////////////////////////
- public static class ResourceBundleProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ public static class BundleProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String RESOURCEBUNDLE_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String RESOURCEBUNDLE_BUNDLE_ATTRIBUTE = "bundle";
private final static String RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE = "language";
- private final static String RESOURCEBUNDLE_DEFAULT_SUBNODE = "default";
private final static String[] RESOURCEBUNDLE_REQUIRED_ATTRIBUTES = { RESOURCEBUNDLE_KEY_ATTRIBUTE, RESOURCEBUNDLE_BUNDLE_ATTRIBUTE };
private final static String[] RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES = { RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE};
private final static String[] RESOURCEBUNDLE_SUBNODES = {};
private String bundle;
private String language;
- public ResourceBundleProducerNodeBuilder() {
+ public BundleProducerNodeBuilder() {
super(RESOURCEBUNDLE_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE);
bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE);
language = (String) anAttributes.get(RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
- return new ResourceBundleProducerNode(key, bundle, language);
- };
+ return new BundleProducerNode(key, bundle, language);
+ }
}
////////////////////////////////////////////////////////////////////////////////
super(FILEDATESETTING_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES);
fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE);
dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new FileDateSettingProducerNode(fileNameKey, dateKey);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
super(FILEDELETING_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new FileDeletingProducerNode(fileNameKey);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
- public static class ScriptCallingProducerNodeBuilder extends AbstractProducerNodeBuilder {
- private final static String SCRIPT_COMMAND_ATTRIBUTE = "command";
- private final static String[] SCRIPT_REQUIRED_ATTRIBUTES = { SCRIPT_COMMAND_ATTRIBUTE };
- private final static String[] SCRIPT_OPTIONAL_ATTRIBUTES = {};
- private final static String[] SCRIPT_SUBNODES = {};
+ public static class ExecuteProgramProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String EXECUTEPROGRAM_COMMAND_ATTRIBUTE = "command";
+ private final static String EXECUTEPROGRAM_MAXTIME_ATTRIBUTE = "maxduration";
+ private final static String EXECUTEPROGRAM_RESULTVAR_ATTRIBUTE = "resultvar";
+ private final static String EXECUTEPROGRAM_RETURNVALUE_ATTRIBUTE = "returnvaluevar";
+ private final static String[] EXECUTEPROGRAM_REQUIRED_ATTRIBUTES = { EXECUTEPROGRAM_COMMAND_ATTRIBUTE };
+ private final static String[] EXECUTEPROGRAM_OPTIONAL_ATTRIBUTES = { EXECUTEPROGRAM_MAXTIME_ATTRIBUTE, EXECUTEPROGRAM_RESULTVAR_ATTRIBUTE };
+ private final static String[] EXECUTEPROGRAM_SUBNODES = {};
private String command;
+ private String time;
+ private String resultvar;
+ private String returnValueVar;
- public ScriptCallingProducerNodeBuilder() {
- super(SCRIPT_SUBNODES);
+ public ExecuteProgramProducerNodeBuilder() {
+ super(EXECUTEPROGRAM_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
- XMLReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
+ XMLReaderTool.checkAttributes(anAttributes, EXECUTEPROGRAM_REQUIRED_ATTRIBUTES, EXECUTEPROGRAM_OPTIONAL_ATTRIBUTES);
- command = (String) anAttributes.get(SCRIPT_COMMAND_ATTRIBUTE);
- };
+ command = (String) anAttributes.get(EXECUTEPROGRAM_COMMAND_ATTRIBUTE);
+ time = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_MAXTIME_ATTRIBUTE, null);
+ resultvar = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_RESULTVAR_ATTRIBUTE, null);
+ returnValueVar = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_RETURNVALUE_ATTRIBUTE, null);
+ }
public ProducerNode constructNode() {
- return new ScriptCallingProducerNode(command);
- };
+ return new
+ ExecuteProgramProducerNode(command, time, resultvar, returnValueVar);
+ }
}
////////////////////////////////////////////////////////////////////////////////
public static class DirCopyProducerNodeBuilder extends AbstractProducerNodeBuilder {
private String source;
private String destination;
- private String sourceBasePath;
- private String destinationBasePath;
+ private File sourceBasePath;
+ private File destinationBasePath;
- public DirCopyProducerNodeBuilder(String aSourceBasePath, String aDestinationBasePath) {
+ public DirCopyProducerNodeBuilder(File aSourceBasePath, File aDestinationBasePath) {
super(DIRCOPY_SUBNODES);
sourceBasePath = aSourceBasePath;
destinationBasePath = aDestinationBasePath;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, DIRCOPY_REQUIRED_ATTRIBUTES, DIRCOPY_OPTIONAL_ATTRIBUTES);
source = (String) anAttributes.get(DIRCOPY_SOURCE_ATTRIBUTE);
destination = (String) anAttributes.get(DIRCOPY_DESTINATION_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new DirCopyingProducerNode(sourceBasePath, destinationBasePath, source, destination);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
- private String sourceBasePath;
- private String destinationBasePath;
+ private File sourceBasePath;
+ private File destinationBasePath;
- public factory(String aSourceBasePath, String aDestinationBasePath) {
+ public factory(File aSourceBasePath, File aDestinationBasePath) {
sourceBasePath = aSourceBasePath;
destinationBasePath = aDestinationBasePath;
}
private String generator;
private String destination;
private String parameters;
- private Generator.GeneratorLibrary generatorLibrary;
+ private Generator.Library generatorLibrary;
private WriterEngine writerEngine;
+ private Generator.Interceptor interceptor;
- public GeneratingProducerNodeBuilder(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
+ public GeneratingProducerNodeBuilder(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine,
+ Generator.Interceptor anInterceptor) {
super(GENERATION_SUBNODES);
writerEngine = aWriterEngine;
generatorLibrary = aGeneratorLibrary;
+ interceptor = anInterceptor;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES);
generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE);
destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE);
parameters = XMLReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
- };
+ }
public ProducerNode constructNode() {
- return new GeneratingProducerNode(generatorLibrary, writerEngine, generator, destination, parameters);
- };
+ return new GeneratingProducerNode(generatorLibrary, writerEngine, interceptor, generator, destination, parameters);
+ }
public static class factory implements ProducerNodeBuilderFactory {
- private Generator.GeneratorLibrary generatorLibrary;
+ private Generator.Library generatorLibrary;
private WriterEngine writerEngine;
+ private Generator.Interceptor interceptor;
- public factory(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
+ public factory(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine, Generator.Interceptor anInterceptor) {
writerEngine = aWriterEngine;
generatorLibrary = aGeneratorLibrary;
+ interceptor = anInterceptor;
}
public ProducerNodeBuilder makeBuilder() {
- return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine);
+ return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine, interceptor);
}
}
}
private final static String BATCHER_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
private final static String BATCHER_PROCESS_ATTRIBUTE = "process";
+ private final static String BATCHER_EXTRATABLES_ATTRIBUTE = EXTRA_TABLES_ATTRIBUTE;
private final static String BATCHER_BATCH_SUBNODE = "batches";
private final static String BATCHER_BATCHLIST_SUBNODE = "batchlist";
private final static String[] BATCHER_REQUIRED_ATTRIBUTES = { BATCHER_DATAKEY_ATTRIBUTE, BATCHER_INFOKEY_ATTRIBUTE, BATCHER_DEFINITION_ATTRIBUTE, BATCHER_BATCHSIZE_ATTRIBUTE };
- private final static String[] BATCHER_OPTIONAL_ATTRIBUTES = { BATCHER_SELECTION_ATTRIBUTE, BATCHER_ORDER_ATTRIBUTE, BATCHER_MINBATCHSIZE_ATTRIBUTE, BATCHER_SKIP_ATTRIBUTE, BATCHER_PROCESS_ATTRIBUTE };
+ private final static String[] BATCHER_OPTIONAL_ATTRIBUTES = { BATCHER_SELECTION_ATTRIBUTE, BATCHER_ORDER_ATTRIBUTE, BATCHER_MINBATCHSIZE_ATTRIBUTE, BATCHER_SKIP_ATTRIBUTE, BATCHER_PROCESS_ATTRIBUTE, BATCHER_EXTRATABLES_ATTRIBUTE };
private final static String[] BATCHER_SUBNODES = { BATCHER_BATCH_SUBNODE, BATCHER_BATCHLIST_SUBNODE };
private EntityAdapterModel model;
private String batchDataKey;
private String batchInfoKey;
+ private String mainTablePrefix;
+ private String extraTables;
private String definition;
private String selection;
private String order;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES);
batchDataKey = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" );
minBatchSize = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, "0" );
skip = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" );
process = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" );
- };
+
+ extraTables = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_EXTRATABLES_ATTRIBUTE, "");
+
+ List parts = StringRoutines.splitString(definition.trim(), " ");
+ if (parts.size()>0) definition = (String) parts.get(0);
+ if (parts.size()>1) mainTablePrefix = (String) parts.get(1);
+ }
public ProducerNode constructNode() {
return new EntityBatchingProducerNode(
batchDataKey,
batchInfoKey,
model,
+ mainTablePrefix,
+ extraTables,
definition,
selection,
order,
getSubNode( BATCHER_BATCH_SUBNODE ),
getSubNode( BATCHER_BATCHLIST_SUBNODE )
);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
super(IF_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE );
- };
+ }
public ProducerNode constructNode() {
return new ConditionalProducerNode(
getSubNode( IF_TRUE_SUBNODE ),
getSubNode( IF_FALSE_SUBNODE )
);
- };
+ }
}
public static class RSSProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String RSS_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String RSS_URL_ATTRIBUTE = URL_ATTRIBUTE;
+ private final static String RSS_ENCODING_ATTRIBUTE = "encoding";
private final static String RSS_VERSION_ATTRIBUTE = "version";
private final static String[] RSS_REQUIRED_ATTRIBUTES = { RSS_KEY_ATTRIBUTE, RSS_URL_ATTRIBUTE };
- private final static String[] RSS_OPTIONAL_ATTRIBUTES = { RSS_VERSION_ATTRIBUTE };
+ private final static String[] RSS_OPTIONAL_ATTRIBUTES = { RSS_VERSION_ATTRIBUTE, RSS_ENCODING_ATTRIBUTE };
private final static String[] RSS_SUBNODES = { };
private String key;
private String url;
private String version;
+ private String encoding;
public RSSProducerNodeBuilder() {
super(RSS_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, RSS_REQUIRED_ATTRIBUTES, RSS_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get( RSS_KEY_ATTRIBUTE );
url = (String) anAttributes.get( RSS_URL_ATTRIBUTE );
version = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RSS_VERSION_ATTRIBUTE, "1.0");
- };
+ encoding = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RSS_ENCODING_ATTRIBUTE, null);
+ }
public ProducerNode constructNode() {
- return new RSSProducerNode(key, url, version);
- };
+ return new RSSProducerNode(key, url, version, encoding);
+ }
}
////////////////////////////////////////////////////////////////////////////////
public static class RDFAggregatorProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String RDF_AGGREGATOR_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String RDF_AGGREGATOR_SOURCE_ATTRIBUTE = "source";
- private final static String RDF_AGGREGATOR_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
- private final static String RDF_AGGREGATOR_FILTER_ATTRIBUTE = "filter";
private final static String[] RDF_AGGREGATOR_REQUIRED_ATTRIBUTES = { RDF_AGGREGATOR_KEY_ATTRIBUTE, RDF_AGGREGATOR_SOURCE_ATTRIBUTE };
- private final static String[] RDF_AGGREGATOR_OPTIONAL_ATTRIBUTES = { RDF_AGGREGATOR_ORDER_ATTRIBUTE, RDF_AGGREGATOR_FILTER_ATTRIBUTE };
+ private final static String[] RDF_AGGREGATOR_OPTIONAL_ATTRIBUTES = { };
private final static String[] RDF_AGGREGATOR_SUBNODES = { };
private String key;
super(RDF_AGGREGATOR_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributes(anAttributes, RDF_AGGREGATOR_REQUIRED_ATTRIBUTES, RDF_AGGREGATOR_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get( RDF_AGGREGATOR_KEY_ATTRIBUTE );
source = (String) anAttributes.get( RDF_AGGREGATOR_SOURCE_ATTRIBUTE );
- order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RDF_AGGREGATOR_SOURCE_ATTRIBUTE, "");
- filter = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RDF_AGGREGATOR_FILTER_ATTRIBUTE, "");
- };
+ }
public ProducerNode constructNode() {
- return new RDFAggregatorProducerNode(key, source, order, filter);
- };
+ return new RDFAggregatorProducerNode(key, source);
+ }
}
////////////////////////////////////////////////////////////////////////////////
}
public void setSubNode(String aName, ProducerNode aNode) {
- };
+ }
public Set getAvailableSubNodes() {
return new HashSet();
- };
+ }
public void setAttributes(Map anAttributes) throws ProducerConfigExc {
if (!anAttributes.isEmpty())
throw new ProducerConfigExc("No parameters allowed here");
- };
+ }
public ProducerNode constructNode() {
return new ScriptedProducerNodeDefinition.NodeParameterProducerNode(scriptedNodeName, parameterName);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
public void setSubNode(String aName, ProducerNode aNode) {
nodeParameterValues.put(aName, aNode);
- };
+ }
public Set getAvailableSubNodes() {
return definition.getNodeParameters();
- };
+ }
- public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
Iterator i = anAttributes.entrySet().iterator();
else
stringParameterValues.put(entry.getKey(), entry.getValue());
}
- };
+ }
public ProducerNode constructNode() {
return new ScriptedProducerNode(definition, stringParameterValues, integerParameterValues, nodeParameterValues);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private ScriptedProducerNodeDefinition definition;
projects / mir.git / blobdiff