X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=source%2Fmir%2Fproducer%2Freader%2FDefaultProducerNodeBuilders.java;h=f7fe8a3fe8544c747704b7e3d7838b97b7a84bfa;hb=55d0f77df79a52d553e93800d730aed1c7f0d485;hp=3c28b999d8f4a770c23a9988c629ea71274ea7fc;hpb=5b2d2279e1d26546a38c5cd3ba3e4f72192e351b;p=mir.git diff --git a/source/mir/producer/reader/DefaultProducerNodeBuilders.java b/source/mir/producer/reader/DefaultProducerNodeBuilders.java index 3c28b999..f7fe8a3f 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, 2002 The Mir-coders group * * This file is part of Mir. * @@ -18,30 +18,59 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * In addition, as a special exception, The Mir-coders gives permission to link - * the code of this program with the com.oreilly.servlet library, 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 exception - * to your version of the file, but you are not obligated to do so. If you do - * not wish to do so, delete this exception statement from your version. + * 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 + * exception to your version of the file, but you are not obligated to do so. + * If you do not wish to do so, delete this exception statement from your version. */ - package mir.producer.reader; -import java.util.*; -import mir.generator.*; -import mir.producer.*; -import mir.entity.adapter.*; -import mir.util.*; +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.entity.adapter.EntityAdapterModel; +import mir.generator.Generator; +import mir.generator.WriterEngine; +import mir.log.LoggerWrapper; +import mir.producer.ConditionalProducerNode; +import mir.producer.DirCopyingProducerNode; +import mir.producer.EntityBatchingProducerNode; +import mir.producer.EntityDeletingProducerNode; +import mir.producer.EntityEnumeratingProducerNode; +import mir.producer.EntityListProducerNode; +import mir.producer.EntityModifyingProducerNode; +import mir.producer.EvaluatedAssignmentProducerNode; +import mir.producer.ExpandedAssignmentProducerNode; +import mir.producer.FileDateSettingProducerNode; +import mir.producer.FileDeletingProducerNode; +import mir.producer.FreeQueryProducerNode; +import mir.producer.GeneratingProducerNode; +import mir.producer.ListEnumeratingProducerNode; +import mir.producer.LoggingProducerNode; +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.StringRoutines; +import mir.util.XMLReader; +import mir.util.XMLReaderTool; public class DefaultProducerNodeBuilders { public static void registerBuilders(ProducerNodeBuilderLibrary aBuilderLibrary, EntityAdapterModel aModel, Generator.GeneratorLibrary aGeneratorLibrary, - WriterEngine aWriterEngine, String aSourceBasePath, String aDestinationBasePath) { + WriterEngine aWriterEngine, String aSourceBasePath, String aDestinationBasePath) throws ProducerConfigExc { aBuilderLibrary.registerBuilder("Set", EvaluatedAssignmentProducerNodeBuilder.class); aBuilderLibrary.registerBuilder("Define", ExpandedAssignmentProducerNodeBuilder.class); @@ -55,10 +84,19 @@ public class DefaultProducerNodeBuilders { aBuilderLibrary.registerBuilder("If", ConditionalProducerNodeBuilder.class); aBuilderLibrary.registerBuilder("While", LoopProducerNodeBuilder.class); + aBuilderLibrary.registerBuilder("RSS", RSSProducerNodeBuilder.class); + aBuilderLibrary.registerBuilder("RDFAggregate", RDFAggregatorProducerNodeBuilder.class); + + aBuilderLibrary.registerBuilder("FreeQuery", FreeQueryProducerNodeBuilder.class); + aBuilderLibrary.registerFactory("Enumerate", new EnumeratingProducerNodeBuilder.factory(aModel)); aBuilderLibrary.registerFactory("List", new ListProducerNodeBuilder.factory(aModel)); aBuilderLibrary.registerFactory("Batch", new BatchingProducerNodeBuilder.factory(aModel)); + aBuilderLibrary.registerFactory("UpdateEntity", new UpdateEntityProducerNodeBuilder.factory(aModel)); + aBuilderLibrary.registerFactory("CreateEntity", new CreateEntityProducerNodeBuilder.factory(aModel)); + aBuilderLibrary.registerFactory("DeleteEntity", new DeleteEntityProducerNodeBuilder.factory(aModel)); + aBuilderLibrary.registerFactory("Generate", new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary, aWriterEngine)); } @@ -98,6 +136,7 @@ public class DefaultProducerNodeBuilders { public final static String SKIP_ATTRIBUTE = "skip"; public final static String KEY_ATTRIBUTE = "key"; public final static String LIMIT_ATTRIBUTE = "limit"; + public final static String URL_ATTRIBUTE = "url"; //////////////////////////////////////////////////////////////////////////////// @@ -116,8 +155,8 @@ public class DefaultProducerNodeBuilders { super(ASSIGNMENT_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES); key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE); value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE); @@ -139,8 +178,8 @@ public class DefaultProducerNodeBuilders { super(ASSIGNMENT_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES); key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE); value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE); @@ -156,17 +195,24 @@ public class DefaultProducerNodeBuilders { public static class EnumeratingProducerNodeBuilder extends AbstractProducerNodeBuilder { private final static String ENUMERATION_KEY_ATTRIBUTE = KEY_ATTRIBUTE; private final static String ENUMERATION_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE; + private final static String ENUMERATION_LIST_ATTRIBUTE = "list"; private final static String ENUMERATION_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE; private final static String ENUMERATION_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE; 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_REQUIRED_ATTRIBUTES = { ENUMERATION_KEY_ATTRIBUTE, ENUMERATION_DEFINITION_ATTRIBUTE }; - private final static String[] ENUMERATION_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE}; + private final static String ENUMERATION_EXTRATABLES_ATTRIBUTE = "extratables"; + 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,ENUMERATION_EXTRATABLES_ATTRIBUTE}; private final static String[] ENUMERATION_SUBNODES = {ENUMERATION_DEFAULT_SUBNODE}; private String key; private String definition; + private String mainTablePrefix; + private List extraTables; + private String list; private String selection; private String order; private String limit; @@ -179,19 +225,36 @@ public class DefaultProducerNodeBuilders { model = aModel; } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, ENUMERATION_REQUIRED_ATTRIBUTES, ENUMERATION_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE); + list = (String) anAttributes.get(ENUMERATION_LIST_ATTRIBUTE); + + if ((list==null && definition==null) || (list!=null && definition!=null)) + throw new ProducerConfigExc("Exactly one of "+ENUMERATION_DEFINITION_ATTRIBUTE+" and "+ENUMERATION_LIST_ATTRIBUTE+" must be set"); + + + if (list!=null) + XMLReaderTool.checkAttributes(anAttributes, ENUMERATION_LIST_REQUIRED_ATTRIBUTES, ENUMERATION_LIST_OPTIONAL_ATTRIBUTES); + if (definition!=null) + XMLReaderTool.checkAttributes(anAttributes, ENUMERATION_QUERY_REQUIRED_ATTRIBUTES, ENUMERATION_QUERY_OPTIONAL_ATTRIBUTES); + key = (String) anAttributes.get(ENUMERATION_KEY_ATTRIBUTE); - definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE); - selection = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, ""); - order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, ""); + selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, ""); + order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, ""); limit = (String) anAttributes.get(ENUMERATION_LIMIT_ATTRIBUTE); skip = (String) anAttributes.get(ENUMERATION_SKIP_ATTRIBUTE); + extraTables = StringRoutines.splitString(XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_EXTRATABLES_ATTRIBUTE,"").trim(), ","); + 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 EntityEnumeratingProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE )); + if (definition!=null) + return new EntityEnumeratingProducerNode(key, model, mainTablePrefix, extraTables, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE )); + else + return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE )); }; public static class factory implements ProducerNodeBuilderFactory { @@ -209,6 +272,106 @@ public class DefaultProducerNodeBuilders { //////////////////////////////////////////////////////////////////////////////// + public static class UpdateEntityProducerNodeBuilder extends AbstractProducerNodeBuilder { + private final static String UPDATE_KEY_ATTRIBUTE = KEY_ATTRIBUTE; + private final static String UPDATE_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE; + private final static String[] UPDATE_SUBNODES = {}; + + private String key; + private String definition; + private Map fieldValues; + + private EntityAdapterModel model; + + public UpdateEntityProducerNodeBuilder(EntityAdapterModel aModel) { + super(UPDATE_SUBNODES); + + model = aModel; + fieldValues = new HashMap(); + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + key = (String) anAttributes.get(UPDATE_KEY_ATTRIBUTE); + + if (key == null) + throw new XMLReader.XMLReaderExc("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; + + public factory(EntityAdapterModel aModel) { + model = aModel; + } + + public ProducerNodeBuilder makeBuilder() { + return new UpdateEntityProducerNodeBuilder(model); + } + } + } + +//////////////////////////////////////////////////////////////////////////////// + + public static class CreateEntityProducerNodeBuilder extends AbstractProducerNodeBuilder { + private final static String CREATEENTITY_KEY_ATTRIBUTE = KEY_ATTRIBUTE; + private final static String CREATEENTITY_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE; + private final static String[] CREATEENTITY_SUBNODES = {}; + + private String key; + private String definition; + private Map fieldValues; + + private EntityAdapterModel model; + + public CreateEntityProducerNodeBuilder(EntityAdapterModel aModel) { + super(CREATEENTITY_SUBNODES); + + model = aModel; + fieldValues = new HashMap(); + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + 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 + "'" ); + if (definition == null) + throw new XMLReader.XMLReaderExc("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; + + public factory(EntityAdapterModel aModel) { + model = aModel; + } + + public ProducerNodeBuilder makeBuilder() { + return new CreateEntityProducerNodeBuilder(model); + } + } + } + +//////////////////////////////////////////////////////////////////////////////// + public static class LoopProducerNodeBuilder extends AbstractProducerNodeBuilder { private final static String LOOP_CONDITION_ATTRIBUTE = "condition"; private final static String LOOP_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE; @@ -224,11 +387,11 @@ public class DefaultProducerNodeBuilders { super(LOOP_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, LOOP_REQUIRED_ATTRIBUTES, LOOP_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, LOOP_REQUIRED_ATTRIBUTES, LOOP_OPTIONAL_ATTRIBUTES); condition = (String) anAttributes.get(LOOP_CONDITION_ATTRIBUTE); - limit = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, ""); + limit = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, ""); }; public ProducerNode constructNode() { @@ -242,16 +405,19 @@ 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 = "extratables"; 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 List extraTables; private String selection; private String order; private String limit; @@ -264,19 +430,24 @@ public class DefaultProducerNodeBuilders { model = aModel; } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + 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) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, ""); - order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, ""); + selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, ""); + order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, ""); limit = (String) anAttributes.get(LIST_LIMIT_ATTRIBUTE); skip = (String) anAttributes.get(LIST_SKIP_ATTRIBUTE); + extraTables = StringRoutines.splitString(XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_EXTRATABLES_ATTRIBUTE,"").trim(), ","); + 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 { @@ -294,26 +465,144 @@ public class DefaultProducerNodeBuilders { //////////////////////////////////////////////////////////////////////////////// + public static class DeleteEntityProducerNodeBuilder extends AbstractProducerNodeBuilder { + private final static String DELETEENTITY_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE; + private final static String DELETEENTITY_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE; + private final static String[] DELETEENTITY_REQUIRED_ATTRIBUTES = { DELETEENTITY_SELECTION_ATTRIBUTE, DELETEENTITY_DEFINITION_ATTRIBUTE }; + private final static String[] DELETEENTITY_OPTIONAL_ATTRIBUTES = { }; + private final static String[] DELETEENTITY_SUBNODES = {}; + + private String definition; + private String selection; + + private EntityAdapterModel model; + + public DeleteEntityProducerNodeBuilder(EntityAdapterModel aModel) { + super(DELETEENTITY_SUBNODES); + + model = aModel; + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, DELETEENTITY_REQUIRED_ATTRIBUTES, DELETEENTITY_OPTIONAL_ATTRIBUTES); + + definition = (String) anAttributes.get(DELETEENTITY_DEFINITION_ATTRIBUTE); + selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, DELETEENTITY_SELECTION_ATTRIBUTE, ""); + }; + + public ProducerNode constructNode() { + return new EntityDeletingProducerNode(model, definition, selection); + }; + + public static class factory implements ProducerNodeBuilderFactory { + private EntityAdapterModel model; + + public factory(EntityAdapterModel aModel) { + model = aModel; + } + + public ProducerNodeBuilder makeBuilder() { + return new DeleteEntityProducerNodeBuilder(model); + } + } + } + +//////////////////////////////////////////////////////////////////////////////// + public static class LoggingProducerNodeBuilder extends AbstractProducerNodeBuilder { private final static String LOG_MESSAGE_ATTRIBUTE = "message"; + private final static String LOG_TYPE_ATTRIBUTE = "type"; private final static String[] LOG_REQUIRED_ATTRIBUTES = { LOG_MESSAGE_ATTRIBUTE }; - private final static String[] LOG_OPTIONAL_ATTRIBUTES = {}; + private final static String[] LOG_OPTIONAL_ATTRIBUTES = { LOG_TYPE_ATTRIBUTE }; private final static String[] LOG_SUBNODES = {}; private String message; + private int type = LoggerWrapper.INFO_MESSAGE; public LoggingProducerNodeBuilder() { super(LOG_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + String typeString; + + XMLReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES); message = (String) anAttributes.get(LOG_MESSAGE_ATTRIBUTE); + if (anAttributes.containsKey(LOG_TYPE_ATTRIBUTE)) { + typeString = ((String) anAttributes.get( LOG_TYPE_ATTRIBUTE )); + + if (typeString.toLowerCase().equals("debug")) + type = LoggerWrapper.DEBUG_MESSAGE; + else if (typeString.toLowerCase().equals("info")) + type = LoggerWrapper.INFO_MESSAGE; + else if (typeString.toLowerCase().equals("error")) + type = LoggerWrapper.ERROR_MESSAGE; + else if (typeString.toLowerCase().equals("warning")) + type = LoggerWrapper.WARN_MESSAGE; + else if (typeString.toLowerCase().equals("fatal")) + type = LoggerWrapper.FATAL_MESSAGE; + else + throw new ProducerConfigExc("unknown log type: " + typeString + " (allowed are debug, info, warning, error, fatal)"); + } + else + type = LoggerWrapper.INFO_MESSAGE; }; public ProducerNode constructNode() { - return new LoggingProducerNode(message); + return new LoggingProducerNode(message, type); + }; + } + +//////////////////////////////////////////////////////////////////////////////// + + public static class FreeQueryProducerNodeBuilder extends AbstractProducerNodeBuilder { + private final static String FREEQUERY_KEY_ATTRIBUTE = KEY_ATTRIBUTE; + private final static String FREEQUERY_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE; + private final static String FREEQUERY_QUERY_ATTRIBUTE = "query"; + private final static String FREEQUERY_TYPE_ATTRIBUTE = "type"; + private final static String[] FREEQUERY_REQUIRED_ATTRIBUTES = { KEY_ATTRIBUTE, FREEQUERY_QUERY_ATTRIBUTE }; + private final static String[] FREEQUERY_OPTIONAL_ATTRIBUTES = { LIMIT_ATTRIBUTE, FREEQUERY_TYPE_ATTRIBUTE }; + private final static String[] FREEQUERY_SUBNODES = {}; + + private String key; + private String query; + private String limit; + private int type; + + public FreeQueryProducerNodeBuilder() { + super(FREEQUERY_SUBNODES); + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + String typeString; + + XMLReaderTool.checkAttributes(anAttributes, FREEQUERY_REQUIRED_ATTRIBUTES, FREEQUERY_OPTIONAL_ATTRIBUTES); + + key = (String) anAttributes.get(FREEQUERY_KEY_ATTRIBUTE); + query = (String) anAttributes.get(FREEQUERY_QUERY_ATTRIBUTE); + limit = (String) anAttributes.get(FREEQUERY_LIMIT_ATTRIBUTE); + + if (anAttributes.containsKey(FREEQUERY_TYPE_ATTRIBUTE)) { + typeString = ((String) anAttributes.get( FREEQUERY_TYPE_ATTRIBUTE )); + + if (typeString.toLowerCase().equals("set")) + type = FreeQueryProducerNode.QUERY_TYPE_SET; + else if (typeString.toLowerCase().equals("row")) + type = FreeQueryProducerNode.QUERY_TYPE_ROW; + else if (typeString.toLowerCase().equals("value")) + type = FreeQueryProducerNode.QUERY_TYPE_VALUE; + else if (typeString.toLowerCase().equals("update")) + type = FreeQueryProducerNode.QUERY_TYPE_UPDATE; + else + throw new ProducerConfigExc("unknown query type: " + typeString + " (allowed are set, row and value)"); + } + else + type = FreeQueryProducerNode.QUERY_TYPE_SET; + }; + + public ProducerNode constructNode() { + return new FreeQueryProducerNode(key, query, limit, type); }; } @@ -336,8 +625,8 @@ public class DefaultProducerNodeBuilders { super(RESOURCEBUNDLE_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES); key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE); bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE); @@ -365,8 +654,8 @@ public class DefaultProducerNodeBuilders { super(FILEDATESETTING_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES); fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE); dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE); @@ -391,8 +680,8 @@ public class DefaultProducerNodeBuilders { super(FILEDELETING_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES); fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE); }; @@ -416,8 +705,8 @@ public class DefaultProducerNodeBuilders { super(SCRIPT_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES); command = (String) anAttributes.get(SCRIPT_COMMAND_ATTRIBUTE); }; @@ -448,8 +737,8 @@ public class DefaultProducerNodeBuilders { destinationBasePath = aDestinationBasePath; } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, DIRCOPY_REQUIRED_ATTRIBUTES, DIRCOPY_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, DIRCOPY_REQUIRED_ATTRIBUTES, DIRCOPY_OPTIONAL_ATTRIBUTES); source = (String) anAttributes.get(DIRCOPY_SOURCE_ATTRIBUTE); destination = (String) anAttributes.get(DIRCOPY_DESTINATION_ATTRIBUTE); @@ -497,12 +786,12 @@ public class DefaultProducerNodeBuilders { generatorLibrary = aGeneratorLibrary; } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES); generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE); destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE); - parameters = ReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" ); + parameters = XMLReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" ); }; public ProducerNode constructNode() { @@ -539,18 +828,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 = "extratables"; 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 }; - // ML: batchSize, minBatchSize, skip should be expressions! - private EntityAdapterModel model; private String batchDataKey; private String batchInfoKey; + private String mainTablePrefix; + private List extraTables; private String definition; private String selection; private String order; @@ -565,19 +855,23 @@ public class DefaultProducerNodeBuilders { model = aModel; } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES); - - batchDataKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" ); - batchInfoKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" ); - definition = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" ); - selection = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" ); - order = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" ); - - batchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, "20" ); - minBatchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, "0" ); - skip = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" ); - process = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" ); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES); + + batchDataKey = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" ); + batchInfoKey = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" ); + definition = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" ); + selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" ); + order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" ); + + batchSize = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, "20" ); + 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 = StringRoutines.splitString(XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_EXTRATABLES_ATTRIBUTE,"").trim(), ","); + 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() { @@ -585,6 +879,8 @@ public class DefaultProducerNodeBuilders { batchDataKey, batchInfoKey, model, + mainTablePrefix, + extraTables, definition, selection, order, @@ -627,8 +923,8 @@ public class DefaultProducerNodeBuilders { super(IF_SUBNODES); } - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES); condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE ); }; @@ -645,6 +941,73 @@ 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_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_SUBNODES = { }; + + private String key; + private String url; + private String version; + + public RSSProducerNodeBuilder() { + super(RSS_SUBNODES); + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + 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"); + }; + + public ProducerNode constructNode() { + return new RSSProducerNode(key, url, version); + }; + } + +//////////////////////////////////////////////////////////////////////////////// + + 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_SUBNODES = { }; + + private String key; + private String source; + private String order; + private String filter; + + public RDFAggregatorProducerNodeBuilder() { + super(RDF_AGGREGATOR_SUBNODES); + } + + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + 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); + }; + } + +//////////////////////////////////////////////////////////////////////////////// + public static class ScriptedProducerParameterNodeBuilder implements ProducerNodeBuilder { private String parameterName; private String scriptedNodeName; @@ -699,8 +1062,8 @@ public class DefaultProducerNodeBuilders { return definition.getNodeParameters(); }; - public void setAttributes(Map anAttributes) throws ProducerConfigExc { - ReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes()); + public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc { + XMLReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes()); Iterator i = anAttributes.entrySet().iterator(); while (i.hasNext()) {