X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=source%2Fmir%2Fproducer%2Freader%2FDefaultProducerNodeBuilders.java;h=1995de7c4af22153c7e934a0307aa490cc11a3c6;hb=10f4bb84a35aadd3a3fd5ba80fcf2ad9f2d54a0c;hp=90bef9d5ac73fecf05bbf13f43edc9ffcb79ea58;hpb=8297c34c7a424107fd7d1980b6e8e5a3ae26494b;p=mir.git diff --git a/source/mir/producer/reader/DefaultProducerNodeBuilders.java b/source/mir/producer/reader/DefaultProducerNodeBuilders.java index 90bef9d5..1995de7c 100755 --- a/source/mir/producer/reader/DefaultProducerNodeBuilders.java +++ b/source/mir/producer/reader/DefaultProducerNodeBuilders.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2001, 2002 The Mir-coders group + * Copyright (C) 2001-2006 The Mir-coders group * * This file is part of Mir. * @@ -19,8 +19,6 @@ * * 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 @@ -29,10 +27,12 @@ */ 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; @@ -40,6 +40,7 @@ import mir.entity.adapter.EntityAdapterModel; 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; @@ -48,7 +49,9 @@ import mir.producer.EntityEnumeratingProducerNode; 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; @@ -59,23 +62,24 @@ import mir.producer.LoopProducerNode; 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); @@ -86,6 +90,7 @@ public class DefaultProducerNodeBuilders { 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)); @@ -95,17 +100,15 @@ public class DefaultProducerNodeBuilders { 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)); } @@ -116,11 +119,11 @@ public class DefaultProducerNodeBuilders { public void setSubNode(String aName, ProducerNode aNode) { subNodes.put(aName, aNode); - }; + } public Set getAvailableSubNodes() { return availableSubnodes; - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -128,6 +131,7 @@ public class DefaultProducerNodeBuilders { // 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"; @@ -153,16 +157,16 @@ public class DefaultProducerNodeBuilders { 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); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -176,16 +180,16 @@ public class DefaultProducerNodeBuilders { 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); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -199,14 +203,17 @@ public class DefaultProducerNodeBuilders { 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; @@ -220,7 +227,7 @@ public class DefaultProducerNodeBuilders { 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); @@ -235,18 +242,25 @@ public class DefaultProducerNodeBuilders { 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; @@ -281,21 +295,20 @@ public class DefaultProducerNodeBuilders { 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; @@ -330,23 +343,23 @@ public class DefaultProducerNodeBuilders { 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; @@ -378,16 +391,16 @@ public class DefaultProducerNodeBuilders { 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 )); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -396,16 +409,18 @@ public class DefaultProducerNodeBuilders { 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; @@ -418,20 +433,25 @@ public class DefaultProducerNodeBuilders { 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; @@ -466,16 +486,16 @@ public class DefaultProducerNodeBuilders { 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; @@ -506,7 +526,7 @@ public class DefaultProducerNodeBuilders { 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); @@ -530,11 +550,11 @@ public class DefaultProducerNodeBuilders { } else type = LoggerWrapper.INFO_MESSAGE; - }; + } public ProducerNode constructNode() { return new LoggingProducerNode(message, type); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -557,7 +577,7 @@ public class DefaultProducerNodeBuilders { 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); @@ -582,20 +602,66 @@ public class DefaultProducerNodeBuilders { } 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 = {}; @@ -604,21 +670,21 @@ public class DefaultProducerNodeBuilders { 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); + } } //////////////////////////////////////////////////////////////////////////////// @@ -637,16 +703,16 @@ public class DefaultProducerNodeBuilders { 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); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -663,40 +729,50 @@ public class DefaultProducerNodeBuilders { 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); + } } //////////////////////////////////////////////////////////////////////////////// @@ -710,32 +786,32 @@ public class DefaultProducerNodeBuilders { 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; } @@ -759,39 +835,44 @@ public class DefaultProducerNodeBuilders { 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); } } } @@ -811,16 +892,19 @@ public class DefaultProducerNodeBuilders { 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; @@ -835,7 +919,7 @@ public class DefaultProducerNodeBuilders { 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" ); @@ -848,13 +932,21 @@ public class DefaultProducerNodeBuilders { 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, @@ -865,7 +957,7 @@ public class DefaultProducerNodeBuilders { getSubNode( BATCHER_BATCH_SUBNODE ), getSubNode( BATCHER_BATCHLIST_SUBNODE ) ); - }; + } public static class factory implements ProducerNodeBuilderFactory { private EntityAdapterModel model; @@ -897,11 +989,11 @@ public class DefaultProducerNodeBuilders { 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( @@ -909,7 +1001,7 @@ public class DefaultProducerNodeBuilders { getSubNode( IF_TRUE_SUBNODE ), getSubNode( IF_FALSE_SUBNODE ) ); - }; + } } @@ -918,31 +1010,34 @@ public class DefaultProducerNodeBuilders { 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); + } } //////////////////////////////////////////////////////////////////////////////// @@ -950,11 +1045,9 @@ public class DefaultProducerNodeBuilders { 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; @@ -966,18 +1059,16 @@ public class DefaultProducerNodeBuilders { 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); + } } //////////////////////////////////////////////////////////////////////////////// @@ -992,20 +1083,20 @@ public class DefaultProducerNodeBuilders { } 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); - }; + } } //////////////////////////////////////////////////////////////////////////////// @@ -1030,13 +1121,13 @@ public class DefaultProducerNodeBuilders { 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(); @@ -1048,11 +1139,11 @@ public class DefaultProducerNodeBuilders { 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;