--- /dev/null
+/**
+ * <b>abstrakte Basisklasse der Entity-Klassen</b><p>
+ */
+
+
+package mir.entity;
+
+import java.lang.*;
+import java.io.*;
+import java.util.*;
+import java.sql.*;
+
+import mir.storage.*;
+import mir.misc.*;
+
+/**
+ * abstrakte Basisklasse der Entity-Klassen
+ *
+ * @author RK
+ * @version 29.6.1999
+ *
+ */
+
+public class AbstractEntity implements Entity
+{
+ private boolean changed;
+ protected HashMap theValuesHash; // tablekey / value
+ protected StorageObject theStorageObject;
+ protected static Logfile theLog;
+ protected ArrayList streamedInput=null;
+ private static int instances = 0;
+ static {
+ theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("Entity.Logfile"));
+ }
+
+ public AbstractEntity() {
+ this.changed = false;
+ instances++;
+ }
+
+ /**
+ * Konstruktor
+ */
+ public AbstractEntity (StorageObject StorageObject) {
+ this();
+ setStorage(StorageObject);
+ }
+
+ /*
+ * Setzt das StorageObject der Entity.
+ */
+ public void setStorage (StorageObject storage) {
+ this.theStorageObject = storage;
+ }
+
+ /**
+ * Setzt die Werte der Entity
+ * @param theStringValues
+ */
+
+ public void setValues(HashMap theStringValues)
+ {
+ /** @todo should be synchronized */
+ theValuesHash = new HashMap();
+ String aKey;
+ Set set = theStringValues.keySet();
+ Iterator it = set.iterator();
+ int size = set.size();
+ for (int i = 0; i < size; i++) {
+ aKey = (String)it.next();
+ theValuesHash.put(aKey, (String)theStringValues.get(aKey));
+ }
+ }
+
+ /**
+ * Liefert boolschen Wert, ob sich der Inhalt der Entity geändert hat.
+ * @return true wenn ja, sonst false
+ */
+ public boolean changed () {
+ return changed;
+ }
+
+ /**
+ * Liefert den Primärschluessel der Entity zurueck
+ * @return String Id
+ */
+ public String getId () {
+ return (String)getValue(theStorageObject.getIdName());
+ }
+
+ /**
+ * Setzt den Primaerschluessel der Entity
+ * @param id
+ */
+ public void setId (String id) {
+ theValuesHash.put(theStorageObject.getIdName(), id);
+ }
+
+ /**
+ * Liefert den Wert für einen Feldnamen zurueck
+ * @param theFieldString
+ * @return Wert für Feld
+ */
+ public String getValue (String theFieldString) {
+ return (String)theValuesHash.get(theFieldString);
+ }
+
+ /**
+ * Fügt Entity via StorageObject in Datenbank ein.
+ * @return Primary Key der Entity
+ * @exception StorageObjectException
+ */
+ public String insert () throws StorageObjectException {
+ theLog.printDebugInfo("Entity: trying to insert ...");
+ if (theStorageObject != null) {
+ return theStorageObject.insert((Entity)this);
+ }
+ else
+ throw new StorageObjectException("Kein StorageObject gesetzt!");
+ }
+
+ /**
+ * Aktualisiert Aenderungen an der Entity in der Datenbank
+ * @exception StorageObjectException
+ */
+ public void update () throws StorageObjectException {
+ theStorageObject.update((Entity)this);
+ }
+
+ /**
+ * Setzt den Wert fuer ein Feld
+ * @param theProp
+ * @param theValue
+ * @exception StorageObjectException
+ */
+ public void setValueForProperty (String theProp, String theValue) throws StorageObjectException {
+ this.changed = true;
+ if (isField(theProp))
+ theValuesHash.put(theProp, theValue);
+ else
+ theLog.printWarning("Property not found: " + theProp);
+ }
+
+ /**
+ * Gibt die Feldnamen der Entity als ArrayList zurueck
+ * @return ArrayList mit Feldnamen
+ * @exception StorageObjectException wird geworfen, wenn kein Zugriff auf die Datenbank
+ * möglich.
+ */
+ public ArrayList getFields () throws StorageObjectException {
+ return theStorageObject.getFields();
+ }
+
+ /**
+ * Liefert ein int[] mit den Typen der Felder zurueck
+ * @return int[] mit den Feldtypen
+ * @exception StorageObjectException
+ */
+ public int[] getTypes () throws StorageObjectException {
+ return theStorageObject.getTypes();
+ }
+
+ /**
+ * Liefert ArrayListe mit Feldnamen zurueck.
+ * @return Liste mit Feldnamen
+ * @exception StorageObjectException
+ */
+ public ArrayList getLabels () throws StorageObjectException {
+ return theStorageObject.getLabels();
+ }
+
+ /**
+ * Liefert eine Hashmap mit allen Werten der Entity zurueck
+ * @return HashMap mit Feldname/Wert
+ */
+ public HashMap getValues() {
+ return theValuesHash;
+ }
+
+ /**
+ * Liefert einen ArrayList mit allen Datenbankfeldern, die
+ * als streamedInput ausgelesen werden muessen.
+ * Waere automatisierbar ueber die types (blob, etc.)
+ * Bisher manuell anzulegen in der erbenden Klasse
+ */
+
+ public ArrayList streamedInput() {
+ return streamedInput;
+ }
+
+ /* Fragt ab, ob fieldName einem Feld entspricht
+ * @param fieldName
+ * @return true, wennn ja, sonst false
+ * @exception StorageObjectException
+ */
+ public boolean isField (String fieldName) throws StorageObjectException {
+ return theStorageObject.getFields().contains(fieldName);
+ }
+
+ /** Liefert Anzahl der Instanzen zurück
+ * @return int
+ */
+ public int getInstances() {
+ return instances;
+ }
+ /**
+ * Gibt eine Instanz frei
+ */
+ public void finalize () {
+ instances--;
+ try {
+ super.finalize();
+ } catch (Throwable t) {
+ System.err.println(t.toString());
+ }
+ }
+}
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.entity;
+
+import java.lang.*;
+import java.util.*;
+import mir.storage.*;
+
+/**
+ * Interface-Definition für Entities
+ */
+
+public interface Entity {
+
+ /**
+ * Eine Entity muss setStorage implementieren, mit der eine Entity mit einem
+ * StorageObject assoziiert wird.
+ *
+ * @param st
+ */
+ public abstract void setStorage (StorageObject st);
+
+
+
+ /**
+ * Eine Entity muss setValues implementieren, mit der die Werte der Entity gesetzt werden
+ * können.
+ *
+ * @param ht
+ */
+ public abstract void setValues(HashMap ht);
+
+
+
+ /**
+ * Eine Entity muss getValues implementieren, mit der die Werte der Entity
+ * als HashMap zurueckgeliefert werden
+ * @return Werte der Entity
+ */
+ public abstract HashMap getValues();
+
+
+
+ /**
+ * Eine Entity muss getFields implementieren, mit der die Feldnamen der
+ * Entity zurueckgegeben werden.
+ * @return ArrayList der Feldnamen
+ * @exception StorageObjectException
+ */
+ public abstract ArrayList getFields () throws StorageObjectException;
+
+
+
+ /**
+ * Eine Entity muss getTypes implementieren, mit der die Feldtype der
+ * Entity zurueckgegeben werden.
+ * @return int[] der Feldtypen
+ * @exception StorageObjectException
+ */
+ public abstract int[] getTypes () throws StorageObjectException;
+
+
+
+ /**
+ * Eine Entity muss getLabels implementieren, mit der die Feldnamen der
+ * Entity zurueckgegeben werden.
+ * @return ArrayList der Feldnamen
+ * @exception StorageObjectException
+ */
+ public abstract ArrayList getLabels () throws StorageObjectException;
+
+
+
+ /**
+ * Eine Entity muss getId implementieren, um den Primaerschuessel der
+ * Entity zurueckgeliefert zu bekommen.
+ *
+ * @return Primary-Key der Entity
+ */
+ public abstract String getId();
+
+
+
+ /**
+ * Eine Entity muss setId implementieren, um den Primaerschuessel der
+ * Entity zu setzen
+ *
+ * @param str
+ */
+ public abstract void setId(String str);
+
+
+ /**
+ * Eine Entity muss getValue implementieren, um den Wert eines
+ * Feldes zurueckzugeben
+ *
+ * @param field
+ * @return Wert von Feld field
+ */
+ public abstract String getValue (String field);
+
+
+
+ /**
+ * Einfügen der Entity in StorageObject
+ *
+ * @return Primary-Key der eingefügten Entity
+ * @exception StorageObjectException
+ */
+ public abstract String insert () throws StorageObjectException;
+
+
+
+ /**
+ * Aktualisieren der Entity via StorageObject
+ * @exception StorageObjectException
+ */
+ public abstract void update () throws StorageObjectException;
+
+
+
+ /**
+ * ArrayListe mit Feldern, die einer Sonderbehandlung bedürfen (blobs)
+ * @return Liste der Feldnamen
+ */
+ public abstract ArrayList streamedInput ();
+
+
+ public abstract void setValueForProperty (String theProp, String theValue) throws StorageObjectException;
+
+
+}
+
+
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.entity;
+
+import java.lang.*;
+import java.util.*;
+import mir.misc.*;
+
+
+/**
+ *
+ * abstrakte Containerklasse für Listen von Entities.
+ *
+ * @author <RK>
+ * @version 27.6.1999
+ */
+public class EntityList {
+ private static Logfile theLog;
+ private ArrayList theEntityArrayList;
+ private String whereClause;
+ private String orderClause;
+ private int count;
+ private int offset;
+ private int offsetnext = -1;
+ private int offsetprev = -1;
+
+ /**
+ * Konstruktor für leere Liste von Entities
+ */
+ public EntityList(){
+ this.theEntityArrayList = new ArrayList();
+ if (theLog == null)
+ this.theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("Entity.Logfile"));
+ }
+
+ /**
+ * Setzt die WhereClause, mit der die Entitis dieser Liste geholt wurden.
+ * @param wc
+ */
+ public void setWhere(String wc) {
+ this.whereClause = wc;
+ }
+
+ /**
+ * Liefert die WhereClause zurueck, mit der die Entities geholt wurden.
+ * @return whereClause
+ */
+ public String getWhere() {
+ return whereClause;
+ }
+
+ /**
+ * Setzt das Sortierkriterium fest, mit der die Entities in die Liste
+ * gestellt wurden.
+ *
+ * @param oc
+ */
+ public void setOrder(String oc) {
+ this.orderClause = oc;
+ }
+
+ /**
+ * Liefert das Sortierkriterium der Liste zurueck.
+ * @return orderClause
+ */
+ public String getOrder() {
+ return orderClause;
+ }
+
+ /**
+ * Setzt die Anzahl der Datensätze fest, die WhereClause erfüllen.
+ * @param i
+ */
+ public void setCount(int i) {
+ this.count = i;
+ }
+
+ /**
+ * Liefert Anzahle der Datensätze, die WhereClause erfüllen.
+ * @return
+ */
+ public int getCount() {
+ return count;
+ }
+
+ /**
+ * Setzt den Offset fest.
+ * @param i
+ */
+ public void setOffset(int i) {
+ offset = i;
+ }
+
+ /**
+ * Liefert den Offset zurueck
+ * @return offset
+ */
+ public int getOffset() {
+ return offset;
+ }
+
+ /**
+ * Setzt den offset für das naechste Batch von Entities fest.
+ * @param i
+ */
+ public void setNextBatch(int i) {
+ offsetnext = i;
+ }
+
+ /**
+ * Liefert den offset für das naechste Batch von Entities
+ * @return offset für naechstes Batch
+ */
+ public int getNextBatch() {
+ return offsetnext;
+ }
+
+ /**
+ * Fragt ab, ob es noch nachfolgendes Batch innerhalb der WhereClause gibt
+ * @return
+ */
+ public boolean hasNextBatch() {
+ return (offsetnext >= 0);
+ }
+
+ /**
+ * Setzt offset des vorhergehenden Batches fest.
+ * @param i
+ */
+ public void setPrevBatch(int i) {
+ offsetprev = i;
+ }
+
+ /**
+ * Liefert offset des vorhergehenden Batches zurueck.
+ * @return offset des vorhergehenden Batches.
+ */
+ public int getPrevBatch() {
+ return offsetprev;
+ }
+
+ /**
+ * Fragt ab, ob es ein vorhergehendes Batch gibt
+ * @return true wenn ja, sont false
+ */
+ public boolean hasPrevBatch() {
+ return (offsetprev >= 0);
+ }
+
+ /**
+ * Liefert den Startindex des Batches zurueck.
+ * @return
+ */
+ public int getFrom() {
+ return offset+1;
+ }
+
+ /**
+ * Liefert den Endindex des Batches zurueck.
+ * @return
+ */
+ public int getTo() {
+ if (hasNextBatch())
+ return offsetnext;
+ else
+ return count;
+ }
+
+ /**
+ * Fügt eine Entity in die Liste ein
+ * @param anEntity
+ */
+ public void add (Entity anEntity) {
+ if (anEntity!=null)
+ theEntityArrayList.add(anEntity);
+ else
+ theLog.printWarning("add (EntityList) mit leerer Entity");
+ }
+
+ /**
+ * @return Anzahl der Entities in der Liste
+ */
+ public int size() {
+ return theEntityArrayList.size();
+ }
+
+
+
+
+
+
+ public Entity elementAt(int i) {
+ return (Entity)theEntityArrayList.get(i);
+ }
+
+}
--- /dev/null
+package mir.entity;
+
+import mir.storage.*;
+import mir.misc.*;
+import freemarker.template.*;
+
+public class EntityRelation {
+
+ public String fromId;
+ public String toId;
+ public StorageObject storage;
+ public int type;
+
+ public final static int TO_ONE = 1;
+ public final static int TO_MANY = 2;
+
+
+ /**
+ * Kontruktor fuer EntityRelation
+ * @param fromId ist der Feldname in der ausgehenden Tabelle fuer die Relation
+ * @param toId ist der Feldname in der Zieltablle
+ * @param storage ist das StorageObject, ueber das der Zugriff auf die abhaengige
+ * Tabelle erfolgt.
+ * @param type ist der Typ der EntityRelation (TO_ONE oder TO_MANY)
+ */
+
+ public EntityRelation(String fromId, String toId, StorageObject storage, int type) {
+ this.fromId = fromId;
+ this.toId = toId;
+ this.storage = storage;
+ this.type = type;
+ }
+
+ /**
+ * @return Liefert eine abhaengige Entity mit den verknuepften
+ * Entities, wenn es sich um eine TO_ONE Beziehung handelt, ansonsten
+ * null.
+ */
+
+ public Entity getOne(Entity entity) throws StorageObjectException {
+ if (type==TO_ONE) {
+ return storage.selectById(entity.getValue(fromId));
+ }
+ else return null;
+ }
+
+ /**
+ * @return Liefert ein freemarker.template.SimpleHash mit den verknuepften
+ * Entities, wenn es sich um eine TO_ONE Beziehung handelt, ansonsten
+ * null.
+ */
+
+ public SimpleHash getOneAsSimpleHash(Entity entity) throws StorageObjectException {
+ if (type==TO_ONE) {
+ Entity returnEntity = getOne(entity);
+ if (returnEntity!=null) return HTMLTemplateProcessor.makeSimpleHash(returnEntity);
+ }
+ return null;
+ }
+
+ /**
+ * @return Liefert eine freemarker.template.SimpleList mit den verknuepften
+ * Entities, wenn es sich um eine TO_MANY Liste handelt, ansonsten
+ * null.
+ */
+
+ public EntityList getMany(Entity entity) throws StorageObjectException{
+ if (type==TO_MANY) {
+ return storage.selectByFieldValue(toId, entity.getValue(fromId));
+ }
+ else return null;
+ }
+
+ /**
+ * @return Liefert eine freemarker.template.SimpleList mit den verknuepften
+ * Entities, wenn es sich um eine TO_MANY Liste handelt, ansonsten
+ * null.
+ */
+
+ public EntityList getMany(Entity entity, String order) throws StorageObjectException{
+ if (type==TO_MANY) {
+ return storage.selectByWhereClause(toId+"="+entity.getValue(fromId), order,-1);
+ }
+ else return null;
+ }
+
+ /**
+ * @return Liefert eine freemarker.template.SimpleList mit den verknuepften
+ * Entities, wenn es sich um eine TO_MANY Liste handelt, ansonsten
+ * null.
+ */
+
+ public SimpleList getManyAsSimpleList(Entity entity)
+ throws StorageObjectException {
+
+ if (type==TO_MANY) {
+ EntityList returnList = getMany(entity);
+ if (returnList!=null) return HTMLTemplateProcessor.makeSimpleList(returnList);
+ }
+ return null;
+ }
+
+ /**
+ * @return Liefert eine freemarker.template.SimpleList mit den verknuepften
+ * Entities, wenn es sich um eine TO_MANY Liste handelt, ansonsten
+ * null.
+ */
+
+ public SimpleList getManyAsSimpleList(Entity entity, String order)
+ throws StorageObjectException {
+
+ if (type==TO_MANY) {
+ EntityList returnList = getMany(entity, order);
+ if (returnList!=null) return HTMLTemplateProcessor.makeSimpleList(returnList);
+ }
+ return null;
+ }
+
+ /**
+ * @return Liefert den Referenznamen der abhaengigen Tabelle
+ */
+
+ public String getName() {
+ return "to" + storage.getTableName();
+ }
+
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * GenericEntity
+ */
+package mir.entity;
+
+/**
+ * Standard-Entity-Container. Wenn keine Zusatzfunktionalitaeten für die Kapselung einer
+ * Datenbankzeile nötig sind, d.h. zu einem Database-Objekt keine eigene Entity-Klasse
+ * implementiert wird, so wird dieser Standard-Container verwendet.
+ *
+ * @author /rk
+ * @version 1.2
+ */
+public class GenericEntity extends AbstractEntity
+ implements Entity {}
+
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.misc;
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+import java.lang.*;
+import com.javaexchange.dbConnectionBroker.*;
+
+
+/**
+ * Diese Klasse realisert den Zugriff auf die Konfiguration.
+ *
+ */
+public class Configuration {
+
+ private static HashMap confs = new HashMap(); // key: conffilename, confHash
+ private static HashMap c = new HashMap();
+ private String confFilename;
+ private static String defaultconfFilename;
+ private static int instances=0;
+ //static ResourceBundle conf = ResourceBundle.getBundle("config");
+ static ResourceBundle conf;
+
+ public static void initConfig(String confName) {
+ conf = ResourceBundle.getBundle(confName);
+ confs.put("confname",confName);
+ }
+
+ public static void addBroker(String driver, String URL){
+
+ System.err.println("--trying to add broker");
+ String username,passwd,min,max,log,reset;
+
+ if(!c.containsKey("Pool.broker")){
+ username=conf.getString("Database.Username");
+ passwd=conf.getString("Database.Password");
+ min=conf.getString("Database.poolMin");
+ max=conf.getString("Database.poolMax");
+ log=conf.getString("Home") + conf.getString("Database.PoolLog");
+ reset=conf.getString("Database.poolResetTime");
+
+ try{
+ System.err.println("-- making Broker for -"
+ +driver+" - " +URL
+ + " log " + log + " user "
+ + username + " pass: " + passwd);
+
+ DbConnectionBroker br = new DbConnectionBroker(driver,URL,username,passwd,(new Integer(min)).intValue(),
+ (new Integer(max)).intValue(),log,(new Float(reset)).floatValue());
+ if (br!=null){
+ instances++;
+ c.put("Pool.broker",br);
+ } else {
+ throw new Exception();
+ }
+ } catch(Exception e){
+ System.err.println("Der ConnectionBroker konnte nicht initializiert werden"+ e.toString());e.printStackTrace();
+ }
+ } // end if
+ }
+
+
+ /**
+ * Fragt ab, ob das Betriebssystem Windows ist.
+ * @return true wenn ja, sonst false.
+ */
+ public static boolean isWindows() {
+ return System.getProperty("os.name").toLowerCase().indexOf("win") >= 0;
+ }
+
+ /**
+ * Liefert Wert einer Property zurueck
+ * @param propName
+ * @return Wert der Property
+ */
+ public static String getProperty(String propName) { // default
+ return conf.getString(propName);
+ }
+
+ /**
+ * Liest eine Property eines Modules aus der Konfiguration
+ * @param filename
+ * @param theModule
+ * @param propName
+ * @return Wert der Property
+ */
+ public String getProperty(String filename ,String theModule, String propName) {
+ return getProperty(filename, theModule + "." + propName);
+ }
+
+ /**
+ * Liest eine Property aus der Konfiguration
+ * @param filename
+ * @param propName
+ * @return Wert der Property
+ */
+ public static String getProperty(String filename, String propName) {
+ if (filename != null) {
+ String prop = null;
+ HashMap conf = ((HashMap)confs.get("confname"));
+
+ if (conf == null) {
+ System.err.println("Keine Konfiguration fuer " + filename);
+ } else {
+ prop = (String)conf.get(propName);
+ }
+
+ if (prop == null) {
+ System.err.println("Keine Konfiguration fuer " + filename + " " + propName);
+ }
+
+ return prop;
+
+ } else {
+ System.err.println("--- filename null!");
+ }
+
+ return null;
+ }
+
+ /**
+ * Liefert DBConnectionBroker einer Configuration zurueck
+ * @param confFilename
+ * @return DBConnectionBroker
+ */
+ public static DbConnectionBroker getBroker() {
+ DbConnectionBroker broker=null;
+ broker=(DbConnectionBroker)c.get("Pool.broker");
+ if (broker==null) {
+ System.err.println("Konnte kein ConnectionPoolBroker initialisiert werden");
+ }
+ return broker;
+ }
+
+ /**
+ * Liefert Hashtabel mit den Konfigurationen
+ * @return
+ */
+ public static HashMap getConfs(){
+ return confs;
+ }
+
+ public static DbConnectionBroker getBrokerInfo(){
+ return (DbConnectionBroker)c.get("Pool.broker");
+ }
+
+
+ /**
+ * Finalize Methode
+ */
+ public void finalize(){
+ instances --;
+ try {
+ super.finalize();
+ } catch (Throwable t) {}
+ }
+
+ /**
+ * Liefert Anzahl der Instantiierten DBConnectionBroker zurueck
+ * @return
+ */
+ public static int getBrokerInstances() {
+ return instances;
+ }
+} //end of class
--- /dev/null
+package mir.misc;
+
+import java.lang.*;
+
+/*
+ * HTMLParseException -
+ * wird vom HTMLProcessor geschmissen</b>
+ *
+ *
+ * @version 30.6.199
+ * @author RK
+ */
+
+public class HTMLParseException extends Exception
+{
+ HTMLParseException(String msg) {
+ super(msg);
+ }
+}
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.misc;
+
+import java.lang.*;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import freemarker.template.*;
+import mir.entity.*;
+import mir.storage.*;
+
+
+/**
+ * Hilfsklasse zum Mergen von Template und Daten
+ */
+public final class HTMLTemplateProcessor {
+
+ public static String templateDir;
+ private static FileTemplateCache templateCache;
+ private static Logfile theLog;
+ private static String docRoot;
+ private static String actionRoot;
+ private static String productionHost;
+ private static String audioHost;
+ private static String videoHost;
+ private static String imageHost;
+ private static String openAction;
+ protected static String producerDocRoot = Configuration.getProperty("Producer.DocRoot");
+ protected static String producerStorageRoot = Configuration.getProperty("Producer.StorageRoot");
+
+
+ //
+ // Initialisierung
+
+ static {
+ templateDir = Configuration.getProperty("Home") + Configuration.getProperty("HTMLTemplateProcessor.Dir");
+ templateCache = new FileTemplateCache(templateDir);
+ templateCache.setLoadingPolicy(templateCache.LOAD_ON_DEMAND);
+ //templateCache.startAutoUpdate();
+ theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("HTMLTemplateProcessor.Logfile"));
+ docRoot = Configuration.getProperty("HTMLTemplateProcessor.DocRoot");
+ actionRoot = Configuration.getProperty("HTMLTemplateProcessor.ActionRoot");
+ openAction = Configuration.getProperty("Producer.OpenAction");
+ productionHost = Configuration.getProperty("Producer.ProductionHost");
+ videoHost = Configuration.getProperty("Producer.VideoHost");
+ audioHost = Configuration.getProperty("Producer.AudioHost");
+ imageHost = Configuration.getProperty("Producer.Image.Host");
+ producerDocRoot = Configuration.getProperty("Producer.DocRoot");
+ producerStorageRoot = Configuration.getProperty("Producer.StorageRoot");
+
+
+ }
+
+ /**
+ * Privater Konstruktor, um versehentliche Instantiierung zu verhindern
+ */
+ private HTMLTemplateProcessor () {
+ }
+
+
+ //
+ // process-Methoden zum Mischen verschiedener Datenstrukturen mit HTML-Templates
+
+
+ /**
+ * Wandelt <code>anEntity</code> in freemarker-Struktur um, mischt die Daten mit
+ * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param anEntity
+ * @param out
+ * @exception HTMLParseException
+ */
+
+ public static void process(String templateFilename, Entity anEntity, PrintWriter out)
+ throws HTMLParseException {
+ if (anEntity == null) throw new HTMLParseException("Entity leer!");
+ else process(templateFilename, anEntity, out);
+ }
+
+
+ /**
+ * Wandelt Liste mit Entities <code>entList</code> in freemarker-Struktur um, mischt die Daten mit
+ * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param entList
+ * @param out
+ * @exception HTMLParseException
+ */
+ public static void process(String templateFilename, EntityList entList, PrintWriter out)
+ throws HTMLParseException {
+ process( templateFilename, entList, (String)null, (TemplateModelRoot)null, out);
+ }
+
+ /**
+ * Wandelt Entitylist in freemarker-Struktur um, fügt <code>additionalModel</code>
+ * unter dem Namen <code>additionalModelName</code> ein und mischt die Daten mit
+ * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param entList
+ * @param additionalModelName
+ * @param additionalModel
+ * @param out
+ * @exception HTMLParseException
+ */
+ public static void process(String templateFilename, EntityList entList, String additionalModelName,
+ TemplateModelRoot additionalModel, PrintWriter out)
+ throws HTMLParseException {
+
+ SimpleHash modelRoot = new SimpleHash();
+
+ if (entList == null) {
+ //theLog.printInfo("Keine Daten! Suche erfolglos.");
+ process(templateFilename, modelRoot, out);
+ } else {
+ try {
+ modelRoot = makeSimpleHashWithEntitylistInfos(entList);
+ //
+ // Hilfskruecke um mal ein Popup mit reinzunhemen ..
+ if (additionalModelName != null && additionalModel != null)
+ modelRoot.put(additionalModelName, additionalModel);
+
+ process(templateFilename, modelRoot, out);
+ } catch (StorageObjectException e) {
+ throw new HTMLParseException(e.toString());
+ }
+ }
+ }
+
+ /**
+ * Wandelt HashMap <code>mergeData</code> in freemarker-Struktur und mischt diese mit
+ * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param mergeData
+ * @param out
+ * @exception HTMLParseException
+ */
+ public static void process(String templateFilename, HashMap mergeData, PrintWriter out)
+ throws HTMLParseException {
+ process(templateFilename, makeSimpleHash(mergeData), out);
+ }
+
+ /**
+ * Gibt Template <code>templateFilename</code> an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param mergeData
+ * @param out
+ * @exception HTMLParseException
+ */
+ public static void process(String templateFilename, PrintWriter out)
+ throws HTMLParseException {
+ process(templateFilename, (TemplateModelRoot)null, out);
+ }
+
+
+ /**
+ * Mischt die freemarker-Struktur <code>tmr</code> mit
+ * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
+ * <code>out</code>
+ *
+ * @param templateFilename
+ * @param mergeData
+ * @param out
+ * @exception HTMLParseException
+ */
+ public static void process(String templateFilename, TemplateModelRoot tmr, PrintWriter out)
+ throws HTMLParseException {
+ if (out==null) throw new HTMLParseException("KEIN OUTPUTSTREAM");
+ Template tmpl = getTemplateFor(templateFilename);
+ if (tmpl == null) throw new HTMLParseException("KEIN TEMPLATE: " + templateFilename);
+ if (tmr==null) tmr = new SimpleHash();
+
+ //some utilities
+ SimpleHash utilityHash = new SimpleHash();
+ utilityHash.put("htmlEscape",new freemarker.template.utility.HtmlEscape());
+
+ // put standard configuration into tempalteRootmodel
+ SimpleHash configHash = new SimpleHash();
+ configHash.put("docroot", new SimpleScalar(producerDocRoot));
+ configHash.put("storageroot", new SimpleScalar(producerStorageRoot));
+ configHash.put("productionhost", new SimpleScalar(productionHost));
+ configHash.put("openaction", new SimpleScalar(openAction));
+
+
+ tmr.put("docRoot", new SimpleScalar(docRoot));
+ tmr.put("now", new SimpleScalar(StringUtil.date2readableDateTime(new GregorianCalendar())));
+ tmr.put("actionRoot", new SimpleScalar(actionRoot));
+ tmr.put("openAction", new SimpleScalar(openAction));
+ tmr.put("productionHost", new SimpleScalar(productionHost));
+ tmr.put("videoHost", new SimpleScalar(videoHost));
+ tmr.put("audioHost", new SimpleScalar(audioHost));
+ tmr.put("imageHost", new SimpleScalar(imageHost));
+
+ tmr.put("config", configHash);
+ tmr.put("utility",utilityHash);
+ tmpl.process(tmr, out);
+
+ }
+
+
+ /**
+ * Wandelt eine Entity-Liste in eine SimpleList von SimpleHashes um.
+ * @param aList ist eine Liste von Entity
+ * @return eine freemarker.template.SimpleList von SimpleHashes.
+ */
+ public static SimpleList makeSimpleList(EntityList aList) throws StorageObjectException
+ {
+ SimpleList simpleList = new SimpleList();
+ if (aList != null) {
+ for(int i=0;i<aList.size();i++){
+ simpleList.add(makeSimpleHash(aList.elementAt(i)));
+ }
+ }
+ return simpleList;
+ }
+
+ /**
+ * Konvertiert ein EntityList in ein freemarker.template.SimpleHash-Modell. Im Hash
+ * sind die einzelnen Entities ueber ihre id zu erreichen.
+ * @param aList ist die EntityList
+ * @return SimpleHash mit den entsprechenden freemarker Daten
+ *
+ */
+ public static SimpleHash makeSimpleHash(EntityList aList) throws StorageObjectException
+ {
+ SimpleHash simpleHash = new SimpleHash();
+ Entity currentEntity;
+
+ if (aList != null) {
+ for (int i=0;i<aList.size();i++) {
+ currentEntity = (Entity)aList.elementAt(i);
+ simpleHash.put(currentEntity.getId(), makeSimpleHash(currentEntity));
+ }
+ }
+ return simpleHash;
+ }
+
+ /**
+ * Konvertiert ein Entity in ein freemarker.template.SimpleHash-Modell
+ * @param entity ist die Entity
+ * @return SimpleHash mit den entsprechenden freemarker Daten
+ *
+ */
+ public static SimpleHash makeSimpleHash(Entity entity) {
+ if (entity != null) {
+ return makeSimpleHash(entity.getValues());
+ }
+ else {
+ //theLog.printWarning("Entity ist <null>");
+ return null;
+ }
+ }
+
+ /**
+ * Konvertiert ein Hashtable mit den keys und values als String
+ * in ein freemarker.template.SimpleHash-Modell
+ * @param mergeData der HashMap mit den String / String Daten
+ * @return SimpleHash mit den entsprechenden freemarker Daten
+ *
+ */
+ public static SimpleHash makeSimpleHash(HashMap mergeData)
+ {
+ SimpleHash modelRoot = new SimpleHash();
+ String aField;
+ if (mergeData != null) {
+ Set set = mergeData.keySet();
+ Iterator it = set.iterator();
+ for (int i=0; i<set.size();i++) {
+ aField = (String)it.next();
+ modelRoot.put(aField, (String)mergeData.get(aField));
+ }
+ }
+ return modelRoot;
+ }
+
+
+ /**
+ * Wandelt EntityListe in SimpleHash um, und versieht die Liste mit StandardInfos,
+ * die aus EntityList kommen.
+ *
+ * @param entList
+ * @return SimpleHash mit Entity-Daten und ZusatzInfos.
+ * @exception StorageObjectException
+ */
+ public static SimpleHash makeSimpleHashWithEntitylistInfos(EntityList entList) throws StorageObjectException {
+ SimpleHash modelRoot = new SimpleHash();
+ if (entList!=null) {
+ modelRoot.put("contentlist", makeSimpleList(entList));
+ modelRoot.put("count", new SimpleScalar((new Integer(entList.getCount())).toString()));
+ if (entList.getWhere()!=null) {
+ modelRoot.put("where", new SimpleScalar(entList.getWhere()));
+ modelRoot.put("where_encoded", new SimpleScalar(URLEncoder.encode(entList.getWhere())));
+ }
+
+ if(entList.getOrder()!=null) {
+ modelRoot.put("order", new SimpleScalar(entList.getOrder()));
+ modelRoot.put("order_encoded", new SimpleScalar(URLEncoder.encode(entList.getOrder())));
+ }
+ modelRoot.put("from", new SimpleScalar((new Integer(entList.getFrom())).toString()));
+ modelRoot.put("to", new SimpleScalar((new Integer(entList.getTo())).toString()));
+
+ if (entList.hasNextBatch())
+ modelRoot.put("next", new SimpleScalar((new Integer(entList.getNextBatch())).toString()));
+ if (entList.hasPrevBatch())
+ modelRoot.put("prev", new SimpleScalar((new Integer(entList.getPrevBatch())).toString()));
+ }
+ return modelRoot;
+ }
+
+ /**
+ * Private Methode, um für templateFilename das Template zu bekommen.
+ * @param templateFilename
+ * @return Template
+ * @exception HTMLParseException
+ */
+ private static Template getTemplateFor(String templateFilename) throws HTMLParseException
+ {
+ if (templateFilename!=null) return templateCache.getTemplate(templateFilename);
+ else {
+ theLog.printError("CACHE (ERR): Unknown template: " + templateFilename);
+ throw new HTMLParseException("Templatedatei: "+ templateFilename + " nicht gefunden!");
+ }
+ }
+
+
+ public static void stopAutoUpdate(){
+ templateCache.stopAutoUpdate();
+ templateCache=null;
+ }
+}
--- /dev/null
+package mir.misc;
+
+import java.io.IOException;
+
+/**
+ * Title: Indy
+ * Description: This class provides some satic help methods
+ * Copyright: Copyright (c) 2001
+ * Company: indymedia.de
+ * @author idfx
+ * @version 1.0
+ */
+
+public class Helper {
+
+ /**
+ * rsync the webrepository
+ * needs a rsyncscript
+ * returns the exit-code
+ */
+ public static int rsync(){
+ Process p;
+ int returnValue = -1;
+ try {
+ Runtime run = Runtime.getRuntime();
+ p = run.exec(Configuration.getProperty("Sync.Script.Path"));
+ returnValue = p.waitFor();
+ } catch (IOException e) {
+ return returnValue;
+ } catch (InterruptedException e) {
+ return returnValue;
+ }
+ return returnValue;
+ }
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import com.icl.saxon.ExtendedInputSource;
+
+/**
+ * Title:
+ * Description:
+ * Copyright: Copyright (c) 2001
+ * Company:
+ * @author
+ * @version 1.0
+ */
+
+
+public class InputSourceResolver {
+ private static InputSourceResolver single = new InputSourceResolver();
+ private String prefix = "";
+
+ /**
+ * InputSourceResolver constructor comment.
+ */
+ private InputSourceResolver() {
+ super();
+ }
+
+ /**
+ * Singleton Constructor
+ * @return de.matetrade.tools.InputSourceResolver
+ */
+ private static InputSourceResolver getInstance() {
+ return single;
+ }
+
+ /**
+ * This method was created in VisualAge.
+ * @return InputStream
+ * @param key java.lang.String
+ */
+ private InputStream getFileInputStream( String key )
+ throws IOException {
+
+ FileInputStream is = null;
+ try {
+ is = new FileInputStream( prefix + key );
+ } catch ( FileNotFoundException ex ) {
+ throw new IOException( "FileNotFoundExcpetion: input for <" + key + "> not found" );
+ }
+
+ return is;
+ }
+
+
+ /**
+ * This method was created in VisualAge.
+ * @return org.xml.sax.InputSource
+ * @param key java.lang.String
+ */
+ public static InputSource resolve( String key )
+ throws IOException {
+
+ InputSource is = new InputSource( single.getFileInputStream( key ) );
+ if ( key.indexOf( ':' ) >= 0 ) {
+ is.setSystemId( "file:///" + key ); // special for win (file:///c:/xxx)
+ } else {
+ is.setSystemId( "file://" + key );
+ }
+
+ return is;
+ }
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+import java.io.*;
+
+/**
+ * LineFilterWriter schneidet unsinnige \t \r \n ` ` raus
+ *
+ **/
+public final class LineFilterWriter extends PrintWriter{//extends java.io.FilterWriter{
+
+
+ public LineFilterWriter(Writer out) {
+ super(out);
+ }
+
+ public final void write(String str){
+ int i,j,len;
+ boolean state=true;
+ char c;
+ len=str.length();
+ if (len==1) {try{out.write(str);}catch(IOException e){}return;}
+ StringBuffer sbuf = new StringBuffer();
+
+ for(i=0;i<len;i++) {
+ c=str.charAt(i);
+ if(state) {
+ j = str.indexOf('\n',i);
+ if (j==-1) j=len-1;
+ sbuf.append(str.substring(i,j+1));
+ i=j;
+ state=false;
+ }
+ else
+ if (!Character.isWhitespace(c)) {
+ sbuf.append(c);
+ state=true;
+ }
+ }
+ try{out.write(sbuf.toString());}catch(IOException e){;}
+ }
+
+ public final void write(char[] cbuf, int off,int len){
+ int i,j=off;
+ boolean state=true;
+ char c;
+
+ for(i=off;i<len;i++) {
+ c=cbuf[i];
+ if(state) {
+ if (c=='\n') state=false;
+ cbuf[j++]=c;
+ }
+ else
+ if (!Character.isWhitespace(c)) {
+ cbuf[j++]=c;
+ state=true;
+ }
+ }
+ try{out.write(cbuf,off,j);}catch(IOException e){;}
+ }
+
+
+}
--- /dev/null
+/*
+ * put your module comment here
+ */
+package mir.misc;
+
+import java.util.*;
+import java.io.*;
+
+
+/**
+ * Hilfs-Klasse, die in Logfiles schreibt.
+ *
+ */
+public final class Logfile {
+ public static final int LOG_INFO = 0;
+ public static final int LOG_WARNING = 1;
+ public static final int LOG_ERROR = 2;
+ public static final int LOG_DEBINFO = 3;
+
+ private static String lineSeparator;
+
+ private static HashMap /* filename / instance */ instanceRepository;
+ private RandomAccessFile raf;
+ private String fileName;
+
+ /**
+ * lineSeparator ermitteln und Repository anlegen
+ */
+ static {
+ // System.runFinalizersOnExit(true);
+ lineSeparator = System.getProperty("line.separator");
+ instanceRepository = new HashMap();
+ }
+
+ /**
+ * Singleton zurueckliefern, anhand des Filenamens,
+ * also pro <code>fileName</code> wird eine Instanz der Logfileklassen
+ * angelegt.
+ *
+ * @param fileName
+ * @return Logfile
+ */
+ public static Logfile getInstance(String fileName) {
+ Logfile returnLogfile = null;
+ System.err.println(fileName);
+ if (fileName != null) {
+ if (instanceRepository.containsKey(fileName)) {
+ returnLogfile = (Logfile) instanceRepository.get(fileName);
+ } else {
+ returnLogfile = new Logfile(fileName);
+ instanceRepository.put(fileName, returnLogfile);
+ }
+ } else {
+ System.err.println("Fehler bei Instantiierung von Logfile");
+ }
+ return returnLogfile;
+ }
+
+ /**
+ * Privater Konstruktor
+ * @param String fileName
+ */
+ private Logfile(String fileName){
+ this.fileName = fileName;
+ try {
+ File f = new File(fileName);
+ File dir = new File(f.getParent());
+ dir.mkdirs();
+ raf = new RandomAccessFile(fileName, "rw");
+ } catch (IOException e) {
+ System.err.println("Could not open logfile '"+fileName+"'");
+ }
+ }
+
+ /**
+ * Private Methode, um eine Zeile auszugeben
+ *
+ * @param type Typ der Logfilezeile (INFO, WARNING, ERROR, DEBUG)
+ * @param text Lognachricht
+ * @todo an dieser Stelle koennte statt in das File in die Datenbank geloggt werden.
+ */
+ private void print(int type, String text) {
+ if (text == null) text = "null";
+ text = text.replace('\n', ' ');
+
+ String typeText =
+ type == LOG_DEBINFO ? "DEBINFO " :
+ type == LOG_INFO ? "INFO " :
+ type == LOG_WARNING ? "WARNING " :
+ type == LOG_ERROR ? "ERROR " :
+ "? ";
+
+ String sectionText = text;
+ GregorianCalendar date = new GregorianCalendar();
+
+ String line = StringUtil.pad2(date.get(Calendar.DATE))+"-"+
+ StringUtil.pad2(date.get(Calendar.MONTH)+1)+"-"+
+ StringUtil.pad2(date.get(Calendar.YEAR) % 100)+" ";
+ int hour = date.get(Calendar.HOUR);
+ if (date.get(Calendar.AM_PM) == Calendar.PM) hour+=12;
+ line += StringUtil.pad2(hour)+":"+
+ StringUtil.pad2(date.get(Calendar.MINUTE))+":"+
+ StringUtil.pad2(date.get(Calendar.SECOND))+" "+
+ typeText+sectionText;
+
+ print(line);
+ }
+
+ /**
+ * Interne Ausgabeprozedur.
+ * Erfordert etwas Handarbeit, da PrintStream nicht mit RandomAcccessFile
+ * kooperiert. Und ein RandomAccessFile brauchen wir, weil FileOutputStream
+ * kein "append" zuläßt.
+ *
+ */
+ private void print(String line) {
+ if (raf == null) return;
+ line += lineSeparator;
+ // byte[] buf = new byte[line.length()];
+ //line.getBytes(0, line.length(), buf, 0);
+
+ byte[] buf = line.getBytes();
+
+ try {
+ raf.seek(raf.length());
+ raf.write(buf, 0, line.length());
+ } catch (IOException e) {
+ System.err.print("Could not write logfile line: "+line);
+ }
+ }
+
+ /**
+ * Schreibt Information <code>text</code> ins Logfil.
+ * @param text
+ */
+ public void printInfo (String text) {
+ print(LOG_INFO, text);
+ }
+
+ /**
+ * Schreibt Warnung <code>text</code> ins Logfile.
+ * @param text
+ */
+ public void printWarning (String text) {
+ print(LOG_WARNING, text);
+ }
+
+ /**
+ * Schreibt Fehlermeldung <code>text</code> ins Logfile.
+ * @param text
+ */
+ public void printError (String text) {
+ print(LOG_ERROR, text);
+ }
+
+ /**
+ * Schreibt Debuginformation <code>text</code> ins Logfile.
+ * @param text
+ */
+ public void printDebugInfo (String text) {
+ print(LOG_DEBINFO, text);
+ }
+
+ /**
+ * Finalize-Methode, die alle offenen Dateien schliesst.
+ */
+ public void finalize () {
+ if (raf != null) {
+ try {
+ raf.close();
+ } catch (IOException e) {}
+ raf = null;
+ }
+ staticFinalize(fileName);
+ try {
+ super.finalize();
+ } catch (Throwable t) {
+ ;
+ }
+ }
+
+ /**
+ * Static-Finalizer
+ * @param fileName
+ */
+ private static synchronized void staticFinalize (String fileName) {
+ instanceRepository.remove(fileName);
+ }
+}
+
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.misc;
+
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+import gnu.regexp.*;
+
+/**
+ * Statische Hilfsmethoden zur Stringbehandlung
+ *
+ * @version 29.6.99
+ * @author RK
+ */
+public final class StringUtil {
+
+ /**
+ * Wandelt Datum in einen 8-ziffrigen String um (yyyymmdd)
+ * @param theDate
+ * @return 8-ziffriger String (yyyymmdd)
+ */
+
+ public static final String date2webdbDate (GregorianCalendar theDate) {
+ StringBuffer webdbDate = new StringBuffer();
+ webdbDate.append(String.valueOf(theDate.get(Calendar.YEAR)));
+ webdbDate.append(pad2(theDate.get(Calendar.MONTH) + 1));
+ webdbDate.append(pad2(theDate.get(Calendar.DATE)));
+ return webdbDate.toString();
+ }
+
+ /**
+ * wandelt Calendar in dd.mm.yyyy / hh.mm um
+ * @param theDate
+ * @return String mit (dd.mm.yyyy / hh.mm um)
+ */
+ public static String date2readableDateTime (GregorianCalendar theDate) {
+ String readable = "";
+ int hour;
+ readable += pad2(theDate.get(Calendar.DATE));
+ readable += "." + pad2(theDate.get(Calendar.MONTH) + 1);
+ readable += "." + String.valueOf(theDate.get(Calendar.YEAR));
+ hour = theDate.get(Calendar.HOUR);
+ if (theDate.get(Calendar.AM_PM) == Calendar.PM)
+ hour += 12;
+ readable += " / " + pad2(hour);
+ readable += ":" + pad2(theDate.get(Calendar.MINUTE));
+ return readable;
+ }
+
+ /**
+ * wandelt eine Datum in einen 8-buchstabigen String, der durch <code>/</code>
+ * getrennt ist.
+ *
+ * @param webdbDate
+ * @return String mit <code>/yyyy/mm/dd</code>
+ */
+ public static final String webdbDate2path (String webdbDate) {
+ StringBuffer path = new StringBuffer();
+ path.append("/").append(webdbDate.substring(0, 4));
+ path.append("/").append(webdbDate.substring(4, 6));
+ path.append("/").append(webdbDate.substring(6, 8));
+ return path.toString();
+ }
+
+ /**
+ * wandelt Calendar in dd.mm.yyyy um
+ *
+ * @param theDate
+ * @return String mit <code>dd.mm.yyyy</code>
+ */
+ public static final String webdbDate2readableDate (String webdbDate) {
+ String date = "";
+ date += webdbDate.substring(6, 8);
+ date += "." + webdbDate.substring(4, 6);
+ date += "." + webdbDate.substring(0, 4);
+ return date;
+ }
+
+
+ /**
+ * converts string from format: yyyy-mm-dd__hh:mm:ss.d
+ * to dd.mm.yyyy hh:mm
+ */
+ public static String dateToReadableDate(String date) {
+ StringBuffer returnDate = new StringBuffer();
+ if (date!=null) {
+
+ returnDate.append(date.substring(8,10)).append('.');
+ returnDate.append(date.substring(5,7)).append('.');
+ returnDate.append(date.substring(0,4)).append(' ');
+ returnDate.append(date.substring(11,16));
+ }
+ return returnDate.toString();
+ }
+
+
+ /**
+ * schließt einen String in Anführungsszeichen ein, falls er Leerzeichen o.ä. enthält
+ *
+ * @return gequoteter String
+ */
+ public static String quoteIfNecessary(String s) {
+ for (int i = 0; i < s.length(); i++)
+ if (!(Character.isLetterOrDigit(s.charAt(i)) || s.charAt(i) == '.'))
+ return quote(s, '"');
+ return s;
+ }
+
+ /**
+ * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
+ * "gefährliche" Zeichen innerhalb des Strings
+ * Quotes special SQL-characters in <code>s</code>
+ *
+ * @return geqoteter String
+ */
+ public static String quote(String s)
+ {
+ //String s2 = quote(s, '\'');
+
+ //Quickhack
+ //Because of '?-Bug in Postgresql-JDBC-Driver
+ StringBuffer temp = new StringBuffer();
+ for(int i=0;i<s.length();i++){
+ if(s.charAt(i)=='\''){
+ temp.append("´");
+ } else {
+ temp.append(s.charAt(i));
+ }
+ }
+ String s2 = temp.toString();
+ //Quickhack end
+
+ s2 = quote(s2, '\"');
+ return s2;
+ }
+
+ /**
+ * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
+ * "gefährliche" Zeichen innerhalb des Strings
+ *
+ * @param s String, der gequoted werden soll
+ * @param quoteChar zu quotendes Zeichen
+ * @return gequoteter String
+ */
+ public static String quote(String s, char quoteChar)
+ {
+ StringBuffer buf = new StringBuffer(s.length());
+ int pos = 0;
+ while (pos < s.length()) {
+ int i = s.indexOf(quoteChar, pos);
+ if (i < 0) i = s.length();
+ buf.append(s.substring(pos, i));
+ pos = i;
+ if (pos < s.length()) {
+ buf.append('\\');
+ buf.append(quoteChar);
+ pos++;
+ }
+ }
+ return buf.toString();
+ }
+
+ /**
+ * ersetzt gefährliche zeichen in <code>s</code>
+ *
+ */
+
+ public static String unquote(String s)
+ {
+ char quoteChar='\'';
+ StringBuffer buf = new StringBuffer(s.length());
+ int pos = 0;
+ String searchString = "\\"+quoteChar;
+ while (pos < s.length()) {
+ int i = s.indexOf(searchString, pos);
+ if (i < 0) i = s.length();
+ buf.append(s.substring(pos, i));
+ pos = i+1;
+ }
+ return buf.toString();
+ }
+
+ /**
+ * Wandelet String in byte[] um.
+ * @param s
+ * @return byte[] des String
+ */
+
+ public static byte[] stringToBytes(String s) {
+ String crlf = System.getProperty("line.separator");
+ if (!crlf.equals("\n"))
+ s = replace(s, "\n", crlf);
+ // byte[] buf = new byte[s.length()];
+ byte[] buf = s.getBytes();
+ return buf;
+ }
+
+ /**
+ * Ersetzt in String <code>s</code> das <code>pattern</code> durch <code>substitute</code>
+ * @param s
+ * @param pattern
+ * @param substitute
+ * @return String mit den Ersetzungen
+ */
+ public static String replace(String s, String pattern, String substitute) {
+ int i = 0, pLen = pattern.length(), sLen = substitute.length();
+ StringBuffer buf = new StringBuffer(s.length());
+ while (true) {
+ int j = s.indexOf(pattern, i);
+ if (j < 0) {
+ buf.append(s.substring(i));
+ break;
+ } else {
+ buf.append(s.substring(i, j));
+ buf.append(substitute);
+ i = j+pLen;
+ }
+ }
+ return buf.toString();
+ }
+
+
+ /**
+ * Fügt einen Separator an den Pfad an
+ * @param path
+ * @return Pfad mit Separator am Ende
+ */
+ public static final String addSeparator (String path) {
+ return path.length() == 0 || path.endsWith(File.separator) ? path : path
+ + File.separatorChar;
+ }
+
+ /**
+ * Fügt ein <code>/</code> ans ende des Strings and
+ * @param path
+ * @return Pfad mit <code>/</code> am Ende
+ */
+ public static final String addSlash (String path) {
+ return path.length() == 0 || path.endsWith("/") ? path : path + '/';
+ }
+
+ /**
+ * Löscht <code>/</code> am Ende des Strings, falls vorhanden
+ * @param path
+ * @return String ohne <code>/</code> am Ende
+ */
+ public static final String removeSlash (String path) {
+ return path.length() > 1 && path.endsWith("/") ? path.substring(0, path.length()
+ - 1) : path;
+ }
+
+ /**
+ * Löscht Slash am Anfang des Strings
+ * @param path
+ * @return
+ */
+ public static String removeFirstSlash (String path) {
+ return path.startsWith("/") ? path.substring(1) : path;
+ }
+
+ /**
+ * formatiert eine Zahl (0-99) zweistellig (z.B. 5 -> 05)
+ * @return zwistellige Zahl
+ */
+ public static String pad2 (int number) {
+ return number < 10 ? "0" + number : String.valueOf(number);
+ }
+
+ /**
+ * formatiert eine Zahl (0-999) dreistellig (z.B. 7 -> 007)
+ *
+ * @return 3-stellige Zahl
+ */
+ public static String pad3 (int number) {
+ return number < 10 ? "00" + number : number < 100 ? "0" + number : String.valueOf(number);
+ }
+
+ /**
+ * Konvertiert Unix-Linefeeds in Win-Linefeeds
+ * @param s
+ * @return Konvertierter String
+ */
+ public static String unixLineFeedsToWin(String s) {
+ int i = -1;
+ while (true) {
+ i = s.indexOf('\n', i+1);
+ if (i < 0) break;
+ if ((i == 0 || s.charAt(i-1) != '\r') &&
+ (i == s.length()-1 || s.charAt(i+1) != '\r')) {
+ s = s.substring(0, i)+'\r'+s.substring(i);
+ i++;
+ }
+ }
+ return s;
+ }
+
+
+ /**
+ * verwandelt einen String in eine gültige Url, konvertiert Sonderzeichen
+ * und Spaces werden zu Underscores
+ *
+ * @return gültige Url
+ */
+ public static String convert2url(String s) {
+ s = toLowerCase(s);
+ StringBuffer buf = new StringBuffer();
+ for(int i = 0; i < s.length(); i++ ) {
+ switch( s.charAt( i ) ) {
+ case 'ö':
+ buf.append( "oe" ); break;
+ case 'ä':
+ buf.append( "ae" ); break;
+ case 'ü':
+ buf.append( "ue" ); break;
+ case 'ã':
+ buf.append( "a" ); break;
+ case '´':
+ case '.':
+ buf.append( "_" ); break;
+ case ' ':
+ if( buf.charAt( buf.length() - 1 ) != '_' ) {
+ buf.append( "_" );
+ }
+ break;
+ default:
+ buf.append( s.charAt( i ) );
+ }
+ }
+ return buf.toString();
+ }
+
+ /**
+ * wandelt Sonderzeichen in Quotes um
+ *
+ * @return Kovertierter String
+ */
+ public static String encodeHtml(String s) {
+ StringBuffer buf = new StringBuffer();
+ for(int i=0;i < s.length(); i++ ) {
+
+ /** @todo looks inefficient */
+ if (s.charAt(i)=='&') {
+ // convert html to xml-parsable representation
+ if( s.indexOf( "ö", i ) == i ) {
+ buf.append( "ö" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ä", i ) == i ) {
+ buf.append( "ä" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ü", i ) == i ) {
+ buf.append( "ü" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ö", i ) == i ) {
+ buf.append( "Ö" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ä", i ) == i ) {
+ buf.append( "Ä" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ü", i ) == i ) {
+ buf.append( "Ü" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ß", i ) == i ) {
+ buf.append( "ß" ); i += 6;
+ continue;
+ }
+
+ /** @todo should only escape outside of tags */
+
+ if( s.indexOf( """, i ) == i ) {
+ buf.append( "ß" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "–", i ) == i ) {
+ buf.append( "–" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( "—", i ) == i ) {
+ buf.append( "—" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( "“", i ) == i ) {
+ buf.append( "“" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( "”", i ) == i ) {
+ buf.append( "”" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( "„", i ) == i ) {
+ buf.append( "„" ); i += 6;
+ continue;
+ }
+
+ //looks pretty stupid
+ if( s.indexOf( "<", i ) == i ) {
+ buf.append( "<" ); i += 3;
+ continue;
+ }
+ if( s.indexOf( ">", i ) == i ) {
+ buf.append( ">" ); i += 3;
+ continue;
+ }
+ if( s.indexOf( "´", i ) == i ) {
+ buf.append( "´" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( " ", i ) == i ) {
+ buf.append( " " ); i += 5;
+ continue;
+ }
+ //has to be the last
+ if( s.indexOf( "&", i ) == i ) {
+ buf.append( "&" ); i += 0;
+ continue;
+ }
+ }
+ // convert umlauts an other special charakters
+ switch( s.charAt(i) ) {
+ case 'ö': buf.append( "ö" ); break;
+ case 'ä': buf.append( "ä" ); break;
+ case 'ü': buf.append( "ü" ); break;
+ case 'Ö': buf.append( "Ö" ); break;
+ case 'Ä': buf.append( "Ä" ); break;
+ case 'Ü': buf.append( "Ü" ); break;
+ case 'ß': buf.append( "ß" ); break;
+ case 'é': buf.append( "é" ); break;
+ case 'è': buf.append( "è" ); break;
+ case 'á': buf.append( "á" ); break;
+ case 'à': buf.append( "à" ); break;
+ case 'â': buf.append( "â" ); break;
+ case 'ã': buf.append( "ã" ); break;
+ case '¬': buf.append( "¬" ); break;
+ case '¹': buf.append( "¹" ); break;
+ case '²': buf.append( "²" ); break;
+ case '³': buf.append( "³" ); break;
+ case '¼': buf.append( "¼" ); break;
+ case '½': buf.append( "½" ); break;
+ case '¾': buf.append( "¾" ); break;
+ case '¶': buf.append( "¶" ); break;
+ case 'æ': buf.append( "æ" ); break;
+ case 'ð': buf.append( "ð" ); break;
+ case '|': buf.append( "¦" ); break;
+ case '·': buf.append( "·" ); break;
+ case '°': buf.append( "°" ); break;
+ case '§': buf.append( "§" ); break;
+ case 'ø': buf.append( "ø" ); break;
+ case 'ç': buf.append( "ç" ); break;
+ case '¤': buf.append( "¤" ); break;
+ case 'ª': buf.append( "ª" ); break;
+ case 'Ç': buf.append( "Ç" ); break;
+ case 'Ã': buf.append( "Ã" ); break;
+ case 'Â': buf.append( "Â" ); break;
+ case 'Æ': buf.append( "Æ" ); break;
+ case '©': buf.append( "©" ); break;
+ case '®': buf.append( "®" ); break;
+ case '¥': buf.append( "¥" ); break;
+ case 'Þ': buf.append( "þ" ); break;
+ case '¯': buf.append( "¯" ); break;
+ case 'Ð': buf.append( "Ð" ); break;
+ case 'º': buf.append( "º" ); break;
+ case '¡': buf.append( "¡" ); break;
+ case '£': buf.append( "£" ); break;
+ case '±': buf.append( "±" ); break;
+ case '¿': buf.append( "¿" ); break;
+ case 'Ø': buf.append( "Ø" ); break;
+ case 'Á': buf.append( "À" ); break;
+ case 'À': buf.append( "Á" ); break;
+ case 'É': buf.append( "È" ); break;
+ case 'È': buf.append( "É" ); break;
+ case 'ù': buf.append( "ú" ); break;
+ case 'ñ': buf.append( "ñ" ); break;
+ case 'Ñ': buf.append( "Ñ" ); break;
+ case 'µ': buf.append( "µ" ); break;
+ case 'Í': buf.append( "Ì" ); break;
+ case 'Ì': buf.append( "Í" ); break;
+ case 'í': buf.append( "ì" ); break;
+ case 'ì': buf.append( "í" ); break;
+ case 'î': buf.append( "î" ); break;
+ case 'Î': buf.append( "Î" ); break;
+ case 'ó': buf.append( "ó" ); break;
+ case 'Ó': buf.append( "Ò" ); break;
+ case 'ò': buf.append( "Î" ); break;
+ case 'Ò': buf.append( "Ó" ); break;
+ case 'ô': buf.append( "ô" ); break;
+ case 'Ô': buf.append( "Ô" ); break;
+ case 'õ': buf.append( "õ" ); break;
+ case 'Õ': buf.append( "Õ" ); break;
+ case 'ý': buf.append( "ý" ); break;
+ case 'Ý': buf.append( "Ý" ); break;
+ case 'û': buf.append( "û" ); break;
+ case 'Û': buf.append( "Û" ); break;
+ case 'ú': buf.append( "ù" ); break;
+ case 'Ú': buf.append( "Ù" ); break;
+ case 'Ù': buf.append( "Ú" ); break;
+ case 'Ê': buf.append( "Ê" ); break;
+ case 'ê': buf.append( "ê" ); break;
+ case 'å': buf.append( "å" ); break;
+ case 'Å': buf.append( "Å" ); break;
+ case 'ë': buf.append( "ë" ); break;
+ case 'Ë': buf.append( "Ë" ); break;
+ case 'ÿ': buf.append( "ÿ" ); break;
+ case 'ï': buf.append( "ï" ); break;
+ case 'Ï': buf.append( "Ï" ); break;
+ case '«': buf.append( "«" ); break;
+ case '»': buf.append( "»" ); break;
+ case '\'': buf.append( "´" ); break;
+ case '\"': buf.append( """ ); break;
+ //case '\u8211': buf.append( "–" ); break;
+ //case '\u8212': buf.append( "—" ); break;
+ //case '\u8220': buf.append( "“" ); break;
+ //case '\u8221': buf.append( "”" ); break;
+ //case '\u8222': buf.append( "„" ); break;
+ //case '\"': buf.append( """ ); break;
+ default: buf.append( s.charAt(i) );
+ }
+
+ }
+ return buf.toString();
+ }
+
+
+ public static String decodeHTMLinTags(String s){
+ StringBuffer buffer = new StringBuffer();
+ boolean start = false;
+ boolean stop = false;
+ int startIndex = 0;
+ int stopIndex = 0;
+ int temp = 0;
+
+ for(int i=0;i<s.length();i++){
+ if(s.charAt(i)=='<'){
+ start = true;
+ startIndex = i;
+ } else if(s.charAt(i)=='>'){
+ stop = true;
+ stopIndex = i;
+
+ if(start && stop){
+ buffer.append(s.substring(temp,startIndex));
+ buffer.append(replaceQuot(s.substring(startIndex,stopIndex+1)));
+ i= temp= stopIndex+1;
+ start= stop= false;
+ }
+ }
+ }
+ buffer.append(s.substring(stopIndex+1));
+ return buffer.toString();
+ }
+
+ public static String replaceQuot(String s) {
+ StringBuffer buffer = new StringBuffer();
+ for(int j = 0; j < s.length();j++){
+ if(s.charAt(j)=='&'){
+ if(s.indexOf( """,j) == j) {
+ buffer.append( "\"" );
+ j += 5;
+ }//if
+ } else {
+ buffer.append(s.charAt(j));
+ }//else
+ }//for
+ return buffer.toString();
+ }
+
+ /** wandelt Quotes in Sonderzeichen um
+ */
+ public static String decodeHtml(String s) {
+ StringBuffer buf = new StringBuffer();
+ for(int i=0;i < s.length(); i++ ) {
+ if( s.indexOf( "ö", i ) == i ) {
+ buf.append( "ö" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ä", i ) == i ) {
+ buf.append( "ä" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ü", i ) == i ) {
+ buf.append( "ü" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ö", i ) == i ) {
+ buf.append( "Ö" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ä", i ) == i ) {
+ buf.append( "Ä" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "Ü", i ) == i ) {
+ buf.append( "Ü" ); i += 5;
+ continue;
+ }
+ if( s.indexOf( "ß", i ) == i ) {
+ buf.append( "ß" ); i += 6;
+ continue;
+ }
+ if( s.indexOf( """, i ) == i ) {
+ buf.append( "\"" ); i += 5;
+ continue;
+ }
+ buf.append( s.charAt(i) );
+ }
+ return buf.toString();
+ }
+
+
+ /**
+ * schnellere Variante der String.toLowerCase()-Routine
+ *
+ * @return String in Kleinbuchsten
+ */
+ public static String toLowerCase(String s) {
+ int l = s.length();
+ char[] a = new char[l];
+ for (int i = 0; i < l; i++)
+ a[i] = Character.toLowerCase(s.charAt(i));
+ return new String(a);
+ }
+
+ /**
+ * Findet <code>element</code> im String-Array <code>array</code>
+ * @param array
+ * @param element
+ * @return Fundstelle als int oder -1
+ */
+ public static int indexOf(String[] array, String element) {
+ if (array != null)
+ for (int i = 0; i < array.length; i++)
+ if (array[i].equals(element))
+ return i;
+ return -1;
+ }
+
+ /**
+ * Testet auf Vorkommen von <code>element</code> in <code>array</code>
+ * @param array String-Array
+ * @param element
+ * @return true wenn <code>element</code> vorkommt, sonst false
+ */
+ public static boolean contains(String[] array, String element) {
+ return indexOf(array, element) >= 0;
+ }
+
+ /**
+ * Ermittelt CRC-Prüfsumme von String <code>s</code>
+ * @param s
+ * @return CRC-Prüfsumme
+ */
+ public static int getCRC(String s) {
+ int h = 0;
+ char val[] = s.toCharArray();
+ int len = val.length;
+
+ for (int i = 0 ; i < len; i++) {
+ h &= 0x7fffffff;
+ h = (((h >> 30) | (h << 1)) ^ (val[i]+i));
+ }
+
+ return (h << 8) | (len & 0xff);
+ }
+
+ /**
+ * Liefert Default-Wert def zurück, wenn String <code>s</code>
+ * kein Integer ist.
+ *
+ * @param s
+ * @param def
+ * @return geparster int aus s oder def
+ */
+ public static int parseInt(String s, int def) {
+ if (s == null) return def;
+ try {
+ return Integer.parseInt(s);
+ } catch (NumberFormatException e) {
+ return def;
+ }
+ }
+
+ /**
+ * Liefert Defaultwert def zurück, wenn s nicht zu einem float geparsed werden kann.
+ * @param s
+ * @param def
+ * @return geparster float oder def
+ */
+ public static float parseFloat(String s, float def) {
+ if (s == null) return def;
+ try {
+ return new Float(s).floatValue();
+ } catch (NumberFormatException e) {
+ return def;
+ }
+ }
+
+ /**
+ * Findet Ende eines Satzes in String <code>text</code>
+ * @param text
+ * @param startIndex
+ * @return index des Satzendes, oder -1
+ */
+ public static int findEndOfSentence(String text, int startIndex) {
+ while (true) {
+ int i = text.indexOf('.', startIndex);
+ if (i < 0) return -1;
+ if (i > 0 && !Character.isDigit(text.charAt(i-1)) &&
+ (i+1 >= text.length()
+ || text.charAt(i+1) == ' '
+ || text.charAt(i+1) == '\n'
+ || text.charAt(i+1) == '\t'))
+ return i+1;
+ startIndex = i+1;
+ }
+ }
+
+ /**
+ * Findet Wortende in String <code>text</code> ab <code>startIndex</code>
+ * @param text
+ * @param startIndex
+ * @return Index des Wortendes, oder -1
+ */
+ public static int findEndOfWord(String text, int startIndex) {
+ int i = text.indexOf(' ', startIndex),
+ j = text.indexOf('\n', startIndex);
+ if (i < 0) i = text.length();
+ if (j < 0) j = text.length();
+ return Math.min(i, j);
+ }
+
+ /**
+ * Diese Routine macht aus links in reinem text browsbare links
+ * @param text
+ * @return Konvertierter String
+ */
+ public static String makeLinks(String text) {
+ int i = 0;
+ StringBuffer buf = new StringBuffer(text.length());
+ while (true) {
+ int j = text.indexOf("http://", i);
+ if (j < 0) {
+ buf.append(text.substring(i));
+ break;
+ } else {
+ buf.append(text.substring(i, j));
+ int k = findEndOfWord(text,j+7);
+ String url="";
+ if (k<0) url = text.substring(j);
+ else url = text.substring(j,k);
+
+ buf.append("<a href=\042"+url+"\042>"+url+"</a>");
+ //System.out.println("url mark: " + url);
+ i = j+url.length();
+ }
+ }
+ return buf.toString();
+
+ }
+
+
+ /**
+ * convertNewline2P ist eine regex-routine zum umwandeln von 2 oder mehr newlines (\n)
+ * in den html-tag <p>
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String convertNewline2P(String haystack) {
+ try {
+ RE regex = new RE("(<br>\r?\n<br>){1,}");
+ return regex.substituteAll(haystack,"\n</p><p>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+ /**
+ * convertNewline2Break ist eine regex-routine zum umwandeln von 1 newline (\n)
+ * in den html-tag <br>
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String convertNewline2Break(String haystack) {
+ try {
+ RE regex = new RE("(\r?\n){1}");
+ return regex.substituteAll(haystack,"$0<br>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+ /**
+ * createMailLinks wandelt text im email-adressenformat
+ * in einen klickbaren link um
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String createMailLinks(String haystack) {
+ try {
+ RE regex = new RE("([a-zA-Z0-9_.-]+)@([a-zA-Z0-9_-]+).([a-zA-Z0-9_.-]+)");
+ return regex.substituteAll(haystack,"<a href=\"mailto:$0\">$0</a>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+
+ /**
+ * createMailLinks wandelt text im email-adressenformat
+ * in einen klickbaren link um
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String createMailLinks(String haystack, String imageRoot, String mailImage) {
+ try {
+ RE regex = new RE("([a-zA-Z0-9_.-]+)@([a-zA-Z0-9_-]+).([a-zA-Z0-9_.-]+)");
+ return regex.substituteAll(haystack,"<img src=\""+imageRoot+"/"+mailImage+"\" border=\"0\"/> <a href=\"mailto:$0\">$0</a>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+
+ /**
+ * createURLLinks wandelt text im url-format
+ * in einen klickbaren link um
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String createURLLinks(String haystack) {
+ try {
+ //dieser Ausdruck brauch dringend fachliche Beratung
+ RE regex = new RE("((https://)|(http://)|(ftp://))+([a-zA-Z0-9_-]+).([a-zA-Z0-9_.:-]+)/([^ \t\r\n<>]+[^ \t\r\n.,<>])");
+ return regex.substituteAll(haystack,"<a href=\"$0\">$0</a>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+ /**
+ * createURLLinks wandelt text im url-format
+ * in einen klickbaren link um
+ * nur sinnvoll, wenn text nicht im html-format eingegeben
+ */
+ public static String createURLLinks(String haystack,String imageRoot,String extImage,String intImage) {
+ try {
+ //dieser Ausdruck brauch dringend fachliche Beratung
+ RE regex = new RE("((https://)|(http://)|(ftp://))+([a-zA-Z0-9_-]+).([a-zA-Z0-9_.:-]+)/?([^ \t\r\n<>]+[^ \t\r\n.,<>])");
+ return regex.substituteAll(haystack,"<img src=\""+imageRoot+"/"+extImage+"\" border=\"0\"/> <a href=\"$0\">$0</a>");
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+ /**
+ * deleteForbiddenTags
+ * this method deletes all <script>, <body> and <head>-tags
+ */
+ public static String deleteForbiddenTags(String haystack) {
+ try {
+ RE regex = new RE("<[ \t\r\n](.*?)script(.*?)/script(.*?)>",RE.REG_ICASE);
+ haystack = regex.substituteAll(haystack,"");
+ regex = new RE("<head>(.*?)</head>");
+ haystack = regex.substituteAll(haystack,"");
+ regex = new RE("<[ \t\r\n/]*body(.*?)>");
+ haystack = regex.substituteAll(haystack,"");
+ return haystack;
+ } catch(REException ex){
+ return null;
+ }
+ }
+
+ /**
+ * createHTML ruft alle regex-methoden zum unwandeln eines nicht
+ * htmlcodierten string auf und returnt einen htmlcodierten String
+ */
+ public static String createHTML(String content){
+ content=convertNewline2Break(content);
+ content=convertNewline2P(content);
+ content=createMailLinks(content);
+ content=createURLLinks(content);
+ return content;
+ }
+
+ /**
+ * createHTML ruft alle regex-methoden zum unwandeln eines nicht
+ * htmlcodierten string auf und returnt einen htmlcodierten String
+ */
+ public static String createHTML(String content,String producerDocRoot,String mailImage,String extImage,String intImage){
+ content=convertNewline2Break(content);
+ content=convertNewline2P(content);
+ content=createMailLinks(content,producerDocRoot,mailImage);
+ content=createURLLinks(content,producerDocRoot,extImage,intImage);
+ return content;
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+
+/**
+ * Title:
+ * Description:
+ * Copyright: Copyright (c) 2001
+ * Company: Indymedia
+ * @author
+ * @version 1.0
+ */
+
+import java.io.*;
+import javax.media.jai.*;
+import com.sun.media.jai.codec.*;
+import java.awt.image.renderable.ParameterBlock;
+
+public class WebdbImage
+{
+
+ // imageTypes
+ public final static int WEBDB_JPG=0;
+ public final static int WEBDB_GIF=1;
+
+ // default values for scaling
+ private int maxIconSize=120;
+ private int maxImageSize=640;
+
+ private byte[] iconData;
+ private byte[] imageData;
+ private int imageType;
+ private int iconWidth;
+ private int iconHeight;
+
+ // internal representation of the image
+ private PlanarImage planarImage;
+
+
+ // constructor
+ public WebdbImage(byte[] image, int type)
+ throws IOException
+ {
+ imageType=type;
+ planarImage = JAI.create("stream",new ByteArraySeekableStream(image));
+ scaleImage();
+ }
+
+ public WebdbImage(byte[] image, int type, int iconMax)
+ throws IOException
+ {
+ imageType=type;
+ maxIconSize=iconMax;
+ planarImage = JAI.create("stream",new ByteArraySeekableStream(image));
+ scaleImage();
+ }
+
+ public WebdbImage(byte[] image, int type, int iconMax, int imageMax)
+ throws IOException
+ {
+ imageType=type;
+ maxIconSize=iconMax;
+ maxImageSize=imageMax;
+ planarImage = JAI.create("stream",new ByteArraySeekableStream(image));
+ scaleImage();
+ }
+
+
+ // acc3ssor-methods
+ public int getIconWidth() throws IOException {
+ if (iconData==null) scaleIcon();
+ return iconWidth;
+ }
+
+ public int getIconHeight() throws IOException {
+ if (iconData==null) scaleIcon();
+ return iconHeight;
+ }
+
+ public int getImageWidth() {
+ return (int)planarImage.getWidth();
+ }
+
+ public int getImageHeight() {
+ return (int)planarImage.getHeight();
+ }
+
+ public byte[] getImage() {
+ if (imageData==null) {
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+
+ switch (imageType) {
+ case WEBDB_JPG:
+ JAI.create("encode", planarImage, outStream, "JPEG", null);break;
+ case WEBDB_GIF:
+ JAI.create("encode", planarImage, outStream, "JPEG", null);break;
+ default:
+ System.err.println("unknown image format: " + imageType);
+ }
+
+ imageData = outStream.toByteArray();
+ }
+ return imageData;
+ }
+
+ public byte[] getIcon()
+ throws IOException
+ {
+ if (iconData == null) scaleIcon();
+ return iconData;
+ }
+
+ private void scaleImage()
+ throws java.io.IOException
+ {
+ if (maxImageSize>0 && ( getImageHeight()> maxImageSize|| getImageWidth() >maxImageSize))
+ {
+ float scale;
+ if (getImageHeight() > getImageWidth())
+ scale = (float)maxImageSize / (float)getImageHeight();
+ else
+ scale = (float)maxImageSize / (float)getImageWidth();
+
+ InterpolationBilinear interp = new InterpolationBilinear();
+ planarImage = JAI.create("scale", planarImage, scale, scale, 0.0F, 0.0F, interp);
+ }
+ }
+
+ private void scaleIcon()
+ throws java.io.IOException
+ {
+ if (iconData==null) {
+ float scale;
+ if (getImageHeight() > getImageWidth())
+ scale = (float)maxIconSize / (float)getImageHeight();
+ else
+ scale = (float)maxIconSize / (float)getImageWidth();
+
+ InterpolationBilinear interp = new InterpolationBilinear();
+ PlanarImage temp = JAI.create("scale", planarImage, scale, scale, 0.0F, 0.0F, interp);
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ /** @todo gif */
+ switch (imageType) {
+ case WEBDB_JPG:
+ JAI.create("encode", temp, outStream, "JPEG", null);break;
+ case WEBDB_GIF:
+ JAI.create("encode", temp, outStream, "JPEG", null);break;
+ default:
+ System.err.println("unknown image format: " + imageType);
+ }
+ iconData = outStream.toByteArray();
+ iconWidth=temp.getWidth();
+ iconHeight=temp.getHeight();
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+
+import java.util.*;
+import java.io.*;
+import javax.servlet.*;
+import javax.servlet.http.*;
+import com.oreilly.servlet.multipart.*;
+import com.oreilly.servlet.*;
+
+/**
+ * Title:
+ * Description:
+ * Copyright: Copyright (c) 2001
+ * Company: Indymedia
+ * @author
+ * @version 1.0
+ */
+
+public class WebdbMultipartRequest
+{
+ HttpServletRequest req=null;
+ HashMap parameters = new HashMap();
+ MultipartParser mp=null;
+ byte[] uploadData=null;
+ String fileName=null;
+
+ public WebdbMultipartRequest(HttpServletRequest theReq) throws IOException
+ {
+ req=theReq;
+ mp = new MultipartParser(req, 1024*8192); // maximum eight megabyte
+ _evaluateRequest();
+ }
+
+
+ public HashMap getParameters(){
+ return parameters;
+ }
+
+ public byte[] getMedia() {
+ return uploadData;
+ }
+
+ public String getFilename() {
+ return fileName;
+ }
+
+ private void _evaluateRequest() throws IOException{
+
+ Part part;
+ while ((part = mp.readNextPart()) != null) {
+ String name = part.getName();
+ if (part.isParam()) {
+ // It's a parameter part, add it to the vector of values
+ ParamPart paramPart = (ParamPart) part;
+ String value = paramPart.getStringValue();
+ parameters.put(name,value);
+ }
+ else if (part.isFile()) {
+ // nur das erste uploadfile beruecksichtigen
+ FilePart filePart = (FilePart) part;
+ fileName = filePart.getFileName();
+ if (fileName != null) {
+ ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+ filePart.writeTo(byteStream);
+ uploadData=byteStream.toByteArray();
+ }
+ }
+ } // while */
+ }
+}
--- /dev/null
+package mir.misc;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import org.xml.sax.SAXException;
+import com.icl.saxon.trax.Transformer;
+import com.icl.saxon.trax.Templates;
+import com.icl.saxon.trax.Result;
+import com.icl.saxon.PreparedStyleSheet;
+import org.xml.sax.InputSource;
+
+/**
+ * Title: XmlSaxonStyler
+ * Description: Implement XmlStyler
+ * Copyright: Copyright (c) 2001
+ * Company: Indymedia
+ * @author idfx
+ * @version 1.0
+ */
+
+public class XmlSaxonStyler implements XmlStyler{
+
+ private XmlSaxonStyler() {}
+ private static XmlSaxonStyler styler = new XmlSaxonStyler();
+ public static XmlSaxonStyler getInstance(){
+ return styler;
+ }
+
+ public void style( String styleKey, InputStream is, OutputStream os )
+ throws SAXException {
+
+ Templates styleSheet = XslStyleCache.getPreparedStyleSheet( styleKey );
+ Transformer transformer = styleSheet.newTransformer();
+ transformer.transform( new InputSource( is ), new Result( os ) );
+ }
+
+ public void style( Transformer transformer, InputStream is, OutputStream os )
+ throws SAXException {
+
+ transformer.transform( new InputSource( is ), new Result( os ) );
+ }
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import org.xml.sax.SAXException;
+
+/**
+ * Title: XmLStyler
+ * Description:
+ * Copyright: Copyright (c) 2001
+ * Company: Indymedia
+ * @author idfx
+ * @version 1.0
+ */
+
+public interface XmlStyler {
+
+ void style( String styleKey, InputStream is, OutputStream os )
+ throws SAXException;
+
+}
\ No newline at end of file
--- /dev/null
+package mir.misc;
+
+import java.io.IOException;
+
+import com.icl.saxon.PreparedStyleSheet;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import com.icl.saxon.trax.Transformer;
+
+import java.util.Hashtable;
+
+/**
+ * Title:
+ * Description:
+ * Copyright: Copyright (c) 2001
+ * Company:
+ * @author
+ * @version 1.0
+ */
+
+
+public class XslStyleCache {
+
+ private static Hashtable cache;
+ private static XslStyleCache single = new XslStyleCache();
+
+
+ /**
+ * XSLStyleCache constructor comment.
+ */
+ private XslStyleCache() {
+ cache = new Hashtable();
+ }
+
+ /**
+ * singleton constructor
+ */
+ private static synchronized XslStyleCache getInstance() {
+ return single;
+ }
+
+
+ /**
+ * Clear Cache
+ */
+ public static void clear() {
+ cache.clear();
+ }
+
+ /**
+ * This method was created in VisualAge.
+ * @return
+ * @param key java.lang.String
+ */
+ public static PreparedStyleSheet getPreparedStyleSheet( String key )
+ throws SAXException {
+
+ PreparedStyleSheet styleSheet = (PreparedStyleSheet)single.cache.get( key );
+ try {
+ if ( styleSheet == null ) {
+ styleSheet = new PreparedStyleSheet();
+ styleSheet.prepare( InputSourceResolver.resolve( key ) );
+ single.cache.put( key, styleSheet );
+ }
+ } catch ( IOException ex ) {
+ throw new SAXException( "tunneld IOExcpetion:" + ex.getMessage() );
+ }
+
+ return styleSheet;
+ }
+
+ /**
+ * This method was created in VisualAge.
+ * @return
+ * @param key java.lang.String
+ */
+ public static Transformer getTransformer( String key ){
+
+ PreparedStyleSheet styleSheet = (PreparedStyleSheet)single.cache.get( key );
+ try {
+ if ( styleSheet == null ) {
+ styleSheet = new PreparedStyleSheet();
+ styleSheet.prepare( InputSourceResolver.resolve( key ) );
+ single.cache.put( key, styleSheet );
+ }
+ } catch ( IOException ex ) {
+ //throw new SAXException( "tunneld IOExcpetion:" + ex.getMessage() );
+ } catch (SAXException ex) {}
+
+ return styleSheet.newTransformer();
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.module;
+
+import java.util.*;
+import java.sql.*;
+import freemarker.template.*;
+import mir.storage.*;
+import mir.misc.*;
+import mir.entity.*;
+
+
+/**
+ * Abstrakte Klasse, von denen die Modules die Basisfunktionalität erben.
+ * Die Moduleschicht dient dazu, Funktionalitaeten zur Verfügung zu stellen,
+ * die von mehreren ServletModulen verwendet werden.
+ */
+public class AbstractModule {
+ protected StorageObject theStorage;
+ protected Logfile theLog;
+
+ public void setStorage(StorageObject storage) {
+ this.theStorage = storage;
+ }
+
+ /**
+ * Liefert das Standard-StorageObject zurück, mit dem das Module assoziiert ist.
+ * @return Standard-StorageObject
+ */
+ public StorageObject getStorageObject () {
+ return theStorage;
+ }
+
+ /**
+ * Holt eine Entity anhand der Id via StorageObject
+ * @param String der Entity
+ * @return Entity
+ */
+ public Entity getById (String id) throws ModuleException {
+ try {
+ if (theStorage == null)
+ throw new ModuleException("Kein StorageObject gesetzt");
+ Entity entity = (Entity)theStorage.selectById(id);
+ if (entity == null)
+ throw new ModuleException("Objekt nicht vorhanden: ID=" + id);
+ else return entity;
+ }
+ catch (StorageObjectException e){
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Holt eine EntityListe anhand des WhereClause via StorageObject
+ * @param String whereclause
+ * @param offset - ab welchem Datensatz die gematchten Entities zurueckgeliefert werden
+ * @return EntityList Liste der gematchten Datensätze
+ */
+ public EntityList getByWhereClause (String whereClause, int offset) throws ModuleException {
+ try {
+ if (theStorage == null)
+ throw new ModuleException("Kein StorageObject gesetzt");
+ return theStorage.selectByWhereClause(whereClause, offset);
+ }
+ catch (StorageObjectException e){
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Holt eine EntityListe anhand des WhereClause aus dem StorageObject
+ * @param String where WhereClause
+ * @param String order Sortierreihenfolge
+ * @param offset - ab welchem Datensatz die gematchten Entities zurueckgeliefert werden
+ * @return EntityList Liste der gematchten Datensätze
+ */
+ public EntityList getByWhereClause (String where, String order, int offset) throws ModuleException {
+ try {
+ if (theStorage==null) throw new ModuleException("Kein StorageObject gesetzt");
+ return theStorage.selectByWhereClause(where, order, offset);
+ }
+ catch (StorageObjectException e){
+ throw new ModuleException(e.toString());
+ }
+ }
+ /**
+ * Executes a where clause on the StorageObject with order criteria
+ * fetching from offset the number of limit objects
+ *
+ * @param String where
+ * @param String order
+ * @param int offset
+ * @param int limit
+ * @return EntityList
+ */
+
+ public EntityList getByWhereClause(String where, String order, int offset, int limit) throws ModuleException
+ {
+ try {
+ if (theStorage==null) throw new ModuleException("StorageObject not set!");
+ return theStorage.selectByWhereClause(where, order, offset, limit);
+ }
+ catch (StorageObjectException e){
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Holt eine EntityListe anhand des Wertes aValue von Feld aField aus dem StorageObject
+ * @param String aField - Feldname im StorageObject
+ * @param String aValue - Wert in Feld im StorageObject
+ * @param offset - ab welchem Datensatz die gematchten Entities zurueckgeliefert werden
+ * @return EntityList Liste der gematchten Datensätze
+ */
+ public EntityList getByFieldValue (String aField, String aValue, int offset) throws ModuleException {
+ String whereClause;
+ whereClause = aField + " like '%" + aValue + "%'";
+ return getByWhereClause(whereClause, offset);
+ }
+
+ /**
+ * Standardfunktion, um einen Datensatz via StorageObject einzufügen
+ * @param theValues Hash mit Spalte/Wert-Paaren
+ * @return Id des eingefügten Objekts
+ * @exception ModuleException
+ */
+ public String add (HashMap theValues) throws ModuleException {
+ try {
+ Entity theEntity = (Entity)theStorage.getEntityClass().newInstance();
+ theEntity.setStorage(theStorage);
+ theEntity.setValues(theValues);
+ return theEntity.insert();
+ } catch (Exception e) {
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Standardfunktion, um einen Datensatz via StorageObject zu aktualisieren
+ * @param theValues Hash mit Spalte/Wert-Paaren
+ * @return Id des eingefügten Objekts
+ * @exception ModuleException
+ */
+ public String set (HashMap theValues) throws ModuleException {
+ try {
+ Entity theEntity = theStorage.selectById((String)theValues.get("id"));
+ if (theEntity == null)
+ throw new ModuleException("Kein Objekt mit id in Datenbank id: " + theValues.get("id"));
+ theEntity.setValues(theValues);
+ theEntity.update();
+ return theEntity.getId();
+ }
+ catch (StorageObjectException e){
+ e.printStackTrace(System.err);
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Löscht einen Datensatz anhand seiner Id
+ * @param idParam
+ * @exception ModuleException
+ */
+ public void deleteById (String idParam) throws ModuleException {
+ try {
+ theStorage.delete(idParam);
+ } catch (StorageObjectException e){
+ throw new ModuleException(e.toString());
+ }
+ }
+
+ /**
+ * Liefert den Lookuptable aller Objekte des StorageObjects
+ * @return freemarker.template.SimpleHash
+ */
+ public SimpleHash getHashData() {
+ return theStorage.getHashData();
+ }
+
+ /**
+ * returns the number of rows
+ */
+ public int getSize(String where)
+ throws SQLException,StorageObjectException {
+ return theStorage.getSize(where);
+ }
+
+}
--- /dev/null
+package mir.module;
+
+import java.lang.*;
+
+/*
+ * ServletModuleException -
+ * wird vom ServletModule geschmissen</b>
+ *
+ *
+ * @version 5.7.199
+ * @author RK
+ */
+
+public final class ModuleException extends Exception
+{
+ public ModuleException(String msg) {
+ super(msg);
+ }
+}
+
--- /dev/null
+package mir.servlet;
+
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import java.io.File;
+import java.util.Locale;
+
+import mir.misc.HTMLTemplateProcessor;
+import mir.misc.Configuration;
+import mir.misc.Logfile;
+
+/**
+ * Title: Mir
+ * Description: Abstract servlet-class
+ * Copyright: Copyright (c) 2001
+ * Company: Indymedia
+ * @author idfx
+ * @version 1.0
+ */
+
+public abstract class AbstractServlet extends HttpServlet {
+ protected static String lang;
+ protected static Logfile theLog;
+
+ /**
+ * get the configration
+ */
+ protected boolean getConfig(HttpServletRequest req) {
+ Configuration.initConfig(getInitParameter("Config"));
+ theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("Mir.Logfile"));
+ theLog.printInfo(super.getServletName() + " started.");
+ return true;
+ }
+
+ /**
+ * Bind the language to the session
+ */
+ protected void setLanguage(HttpServletRequest req, String language){
+ HttpSession session = req.getSession();
+ session.setAttribute("Language",language);
+ }
+
+ /**
+ * Get the session-binded language
+ */
+ protected String getLanguage(HttpServletRequest req){
+ HttpSession session = req.getSession();
+ String lang = (String)session.getAttribute("Language");
+ if(lang==null || lang==""){
+ return getAcceptLanguage(req);
+ } else {
+ return lang;
+ }
+ }
+
+ /**
+ * Checks the Accept-Language of the clients browser.
+ * if this language is available it returns its contry-code,
+ * else it return the standard-language
+ */
+ protected String getAcceptLanguage(HttpServletRequest req){
+ Locale loc = req.getLocale();
+ lang = loc.getLanguage();
+ File f = new File(HTMLTemplateProcessor.templateDir+"/"+lang);
+ //is there an existing template-path?
+ if(!f.isDirectory()){
+ //no there isn't. we use standard-language
+ lang = Configuration.getProperty("StandardLanguage");
+ theLog.printDebugInfo("language not existing");
+ }
+ theLog.printDebugInfo("Language: " + lang);
+ return lang;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * put your module comment here
+ *
+ */
+
+
+package mir.servlet;
+
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+import javax.servlet.http.*;
+import freemarker.template.*;
+import mir.storage.*;
+import mir.servlet.ServletModuleException;
+import mir.misc.*;
+import mir.entity.*;
+import mir.module.*;
+import mir.misc.*;
+
+
+/**
+ * Abstrakte Klasse ServletModule stellt die Basisfunktionalitaet der
+ * abgeleiteten ServletModule zur Verfügung.
+ *
+ * @version 28.6.1999
+ * @author RK
+ */
+
+public abstract class ServletModule {
+
+ public String defaultAction;
+ protected Logfile theLog;
+ protected AbstractModule mainModule;
+ protected String templateListString;
+ protected String templateObjektString;
+ protected String templateConfirmString;
+
+ /**
+ * Singelton - Methode muss in den abgeleiteten Klassen ueberschrieben werden.
+ * @return ServletModule
+ */
+ public static ServletModule getInstance() { return null; }
+
+ /**
+ * get the session binded language
+ */
+ public String getLanguage(HttpServletRequest req){
+ HttpSession session = req.getSession();
+ String language = (String)session.getAttribute("Language");
+ if(language==null){
+ language=Configuration.getProperty("StandardLanguage");
+ }
+ return language;
+ }
+
+ // ACHTUNG DEPRECATED::::
+ public void process(HttpServletRequest req, HttpServletResponse res) throws ServletModuleException {}
+
+
+
+ /**
+ * list(req,res) - generische Listmethode. Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+ public void list(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException {
+ try {
+ EntityList theList;
+ String offsetParam = req.getParameter("offset");
+ int offset =0;
+ PrintWriter out = res.getWriter();
+
+ // hier offsetcode bearbeiten
+ if (offsetParam != null) offset = Integer.parseInt(offsetParam);
+ if (req.getParameter("next") != null)
+ offset=Integer.parseInt(req.getParameter("nextoffset"));
+ else
+ if (req.getParameter("prev") != null)
+ offset = Integer.parseInt(req.getParameter("prevoffset"));
+ theList = mainModule.getByWhereClause(null, offset);
+ //theList = mainModule.getByWhereClause((String)null, offset);
+ if (theList == null || theList.getCount() == 0 || theList.getCount()>1)
+ HTMLTemplateProcessor.process(getLanguage(req)+"/"+templateListString, theList, out);
+ else
+ deliver(req, res, theList.elementAt(0), templateObjektString);
+ } catch (Exception e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+ /**
+ * add(req,res) - generische Addmethode. Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+ public void add(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException {
+
+ try {
+ SimpleHash mergeData = new SimpleHash();
+ mergeData.put("new", "1");
+ deliver(req, res, mergeData, templateObjektString);
+ } catch (Exception e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+ /**
+ * insert(req,res) - generische Insertmethode, folgt auf add.
+ * Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+ public void insert(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException {
+ try {
+ HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
+ String id = mainModule.add(withValues);
+ // theLog.printDebugInfo("--trying to deliver..."+id);
+ deliver(req, res, mainModule.getById(id), templateObjektString);
+ }
+ catch (Exception e) { throw new ServletModuleException(e.toString());}
+ }
+
+/**
+ * delete(req,res) - generische Deletemethode. Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+
+ public void delete(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException
+ {
+ try {
+ String idParam = req.getParameter("id");
+ if (idParam == null) throw new ServletModuleException("Falscher Aufruf: (id) nicht angegeben");
+ // Hier code zum Loeschen
+ String confirmParam = req.getParameter("confirm");
+ String cancelParam = req.getParameter("cancel");
+ if (confirmParam == null && cancelParam == null) {
+ // HTML Ausgabe zum Confirmen!
+ SimpleHash mergeData = new SimpleHash();
+ String moduleClassName = mainModule.getClass().getName();
+ int i = moduleClassName.indexOf(".Module");
+ String moduleName = moduleClassName.substring(i+7);
+ mergeData.put("module", moduleName);
+ mergeData.put("infoString", moduleName + ": " + idParam);
+ mergeData.put("id", idParam);
+ mergeData.put("where", req.getParameter("where"));
+ mergeData.put("order", req.getParameter("order"));
+ mergeData.put("offset", req.getParameter("offset"));
+ deliver(req, res, mergeData,templateConfirmString);
+ } else {
+ if (confirmParam!= null && !confirmParam.equals("")) {
+ //theLog.printInfo("delete confirmed!");
+ mainModule.deleteById(idParam);
+ list(req,res); // back to list
+ } else {
+ if (req.getParameter("where") != null)
+ list(req,res);
+ else
+ edit(req,res);
+ }
+ }
+ } catch (Exception e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+ /**
+ * edit(req,res) - generische Editmethode. Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+ public void edit(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException {
+ try {
+ String idParam = req.getParameter("id");
+ deliver(req, res, mainModule.getById(idParam), templateObjektString);
+ } catch(ModuleException e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+/**
+ * update(req,res) - generische Updatemethode. Wennn die Funktionalitaet
+ * nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
+ * ueberschreiben werden.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ */
+
+ public void update(HttpServletRequest req, HttpServletResponse res)
+ throws ServletModuleException {
+ try {
+ String idParam = req.getParameter("id");
+ HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
+ String id = mainModule.set(withValues);
+ //theLog.printInfo("Showing Entity with id: " + id);
+ //edit(req,res);
+ String whereParam = req.getParameter("where");
+ String orderParam = req.getParameter("order");
+ if ((whereParam!=null && !whereParam.equals("")) || (orderParam!=null && !orderParam.equals(""))){
+ //theLog.printDebugInfo("update to list");
+ list(req,res);
+ } else {
+ edit(req, res);
+ }
+ //list(req,res);
+ } catch (Exception e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+ // Hilfsprozeduren
+ /**
+ public void predeliver(HttpServletResponse res, TemplateModelRoot rtm, String tmpl)
+ throws ServletModuleException {
+ try {
+ PrintWriter out = new LineFilterWriter(res.getWriter());
+ StringWriter a = new StringWriter();
+ deliver(new PrintWriter(a),rtm,tmpl);
+ out.write(a.toString());
+ out.flush();
+ } catch (Exception e) {
+ e.printStackTrace();System.err.println(e.toString());
+ }
+ }
+ */
+
+ /**
+ * deliver liefert das Template mit dem Filenamen templateFilename
+ * an den HttpServletResponse res aus, nachdem es mit den Daten aus
+ * TemplateModelRoot rtm gemischt wurde
+ *
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
+ * Daten, die ins Template gemerged werden sollen.
+ * @param tmpl Name des Templates
+ * @exception ServletModuleException
+ */
+ public void deliver(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm, String templateFilename)
+ throws ServletModuleException {
+ if (rtm == null) rtm = new SimpleHash();
+ try {
+ //PrintWriter out = new LineFilterWriter(res.getWriter());
+ PrintWriter out = res.getWriter();
+ HTMLTemplateProcessor.process(getLanguage(req)+"/"+templateFilename, rtm , out);
+ out.close();
+ } catch (HTMLParseException e) {
+ throw new ServletModuleException(e.toString());
+ } catch (IOException e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+ /**
+ * deliver liefert das Template mit dem Filenamen templateFilename
+ * an den HttpServletResponse res aus, nachdem es mit den Daten aus
+ * TemplateModelRoot rtm gemischt wurde
+ *
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ * @param entity Entity, aus der die Daten, die ins Template gemerged werden sollen.
+ * @param tmpl Name des Templates
+ * @exception ServletModuleException
+ */
+ public void deliver(HttpServletRequest req, HttpServletResponse res, Entity ent, String templateFilename)
+ throws ServletModuleException {
+ deliver(req, res,HTMLTemplateProcessor.makeSimpleHash(ent), templateFilename);
+ }
+ /**
+ * deliver liefert das Template mit dem Filenamen templateFilename
+ * an den HttpServletResponse res aus, nachdem es mit den Daten aus
+ * TemplateModelRoot rtm gemischt wurde
+ *
+ * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.
+ * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
+ * Daten, die ins Template gemerged werden sollen.
+ * @param tmpl Name des Templates
+ * @exception ServletModuleException
+ */
+ private void deliver(HttpServletRequest req, PrintWriter out, TemplateModelRoot rtm, String templateFilename)
+ throws HTMLParseException {
+ HTMLTemplateProcessor.process(getLanguage(req)+"/"+templateFilename, rtm , out);
+ }
+
+ /**
+ * Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem
+ * Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des
+ * doParameters ausgefuehrt.
+ *
+ * @return Name der Default-Action
+ */
+ public String defaultAction() { return defaultAction; }
+
+ /**
+ * Hier kann vor der Datenaufbereitung schon mal ein response geschickt
+ * werden (um das subjektive Antwortverhalten bei langsamen Verbindungen
+ * zu verbessern).
+ */
+ public void predeliver(HttpServletRequest req, HttpServletResponse res) { ; }
+
+ /**
+ * Holt die Felder aus der Metadatenfelderliste des StorageObjects, die
+ * im HttpRequest vorkommen und liefert sie als HashMap zurueck
+ *
+ * @return HashMap mit den Werten
+ */
+ public HashMap getIntersectingValues(HttpServletRequest req, StorageObject theStorage)
+ throws ServletModuleException {
+ ArrayList theFieldList;
+ try {
+ theFieldList = theStorage.getFields();
+ } catch (StorageObjectException e) {
+ throw new ServletModuleException("ServletModule.getIntersectingValues: " + e.toString());
+ }
+
+ HashMap withValues = new HashMap();
+ String aField, aValue;
+
+ for(int i=0; i<theFieldList.size();i++) {
+ aField = (String)theFieldList.get(i);
+ aValue = req.getParameter(aField);
+ if (aValue!=null) withValues.put(aField,aValue);
+ }
+ return withValues;
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Dispatcher
+ */
+
+package mir.servlet;
+
+import java.lang.reflect.*;
+import javax.servlet.http.*;
+import mir.servlet.ServletModuleException;
+import mir.misc.*;
+
+
+/**
+ * Dispatcher, der in einer ServletModule-Klasse, die Methode, die per Http-Post oder Get
+ * Parameter "do" angegeben wurde, ausruft.
+ */
+public final class ServletModuleDispatch {
+
+ static Logfile theLog;
+
+ static {
+ theLog = Logfile.getInstance("/tmp/smod.dispatch");
+ }
+
+ /**
+ * privater Konstruktor, um versehentliche Instantiierung zu verhindern
+ */
+ private ServletModuleDispatch () {
+ }
+
+ /**
+ * Die Dispatch-Routine ruft das von dem Hauptservlet kommende ServletModule
+ * mit dem per HttpServletRequest angegebenen Paramter <code>do</code> auf.
+ * Ist kein Parameter angegeben, so wird versucht, in die <code>defaultAction</code>
+ * des ServletModules zu springen.
+ *
+ * @param req Http-Request, das vom Dispatcher an die Methode des
+ * ServletModules durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher an die Methode des
+ * ServletModules durchgereicht wird
+ * @param sMod ServletModule, an das dispatched wird.
+ * @param mod Name des Modules als String (für Logfile)
+ */
+
+ public static void dispatch(ServletModule sMod, HttpServletRequest req,
+ HttpServletResponse res) throws ServletModuleException
+ {
+ //sMod.predeliver(req,res);
+
+ String doParam = req.getParameter("do");
+ //theLog.printInfo("SerletModuleDispatch: " + sMod.toString() + " with method " + doParam);
+ if (doParam == null) {
+ if (sMod.defaultAction() != null) doParam = sMod.defaultAction();
+ else throw new ServletModuleException("Parameter do nicht angegeben!");
+ }
+
+ Class[] params= { HttpServletRequest.class, HttpServletResponse.class};
+
+ try {
+ Method method = sMod.getClass().getMethod(doParam,params);
+ if (method != null) {
+ method.invoke(sMod,new Object[] {req,res} );
+ return;
+ }
+ else theLog.printDebugInfo("method lookup unsuccesful");
+ }
+ catch ( NoSuchMethodException e) { throw new ServletModuleException("no such method!" + e.toString());}
+ catch ( SecurityException e) { throw new ServletModuleException("method not allowed!" + e.toString());}
+ catch ( InvocationTargetException e) {throw new ServletModuleException("target method exception!" + e.getTargetException().toString());}
+ catch ( IllegalAccessException e) { throw new ServletModuleException("illegal method not allowed!" + e.toString());}
+// catch ( Exception e ) { throw new ServletModuleException(e.toString()); }
+
+ throw new ServletModuleException("delivery failed! -- ");
+ }
+}
\ No newline at end of file
--- /dev/null
+package mir.servlet;
+
+import java.lang.*;
+
+/*
+ * ServletModuleException -
+ * wird vom ServletModule geschmissen</b>
+ *
+ *
+ * @version 28.6.199
+ * @author RK
+ */
+
+public final class ServletModuleException extends Exception
+{
+ public ServletModuleException(String msg) {
+ super(msg);
+ }
+}
+
--- /dev/null
+package mir.servlet;
+
+import java.io.*;
+import java.sql.*;
+import java.util.*;
+import javax.servlet.*;
+import javax.servlet.http.*;
+
+import freemarker.template.*;
+
+import mir.servlet.*;
+import mir.module.*;
+import mir.misc.*;
+import mir.storage.*;
+import mir.entity.*;
+
+import com.javaexchange.dbConnectionBroker.*;
+/*
+ * ServletModuleShow -
+ * liefert HTML fuer Show
+ *
+ *
+ * @author RK
+ */
+
+public class ServletModuleMonitor extends ServletModule
+{
+ private static ServletModuleMonitor instance = new ServletModuleMonitor();
+ public static ServletModule getInstance() { return instance; }
+
+ public String defaultAction() { return "show"; }
+
+ public void show(HttpServletRequest req, HttpServletResponse res) throws ServletModuleException {
+
+ try {
+ // Hier Ausgabe von
+ // instances in AbstractEntity
+ // eingelesene confs
+ // datenbankverbindungen fuer brokers
+ getSimpleInfo(res.getWriter(),getConfs());
+ PrintWriter out = res.getWriter();
+ out.println(getInstancesInfo());
+ out.println(getInstancesConfInfo());
+
+ }
+ catch (Exception e) {
+ //e.printStackTrace();
+ throw new ServletModuleException(e.toString());
+ }
+ }
+ protected int getInstances(){
+ AbstractEntity ent = new AbstractEntity();
+ return ent.getInstances();
+ }
+ public String getInstancesInfo(){
+ return "<table><tr><td>Momentan instanzierte EntityObjekte = </td><td>" + getInstances()+"</td></tr></table>\n";
+ }
+ public String getInstancesConfInfo(){
+ return "<table><tr><td>Momentan instanzierte BrokerObjekte = </td><td>" + getConfBrokerCnt()+"</td></tr></table>\n";
+ }
+
+ protected HashMap getConfs(){
+ return Configuration.getConfs();
+ }
+ protected int getBrokerUseCnt(DbConnectionBroker broker){
+ return broker.getUseCount();
+ }
+ protected int getConfBrokerCnt(){
+ return Configuration.getBrokerInstances();
+ }
+ protected int getBrokerSize(DbConnectionBroker broker){
+ return broker.getSize();
+ }
+ public String getBrokerInfo(DbConnectionBroker broker){
+ return "<tr><td>Connections im pool = </td><td>"+ broker.getSize() + "</td></tr>\n"+
+ "<tr><td>Connection die gerade benutzt werden = </td><td>" + broker.getUseCount()+"</td></tr>\n";
+ }
+ public void getSimpleInfo(Writer out,HashMap confs) throws IOException{
+ String key;
+ DbConnectionBroker broker = null;
+ out.write(getInstancesInfo());
+ out.write(getInstancesConfInfo());
+ Set set = confs.keySet();
+ Iterator it = set.iterator();
+ for (int i=0;i<set.size();i++){
+ key=(String)it.next();
+ out.write("<table><tr><td>Konfiguration : </td><td>" + confs.get(key)+ "</td></tr>\n" );
+ broker=Configuration.getBrokerInfo();
+ //broker=(DbConnectionBroker) ((HashMap)confs.get(key)).get("Pool.broker");
+ if(broker!=null) out.write(getBrokerInfo(broker));
+ else
+ out.write("<tr><td>Broker nicht initializiert</td><td></td></tr>\n");
+ out.write("</table>\n");
+ }
+ }
+}
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+package mir.servlet;
+
+import javax.servlet.http.*;
+import freemarker.template.*;
+import mir.storage.*;
+
+
+/**
+ * Standard ServletModule, dass eine Template anzeigt, und nicht
+ * mit Daten mischt. Damit ist es moeglich, einfache HTML-Seiten
+ * als templates zu benutzen. Damit kann auf einfache Weise die
+ * Funktionalitaet der Freemarker-Bibliothek (beispielsweise Navigationen
+ * per <code>include</code> einzubauen) benutzt werden. Die Templates
+ * werden aus dem per Konfiguration angegebenem template-Verzeichnis
+ * im Ordner "/html" genommen.
+ *
+ * @author RK
+ */
+public class ServletModuleShow extends ServletModule {
+ private static ServletModuleShow instance = new ServletModuleShow();
+
+ /**
+ * Ein ServletModuleShow-Objekt wird über getInstance geliefert. Es gibt zur
+ * Laufzeit nur ein Objekt (Singleton)
+ * @return ServletModuleShow
+ */
+ public static ServletModule getInstance () {
+ return instance;
+ }
+
+ /**
+ * Initialisierung leer.
+ */
+ private ServletModuleShow () {
+ }
+
+ /**
+ * defaultAction (s.a ServletModule)
+ * @return "show"
+ */
+ public String defaultAction () {
+ return "show";
+ }
+
+ /**
+ * Standardmethode, die die Funktionalitaet des ServletModules implementiert.
+ *
+ * @param req Http-Request, das vom Dispatcher durchgereicht wird
+ * @param res Http-Response, die vom Dispatcher durchgereicht wird
+ * @return String fuer Logfile
+ * @exception ServletModuleException
+ */
+ public void show(HttpServletRequest req, HttpServletResponse res) throws ServletModuleException {
+ try {
+ String idParam = req.getParameter("tmpl");
+ if (!(idParam==null || idParam.equals(""))) {
+ deliver(req, res, (TemplateModelRoot)null, "html/"+idParam+".template");
+ }
+ else {
+ throw new ServletModuleException("Falsches template: " + idParam);
+ }
+ }
+ catch (Exception e) {
+ throw new ServletModuleException(e.toString());
+ }
+ }
+
+}
+
+
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+package mir.storage;
+
+import java.sql.*;
+import java.lang.*;
+import java.io.*;
+import java.util.*;
+import freemarker.template.*;
+import com.javaexchange.dbConnectionBroker.*;
+import mir.storage.StorageObject;
+import mir.entity.*;
+import mir.misc.*;
+
+
+/**
+ * Diese Klasse implementiert die Zugriffsschicht auf die Datenbank.
+ * Alle Projektspezifischen Datenbankklassen erben von dieser Klasse.
+ * In den Unterklassen wird im Minimalfall nur die Tabelle angegeben.
+ * Im Konfigurationsfile findet sich eine Verweis auf den verwendeten
+ * Treiber, Host, User und Passwort, ueber den der Zugriff auf die
+ * Datenbank erfolgt.
+ *
+ * @author RK
+ * @version 16.7.1999
+ */
+public class Database implements StorageObject {
+
+ protected DbConnectionBroker myBroker;
+ protected String theTable;
+ protected String theCoreTable=null;
+ protected String thePKeyName="id";
+ protected int thePKeyType;
+ protected boolean evaluatedMetaData=false;
+ protected ArrayList metadataFields,metadataLabels,metadataNotNullFields;
+ protected int[] metadataTypes;
+ protected Class theEntityClass;
+ protected StorageObject myselfDatabase;
+ protected HashMap cache;
+ protected SimpleList popupCache=null;
+ protected boolean hasPopupCache = false;
+ protected SimpleHash hashCache=null;
+ protected boolean hasTimestamp=true;
+ private String database_driver;
+ private String database_url;
+ private int defaultLimit;
+ private DatabaseAdaptor theAdaptor;
+ protected Logfile theLog;
+ protected Connection con;
+
+ /**
+ * Kontruktor bekommt den Filenamen des Konfigurationsfiles übergeben.
+ * Aus diesem file werden <code>Database.Logfile</code>,
+ * <code>Database.Username</code>,<code>Database.Password</code>,
+ * <code>Database.Host</code> und <code>Database.Adaptor</code>
+ * ausgelesen und ein Broker für die Verbindugen zur Datenbank
+ * erzeugt.
+ *
+ * @param String confFilename Dateiname der Konfigurationsdatei
+ */
+ public Database() {
+ theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("Database.Logfile"));
+ String database_username=Configuration.getProperty("Database.Username");
+ String database_password=Configuration.getProperty("Database.Password");
+ String database_host=Configuration.getProperty("Database.Host");
+ String theAdaptorName=Configuration.getProperty("Database.Adaptor");
+ try {
+ theEntityClass = Class.forName("mir.entity.GenericEntity");
+ theAdaptor = (DatabaseAdaptor)Class.forName(theAdaptorName).newInstance();
+ defaultLimit = Integer.parseInt(Configuration.getProperty("Database.Limit"));
+ database_driver=theAdaptor.getDriver();
+ database_url=theAdaptor.getURL(database_username,database_password,database_host);
+ theLog.printDebugInfo("adding Broker with: " +database_driver+":"+database_url );
+ Configuration.addBroker(database_driver,database_url);
+ myBroker=Configuration.getBroker();
+ }
+ catch (Exception e){
+ theLog.printError("Bei Konstruktion von Database() with " + theAdaptorName + " -- " +e.toString());
+ }
+ }
+
+ /**
+ * Liefert die Entity-Klasse zurück, in der eine Datenbankzeile gewrappt
+ * wird. Wird die Entity-Klasse durch die erbende Klasse nicht überschrieben,
+ * wird eine mir.entity.GenericEntity erzeugt.
+ *
+ * @return Class-Objekt der Entity
+ */
+ public java.lang.Class getEntityClass () {
+ return theEntityClass;
+ }
+
+ /**
+ * Liefert die Standardbeschränkung von select-Statements zurück, also
+ * wieviel Datensätze per Default selektiert werden.
+ *
+ * @return Standard-Anzahl der Datensätze
+ */
+ public int getLimit () {
+ return defaultLimit;
+ }
+
+ /**
+ * Liefert den Namen des Primary-Keys zurück. Wird die Variable nicht von
+ * der erbenden Klasse überschrieben, so ist der Wert <code>PKEY</code>
+ * @return Name des Primary-Keys
+ */
+ public String getIdName () {
+ return thePKeyName;
+ }
+
+ /**
+ * Liefert den Namen der Tabelle, auf das sich das Datenbankobjekt bezieht.
+ *
+ * @return Name der Tabelle
+ */
+ public String getTableName () {
+ return theTable;
+ }
+
+ /*
+ * Dient dazu vererbte Tabellen bei objectrelationalen DBMS
+ * zu speichern, wenn die id einer Tabelle in der parenttabelle verwaltet wird.
+ * @return liefert theCoreTabel als String zurueck, wenn gesetzt, sonst
+ * the Table
+ */
+
+ public String getCoreTable(){
+ if (theCoreTable!=null) return theCoreTable;
+ else return theTable;
+ }
+
+ /**
+ * Liefert Feldtypen der Felder der Tabelle zurueck (s.a. java.sql.Types)
+ * @return int-Array mit den Typen der Felder
+ * @exception StorageObjectException
+ */
+ public int[] getTypes () throws StorageObjectException {
+ if (metadataTypes == null)
+ get_meta_data();
+ return metadataTypes;
+ }
+
+ /**
+ * Liefert eine Liste der Labels der Tabellenfelder
+ * @return ArrayListe mit Labeln
+ * @exception StorageObjectException
+ */
+ public ArrayList getLabels () throws StorageObjectException {
+ if (metadataLabels == null)
+ get_meta_data();
+ return metadataLabels;
+ }
+
+ /**
+ * Liefert eine Liste der Felder der Tabelle
+ * @return ArrayList mit Feldern
+ * @exception StorageObjectException
+ */
+ public ArrayList getFields () throws StorageObjectException {
+ if (metadataFields == null)
+ get_meta_data();
+ return metadataFields;
+ }
+
+
+ /*
+ * Uebersetzt die Datenbankwerte in einen String.
+ * @param inValue Wert aus ResultSet.
+ * @param aType Datenbanktyp.
+ * @return liefert den Wert als String zurueck. Wenn keine Umwandlung moeglich
+ * dann /unsupported value/
+ */
+ private String getValueAsString (ResultSet rs, int valueIndex, int aType) throws StorageObjectException {
+ String outValue = null;
+ if (rs != null) {
+ try {
+ switch (aType) {
+ case java.sql.Types.BIT:
+ outValue = (rs.getBoolean(valueIndex) == true) ? "1" : "0";
+ break;
+ case java.sql.Types.INTEGER:case java.sql.Types.SMALLINT:case java.sql.Types.TINYINT:case java.sql.Types.BIGINT:
+ int out = rs.getInt(valueIndex);
+ if (!rs.wasNull())
+ outValue = new Integer(out).toString();
+ break;
+ case java.sql.Types.NUMERIC:
+ long outl = rs.getLong(valueIndex);
+ if (!rs.wasNull())
+ outValue = new Long(outl).toString();
+ break;
+ case java.sql.Types.REAL:
+ float tempf = rs.getFloat(valueIndex);
+ if (!rs.wasNull()) {
+ tempf *= 10;
+ tempf += 0.5;
+ int tempf_int = (int)tempf;
+ tempf = (float)tempf_int;
+ tempf /= 10;
+ outValue = "" + tempf;
+ outValue = outValue.replace('.', ',');
+ }
+ break;
+ case java.sql.Types.DOUBLE:
+ double tempd = rs.getDouble(valueIndex);
+ if (!rs.wasNull()) {
+ tempd *= 10;
+ tempd += 0.5;
+ int tempd_int = (int)tempd;
+ tempd = (double)tempd_int;
+ tempd /= 10;
+ outValue = "" + tempd;
+ outValue = outValue.replace('.', ',');
+ }
+ break;
+ case java.sql.Types.CHAR:case java.sql.Types.VARCHAR:case java.sql.Types.LONGVARCHAR:
+ outValue = rs.getString(valueIndex);
+ if (outValue != null)
+ outValue = StringUtil.encodeHtml(StringUtil.unquote(outValue));
+ break;
+ case java.sql.Types.LONGVARBINARY:
+ outValue = rs.getString(valueIndex);
+ if (outValue != null)
+ outValue = StringUtil.encodeHtml(StringUtil.unquote(outValue));
+ break;
+ case java.sql.Types.TIMESTAMP:
+ Timestamp timestamp = (rs.getTimestamp(valueIndex));
+ if (!rs.wasNull()) {
+ outValue = timestamp.toString();
+ }
+ break;
+ default:
+ outValue = "<unsupported value>";
+ theLog.printWarning("Unsupported Datatype: at " + valueIndex +
+ " (" + aType + ")");
+ }
+ } catch (SQLException e) {
+ throw new StorageObjectException("Could not get Value out of Resultset -- "
+ + e.toString());
+ }
+ }
+ return outValue;
+ }
+
+ /*
+ * select-Operator um einen Datensatz zu bekommen.
+ * @param id Primaerschluessel des Datensatzes.
+ * @return liefert EntityObject des gefundenen Datensatzes oder null.
+ */
+ public Entity selectById(String id)
+ throws StorageObjectException {
+
+ if (id==null||id.equals(""))
+ throw new StorageObjectException("id war null");
+ if (cache != null && cache.containsKey(id))
+ return (Entity)cache.get(id); // wenn cache gesetzt, evtl. kein roundtrip zur Datenbank
+
+ Statement stmt=null;Connection con=getPooledCon();
+ Entity returnEntity=null;
+ try {
+ ResultSet rs;
+ String selectSql = "select * from " + theTable + " where " + thePKeyName + "=" + id;
+ stmt = con.createStatement();
+ rs = executeSql(stmt, selectSql);
+ if (rs != null) {
+ if (evaluatedMetaData==false) evalMetaData(rs.getMetaData());
+ if (rs.next())
+ returnEntity = makeEntityFromResultSet(rs);
+ else theLog.printDebugInfo("Keine daten fuer id: " + id + "in Tabelle" + theTable);
+ rs.close();
+ } else {
+ theLog.printDebugInfo("No Data for Id " + id + " in Table " + theTable);
+ }
+ } catch (SQLException sqe){
+ throwSQLException(sqe,"selectById"); return null;
+ } catch (NumberFormatException e) {
+ theLog.printError("ID ist keine Zahl: " + id);
+ } finally {
+ freeConnection(con,stmt);
+ }
+
+ return returnEntity;
+ }
+
+ /**
+ * select-Operator um Datensaetze zu bekommen, die key = value erfuellen.
+ * @param key Datenbankfeld der Bedingung.
+ * @param value Wert die der key anehmen muss.
+ * @return EntityList mit den gematchten Entities
+ */
+
+ public EntityList selectByFieldValue(String aField, String aValue)
+ throws StorageObjectException {
+
+ return selectByFieldValue(aField, aValue, 0);
+ }
+
+ /**
+ * select-Operator um Datensaetze zu bekommen, die key = value erfuellen.
+ * @param key Datenbankfeld der Bedingung.
+ * @param value Wert die der key anehmen muss.
+ * @param offset Gibt an ab welchem Datensatz angezeigt werden soll.
+ * @return EntityList mit den gematchten Entities
+ */
+
+ public EntityList selectByFieldValue(String aField, String aValue, int offset)
+ throws StorageObjectException {
+
+ return selectByWhereClause(aField + "=" + aValue, offset);
+ }
+
+
+ /**
+ * select-Operator liefert eine EntityListe mit den gematchten Datensätzen zurück.
+ * Also offset wird der erste Datensatz genommen.
+ *
+ * @param wc where-Clause
+ * @return EntityList mit den gematchten Entities
+ * @exception StorageObjectException
+ */
+ public EntityList selectByWhereClause(String where)
+ throws StorageObjectException {
+
+ return selectByWhereClause(where, 0);
+ }
+
+
+ /**
+ * select-Operator liefert eine EntityListe mit den gematchten Datensätzen zurück.
+ * Als maximale Anzahl wird das Limit auf der Konfiguration genommen.
+ *
+ * @param wc where-Clause
+ * @param offset ab welchem Datensatz.
+ * @return EntityList mit den gematchten Entities
+ * @exception StorageObjectException
+ */
+ public EntityList selectByWhereClause(String whereClause, int offset)
+ throws StorageObjectException {
+
+ return selectByWhereClause(whereClause, null, offset);
+ }
+
+ /**
+ * select-Operator liefert eine EntityListe mit den gematchten Datensätzen zurück.
+ * Also offset wird der erste Datensatz genommen.
+ * Als maximale Anzahl wird das Limit auf der Konfiguration genommen.
+ *
+ * @param wc where-Clause
+ * @param ob orderBy-Clause
+ * @return EntityList mit den gematchten Entities
+ * @exception StorageObjectException
+ */
+
+ public EntityList selectByWhereClause(String where, String order)
+ throws StorageObjectException {
+
+ return selectByWhereClause(where, order, 0);
+ }
+ /**
+ * select-Operator liefert eine EntityListe mit den gematchten Datensätzen zurück.
+ * Als maximale Anzahl wird das Limit auf der Konfiguration genommen.
+ *
+ * @param wc where-Clause
+ * @param ob orderBy-Clause
+ * @param offset ab welchem Datensatz
+ * @return EntityList mit den gematchten Entities
+ * @exception StorageObjectException
+ */
+
+ public EntityList selectByWhereClause(String whereClause, String orderBy, int offset)
+ throws StorageObjectException {
+
+ return selectByWhereClause(whereClause, orderBy, offset, defaultLimit);
+ }
+
+
+ /**
+ * select-Operator liefert eine EntityListe mit den gematchten Datensätzen zurück.
+ * @param wc where-Clause
+ * @param ob orderBy-Clause
+ * @param offset ab welchem Datensatz
+ * @param limit wieviele Datensätze
+ * @return EntityList mit den gematchten Entities
+ * @exception StorageObjectException
+ */
+
+ public EntityList selectByWhereClause(String wc, String ob, int offset, int limit)
+ throws StorageObjectException {
+
+ // local
+ EntityList theReturnList=null;
+ Connection con=null;
+ Statement stmt=null;
+ ResultSet rs;
+ int offsetCount = 0;
+ int count=0;
+
+
+ // build sql-statement
+ if (wc != null && wc.length() == 0) {
+ wc = null;
+ }
+ StringBuffer countSql = new StringBuffer("select count(*) from ").append(theTable);
+ StringBuffer selectSql = new StringBuffer("select * from ").append(theTable);
+ if (wc != null) {
+ selectSql.append(" where ").append(wc);
+ countSql.append(" where ").append(wc);
+ }
+ if (ob != null && !(ob.length() == 0)) {
+ selectSql.append(" order by ").append(ob);
+ }
+ if (theAdaptor.hasLimit()) {
+ if (limit > -1 && offset > -1) {
+ selectSql.append(" limit ");
+ if (theAdaptor.reverseLimit()) {
+ selectSql.append(limit).append(",").append(offset);
+ }
+ else {
+ selectSql.append(offset).append(",").append(limit);
+ }
+ }
+ }
+
+ // execute sql
+ try {
+ con = getPooledCon();
+ stmt = con.createStatement();
+ // counting rows
+ if (theAdaptor.hasLimit()) {
+ rs = executeSql(stmt, countSql.toString());
+ if (rs != null) {
+ if (rs.next())
+ count = rs.getInt(1);
+ rs.close();
+ }
+ else
+ theLog.printError("Mh. Konnte nicht zaehlen: " + countSql);
+ }
+ // hier select
+ rs = executeSql(stmt, selectSql.toString());
+ if (rs != null) {
+ theReturnList = new EntityList();
+ if (evaluatedMetaData == false) {
+ evalMetaData(rs.getMetaData());
+ }
+ Entity theResultEntity;
+ while (rs.next()) {
+ theResultEntity = makeEntityFromResultSet(rs);
+ theReturnList.add(theResultEntity);
+ offsetCount++;
+ }
+ rs.close();
+ }
+ // making entitylist
+ if (!(theAdaptor.hasLimit()))
+ count = offsetCount;
+ if (theReturnList != null) {
+ theReturnList.setCount(count);
+ theReturnList.setOffset(offset);
+ theReturnList.setWhere(wc);
+ theReturnList.setOrder(ob);
+ if (offset >= limit) {
+ theReturnList.setPrevBatch(offset - limit);
+ }
+ if (offset + offsetCount < count) {
+ theReturnList.setNextBatch(offset + limit);
+ }
+ }
+ } catch (SQLException sqe) {
+ throwSQLException(sqe, "selectByWhereClause");
+ } finally {
+ freeConnection(con, stmt);
+ }
+ return theReturnList;
+ }
+
+ /**
+ * Bastelt aus einer Zeile der Datenbank ein EntityObjekt.
+ *
+ * @param rs Das ResultSetObjekt.
+ * @return Entity Die Entity.
+ */
+
+ public Entity makeEntityFromResultSet (ResultSet rs) throws StorageObjectException {
+ HashMap theResultHash = new HashMap();
+ String theResult = null;
+ int theType;
+ Entity returnEntity = null;
+ try {
+ int size = metadataFields.size();
+ for (int i = 0; i < size; i++) {
+ // alle durchlaufen bis nix mehr da
+ theType = metadataTypes[i];
+ if (theType == java.sql.Types.LONGVARBINARY) {
+ InputStream us = rs.getAsciiStream(i + 1);
+ if (us != null) {
+ InputStreamReader is = new InputStreamReader(us);
+ char[] data = new char[32768];
+ StringBuffer theResultString = new StringBuffer();
+ int len;
+ while ((len = is.read(data)) > 0) {
+ theResultString.append(data, 0, len);
+ }
+ is.close();
+ theResult = theResultString.toString();
+ }
+ else {
+ theResult = null;
+ }
+ }
+ else {
+ theResult = getValueAsString(rs, (i + 1), theType);
+ }
+ if (theResult != null) {
+ theResultHash.put(metadataFields.get(i), theResult);
+ }
+ }
+ if (cache != null && theResultHash.containsKey(thePKeyName) && cache.containsKey((String)theResultHash.get(thePKeyName))) {
+ //theLog.printDebugInfo("CACHE: (out) "+ theResultHash.get(thePKeyName)+ " :"+theTable);
+ returnEntity = (Entity)cache.get((String)theResultHash.get(thePKeyName));
+ }
+ else {
+ if (theEntityClass != null) {
+ returnEntity = (Entity)theEntityClass.newInstance();
+ returnEntity.setValues(theResultHash);
+ returnEntity.setStorage(myselfDatabase);
+ if (cache != null) {
+ //theLog.printDebugInfo("CACHE: ( in) " + returnEntity.getId() + " :"+theTable);
+ cache.put(returnEntity.getId(), returnEntity);
+ }
+ }
+ else {
+ throwStorageObjectException("Interner Fehler theEntityClass nicht gesetzt!");
+ }
+ }
+ } // try
+ catch (IllegalAccessException e) {
+ throwStorageObjectException("Kein Zugriff! -- " + e.toString());
+ } catch (IOException e) {
+ throwStorageObjectException("IOException! -- " + e.toString());
+ } catch (InstantiationException e) {
+ throwStorageObjectException("Keine Instantiiierung! -- " + e.toString());
+ } catch (SQLException sqe) {
+ throwSQLException(sqe, "makeEntityFromResultSet");
+ return null;
+ }
+ return returnEntity;
+ }
+
+ /**
+ * insert-Operator: fügt eine Entity in die Tabelle ein. Eine Spalte WEBDB_CREATE
+ * wird automatisch mit dem aktuellen Datum gefuellt.
+ *
+ * @param theEntity
+ * @return der Wert des Primary-keys der eingefügten Entity
+ */
+ public String insert (Entity theEntity) throws StorageObjectException {
+ String returnId = "0";
+ Connection con = null;
+ PreparedStatement pstmt = null;
+ //cache
+ invalidatePopupCache();
+ try {
+ HashMap theEntityValues = theEntity.getValues();
+ ArrayList streamedInput = theEntity.streamedInput();
+ StringBuffer f = new StringBuffer();
+ StringBuffer v = new StringBuffer();
+ String aField, aValue;
+ boolean firstField = true;
+ // make sql-string
+ for (int i = 0; i < getFields().size(); i++) {
+ aField = (String)getFields().get(i);
+ if (!aField.equals(thePKeyName)) {
+ aValue = null;
+ // sonderfaelle
+ if (aField.equals("webdb_create")) {
+ aValue = "NOW()";
+ }
+ else {
+ if (streamedInput != null && streamedInput.contains(aField)) {
+ aValue = "?";
+ }
+ else {
+ if (theEntityValues.containsKey(aField)) {
+ aValue = "'" + StringUtil.quote((String)theEntityValues.get(aField))
+ + "'";
+ }
+ }
+ }
+ // wenn Wert gegeben, dann einbauen
+ if (aValue != null) {
+ if (firstField == false) {
+ f.append(",");
+ v.append(",");
+ }
+ else {
+ firstField = false;
+ }
+ f.append(aField);
+ v.append(aValue);
+ }
+ }
+ } // end for
+ // insert into db
+ StringBuffer sqlBuf = new StringBuffer("insert into ").append(theTable).append("(").append(f).append(") values (").append(v).append(")");
+ String sql = sqlBuf.toString();
+ theLog.printInfo("INSERT: " + sql);
+ con = getPooledCon();
+ con.setAutoCommit(false);
+ pstmt = con.prepareStatement(sql);
+ if (streamedInput != null) {
+ for (int i = 0; i < streamedInput.size(); i++) {
+ String inputString = (String)theEntityValues.get(streamedInput.get(i));
+ pstmt.setBytes(i + 1, inputString.getBytes());
+ }
+ }
+ pstmt.execute();
+ pstmt = con.prepareStatement(theAdaptor.getLastInsertSQL((Database)myselfDatabase));
+ ResultSet rs = pstmt.executeQuery();
+ rs.next();
+ returnId = rs.getString(1);
+ theEntity.setId(returnId);
+ } catch (SQLException sqe) {
+ throwSQLException(sqe, "insert");
+ } finally {
+ try {
+ con.setAutoCommit(true);
+ } catch (Exception e) {
+ ;
+ }
+ freeConnection(con, pstmt);
+ }
+ return returnId;
+ }
+
+ /**
+ * update-Operator: aktualisiert eine Entity. Eine Spalte WEBDB_LASTCHANGE
+ * wird automatisch mit dem aktuellen Datum gefuellt.
+ *
+ * @param theEntity
+ */
+ public void update (Entity theEntity) throws StorageObjectException {
+ Connection con = null;
+ PreparedStatement pstmt = null;
+ ArrayList streamedInput = theEntity.streamedInput();
+ HashMap theEntityValues = theEntity.getValues();
+ String id = theEntity.getId();
+ String aField;
+ StringBuffer fv = new StringBuffer();
+ boolean firstField = true;
+ //cache
+ invalidatePopupCache();
+ // build sql statement
+ for (int i = 0; i < getFields().size(); i++) {
+ aField = (String)metadataFields.get(i);
+ // only normal cases
+ if (!(aField.equals(thePKeyName) || aField.equals("webdb_create") ||
+ aField.equals("webdb_lastchange") || (streamedInput != null && streamedInput.contains(aField)))) {
+ if (theEntityValues.containsKey(aField)) {
+ if (firstField == false) {
+ fv.append(", ");
+ }
+ else {
+ firstField = false;
+ }
+ fv.append(aField).append("='").append(StringUtil.quote((String)theEntityValues.get(aField))).append("'");
+ }
+ }
+ }
+ StringBuffer sql = new StringBuffer("update ").append(theTable).append(" set ").append(fv);
+ // exceptions
+ if (metadataFields.contains("webdb_lastchange")) {
+ sql.append(",webdb_lastchange=NOW()");
+ }
+ if (streamedInput != null) {
+ for (int i = 0; i < streamedInput.size(); i++) {
+ sql.append(",").append(streamedInput.get(i)).append("=?");
+ }
+ }
+ sql.append(" where id=").append(id);
+ theLog.printInfo("UPDATE: " + sql);
+ // execute sql
+ try {
+ con = getPooledCon();
+ con.setAutoCommit(false);
+ pstmt = con.prepareStatement(sql.toString());
+ if (streamedInput != null) {
+ for (int i = 0; i < streamedInput.size(); i++) {
+ String inputString = (String)theEntityValues.get(streamedInput.get(i));
+ pstmt.setBytes(i + 1, inputString.getBytes());
+ }
+ }
+ pstmt.executeUpdate();
+ } catch (SQLException sqe) {
+ throwSQLException(sqe, "update");
+ } finally {
+ try {
+ con.setAutoCommit(true);
+ } catch (Exception e) {
+ ;
+ }
+ freeConnection(con, pstmt);
+ }
+ }
+
+ /*
+ * delete-Operator
+ * @param id des zu loeschenden Datensatzes
+ * @return boolean liefert true zurueck, wenn loeschen erfolgreich war.
+ */
+ public boolean delete (String id) throws StorageObjectException {
+ Statement stmt = null;
+ Connection con = null;
+ String sql;
+ int res = 0;
+ // loeschen des caches
+ invalidatePopupCache();
+ sql = "delete from " + theTable + " where " + thePKeyName + "='" + id +
+ "'";
+ theLog.printInfo("DELETE " + sql);
+ try {
+ con = getPooledCon();
+ stmt = con.createStatement();
+ res = stmt.executeUpdate(sql);
+ } catch (SQLException sqe) {
+ throwSQLException(sqe, "delete");
+ } finally {
+ freeConnection(con, stmt);
+ }
+ if (cache != null) {
+ theLog.printInfo("CACHE: deleted " + id);
+ cache.remove(id);
+ }
+ return (res > 0) ? true : false;
+ }
+
+ /* noch nicht implementiert.
+ * @return immer false
+ */
+ public boolean delete (EntityList theEntityList) {
+ invalidatePopupCache();
+ return false;
+ }
+
+ /**
+ * Diese Methode sollte ueberschrieben werden, wenn fuer die abgeleitete Database-Klasse
+ * eine SimpleList mit Standard-Popupdaten erzeugt werden koennen soll.
+ * @return null
+ */
+ public SimpleList getPopupData () {
+ return null;
+ }
+
+ /**
+ * Holt Daten fuer Popups.
+ * @param name Name des Feldes.
+ * @param hasNullValue Wenn true wird eine leerer Eintrag fuer die Popups erzeugt.
+ * @return SimpleList Gibt freemarker.template.SimpleList zurueck.
+ */
+ public SimpleList getPopupData (String name, boolean hasNullValue) {
+ return getPopupData(name, hasNullValue, null);
+ }
+
+ /**
+ * Holt Daten fuer Popups.
+ * @param name Name des Feldes.
+ * @param hasNullValue Wenn true wird eine leerer Eintrag fuer die Popups erzeugt.
+ * @param where Schraenkt die Selektion der Datensaetze ein.
+ * @return SimpleList Gibt freemarker.template.SimpleList zurueck.
+ */
+ public SimpleList getPopupData (String name, boolean hasNullValue, String where) {
+ return getPopupData(name, hasNullValue, where, null);
+ }
+
+ /**
+ * Holt Daten fuer Popups.
+ * @param name Name des Feldes.
+ * @param hasNullValue Wenn true wird eine leerer Eintrag fuer die Popups erzeugt.
+ * @param where Schraenkt die Selektion der Datensaetze ein.
+ * @param order Gibt ein Feld als Sortierkriterium an.
+ * @return SimpleList Gibt freemarker.template.SimpleList zurueck.
+ */
+ public SimpleList getPopupData (String name, boolean hasNullValue, String where,
+ String order) {
+ // caching
+ if (hasPopupCache && popupCache != null)
+ return popupCache;
+ SimpleList simpleList = null;
+ Connection con = null;
+ Statement stmt = null;
+ // build sql
+ StringBuffer sql = new StringBuffer("select ").append(thePKeyName).append(",").append(name).append(" from ").append(theTable);
+ if (where != null && !(where.length() == 0))
+ sql.append(" where ").append(where);
+ sql.append(" order by ");
+ if (order != null && !(order.length() == 0))
+ sql.append(order);
+ else
+ sql.append(name);
+ // execute sql
+ try {
+ con = getPooledCon();
+ stmt = con.createStatement();
+ ResultSet rs = executeSql(stmt, sql.toString());
+ if (rs != null) {
+ if (evaluatedMetaData == false)
+ get_meta_data();
+ simpleList = new SimpleList();
+ SimpleHash popupDict;
+ if (hasNullValue) {
+ popupDict = new SimpleHash();
+ popupDict.put("key", "");
+ popupDict.put("value", "--");
+ simpleList.add(popupDict);
+ }
+ while (rs.next()) {
+ popupDict = new SimpleHash();
+ popupDict.put("key", getValueAsString(rs, 1, thePKeyType));
+ popupDict.put("value", rs.getString(2));
+ simpleList.add(popupDict);
+ }
+ rs.close();
+ }
+ } catch (Exception e) {
+ theLog.printDebugInfo(e.toString());
+ } finally {
+ freeConnection(con, stmt);
+ }
+ if (hasPopupCache) {
+ popupCache = simpleList;
+ }
+ return simpleList;
+ }
+
+ /**
+ * Liefert alle Daten der Tabelle als SimpleHash zurueck. Dies wird verwandt,
+ * wenn in den Templates ein Lookup-Table benoetigt wird. Sollte nur bei kleinen
+ * Tabellen Verwendung finden.
+ * @return SimpleHash mit den Tabellezeilen.
+ */
+ public SimpleHash getHashData () {
+ if (hashCache == null) {
+ try {
+ hashCache = HTMLTemplateProcessor.makeSimpleHash(selectByWhereClause("",
+ -1));
+ } catch (StorageObjectException e) {
+ theLog.printDebugInfo(e.toString());
+ }
+ }
+ return hashCache;
+ }
+
+ /* invalidates the popupCache
+ */
+ private void invalidatePopupCache () {
+
+ /** @todo invalidates toooo much */
+ popupCache = null;
+ hashCache = null;
+ }
+
+ /**
+ * Diese Methode fuehrt den Sqlstring <i>sql</i> aus und timed im Logfile.
+ * @param stmt Statemnt
+ * @param sql Sql-String
+ * @return ResultSet
+ * @exception StorageObjectException, SQLException
+ */
+ public ResultSet executeSql (Statement stmt, String sql) throws StorageObjectException,
+ SQLException {
+ long startTime = (new java.util.Date()).getTime();
+ ResultSet rs = stmt.executeQuery(sql);
+ theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: "
+ + sql);
+ return rs;
+ }
+
+ /**
+ * Fuehrt Statement stmt aus und liefert Resultset zurueck. Das SQL-Statment wird
+ * getimed und geloggt.
+ * @param stmt PreparedStatement mit der SQL-Anweisung
+ * @return Liefert ResultSet des Statements zurueck.
+ * @exception StorageObjectException, SQLException
+ */
+ public ResultSet executeSql (PreparedStatement stmt) throws StorageObjectException,
+ SQLException {
+ long startTime = (new java.util.Date()).getTime();
+ ResultSet rs = stmt.executeQuery();
+ theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms.");
+ return rs;
+ }
+
+ /**
+ * returns the number of rows in the table
+ */
+ public int getSize(String where)
+ throws SQLException,StorageObjectException
+ {
+ long startTime = (new java.util.Date()).getTime();
+ String sql = "SELECT count(*) FROM "+ theTable + " where " + where;
+ //theLog.printDebugInfo("trying: "+ sql);
+ Connection con = null;
+ Statement stmt = null;
+ int result = 0;
+
+ try {
+ con = getPooledCon();
+ stmt = con.createStatement();
+ ResultSet rs = executeSql(stmt,sql);
+ while(rs.next()){
+ result = rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ theLog.printError(e.toString());
+ } finally {
+ freeConnection(con,stmt);
+ }
+ theLog.printInfo(theTable + " has "+ result +" rows where " + where);
+ theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: " + sql);
+ return result;
+ }
+
+ public int executeUpdate(Statement stmt, String sql)
+ throws StorageObjectException, SQLException
+ {
+ long startTime = (new java.util.Date()).getTime();
+ //theLog.printDebugInfo("trying: "+ sql);
+ int rs = stmt.executeUpdate(sql);
+ theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: " + sql);
+ return rs;
+ }
+
+ public int executeUpdate(String sql)
+ throws StorageObjectException, SQLException
+ {
+ int result=-1;
+ long startTime = (new java.util.Date()).getTime();
+ Connection con=null;PreparedStatement pstmt=null;
+ try {
+ con=getPooledCon();
+ pstmt = con.prepareStatement(sql);
+ result = pstmt.executeUpdate();
+ }
+ catch (Exception e) {theLog.printDebugInfo("settimage :: setImage gescheitert: "+e.toString());}
+ finally { freeConnection(con,pstmt); }
+ theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: " + sql);
+ return result;
+ }
+
+ /**
+ * Wertet ResultSetMetaData aus und setzt interne Daten entsprechend
+ * @param md ResultSetMetaData
+ * @exception StorageObjectException
+ */
+ private void evalMetaData (ResultSetMetaData md) throws StorageObjectException {
+ this.evaluatedMetaData = true;
+ this.metadataFields = new ArrayList();
+ this.metadataLabels = new ArrayList();
+ this.metadataNotNullFields = new ArrayList();
+ try {
+ int numFields = md.getColumnCount();
+ this.metadataTypes = new int[numFields];
+ String aField;
+ int aType;
+ for (int i = 1; i <= numFields; i++) {
+ aField = md.getColumnName(i);
+ metadataFields.add(aField);
+ metadataLabels.add(md.getColumnLabel(i));
+ aType = md.getColumnType(i);
+ metadataTypes[i - 1] = aType;
+ if (aField.equals(thePKeyName)) {
+ thePKeyType = aType;
+ }
+ if (md.isNullable(i) == md.columnNullable) {
+ metadataNotNullFields.add(aField);
+ }
+ }
+ } catch (SQLException e) {
+ throwSQLException(e, "evalMetaData");
+ }
+ }
+
+ /**
+ * Wertet die Metadaten eines Resultsets fuer eine Tabelle aus,
+ * um die alle Columns und Typen einer Tabelle zu ermitteln.
+ */
+ private void get_meta_data () throws StorageObjectException {
+ Connection con = null;
+ PreparedStatement pstmt = null;
+ String sql = "select * from " + theTable + " where 0=1";
+ try {
+ con = getPooledCon();
+ pstmt = con.prepareStatement(sql);
+ theLog.printInfo("METADATA: " + sql);
+ ResultSet rs = pstmt.executeQuery();
+ evalMetaData(rs.getMetaData());
+ rs.close();
+ } catch (SQLException e) {
+ throwSQLException(e, "get_meta_data");
+ } finally {
+ freeConnection(con, pstmt);
+ }
+ }
+
+ /**
+ * Datenbankverbindung wird geschlossen
+ */
+ public void disconnectPool () {
+ try {
+ myBroker.destroy(100);
+ } catch (SQLException sqe) {
+ ;
+ }
+ }
+
+ /**
+ * Liefert ein Connection-Objekt aus dem ConnectionPool.
+ * @return Connection Objekt.
+ */
+ public Connection getPooledCon () throws StorageObjectException {
+ if (myBroker != null) {
+ Connection con = myBroker.getConnection();
+ if (con != null)
+ return con;
+ }
+ throw new StorageObjectException("KEINE VERBINDUNG ZUR DATENBANK");
+ }
+
+ /**
+ * Connection und StatementObjekt werden geschlossen und an den Connectionpool
+ * zurückgeben
+ * @param con Connection zur Datenbank
+ * @param stmt Statement-Objekt
+ */
+ public void freeConnection (Connection con, Statement stmt) {
+ try {
+ if (stmt != null)
+ stmt.close();
+ } catch (SQLException e1) {
+ theLog.printDebugInfo(e1.toString());
+ }
+ if (con != null)
+ myBroker.freeConnection(con);
+ else
+ theLog.printDebugInfo("Con was null!");
+ }
+
+ /**
+ * Wertet SQLException aus und wirft dannach eine StorageObjectException
+ * @param sqe SQLException
+ * @param wo Funktonsname, in der die SQLException geworfen wurde
+ * @exception StorageObjectException
+ */
+ void throwSQLException (SQLException sqe, String wo) throws StorageObjectException {
+ String state = "";
+ String message = "";
+ int vendor = 0;
+ if (sqe != null) {
+ state = sqe.getSQLState();
+ message = sqe.getMessage();
+ vendor = sqe.getErrorCode();
+ }
+ theLog.printError(state + ": " + vendor + " : " + message + " Funktion: "
+ + wo);
+ throw new StorageObjectException((sqe == null) ? "undefined sql exception" :
+ sqe.toString());
+ }
+
+ /**
+ * Loggt Fehlermeldung mit dem Parameter Message und wirft dannach eine StorageObjectException
+ * @param message Nachricht mit dem Fehler
+ * @exception StorageObjectException
+ */
+ void throwStorageObjectException (String message) throws StorageObjectException {
+ theLog.printError(message);
+ throw new StorageObjectException(message);
+ }
+}
+
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.storage;
+
+import java.util.*;
+
+
+/**
+ * Interfacedefinition für Datenbank-Adpatoren. Die Adaptoren legen
+ * jeweils das Verhalten und die Befehlsmächtigkeit der Datenbank
+ * fest.
+ *
+ * @author <RK>
+ * @version 27.6.1999
+ */
+
+public interface DatabaseAdaptor{
+
+ /* Liefert den Namen der Adaptorklasse
+ * @return Adaptorklasse als String
+ */
+ public abstract String getDriver ();
+
+
+ /**
+ * Liefert die URL für JDBC zurück, in den die Parameter user, pass und host
+ * eingefügt werden. Die URL wird aus der Konfiguration geholt.
+ *
+ * @param user user als String
+ * @param pass passwort als String
+ * @param host host als String
+ * @return url als String
+ */
+ public abstract String getURL (String user, String pass, String host);
+
+
+ /**
+ * Gibt zurück, ob das SQL der Datenbank den <code>limit</code>-Befehl beherrscht.
+ * @return true wenn ja, sonst false
+ */
+ public abstract boolean hasLimit ();
+
+
+ /**
+ * Liefert zurück, ob der <code>limit</code>-Befehl erst start und dann offset
+ * hat (true), oder umgekehrt. Nur Relevant, wenn hasLimit true zurückliefert.
+ *
+ * @return true wenn erstes, sonst false
+ */
+ public abstract boolean reverseLimit ();
+
+
+ /**
+ * Liefert ein Properties-Objekt zurueck mit user und password.
+ * @param user
+ * @param password
+ * @return Properties
+ */
+ public abstract Properties getProperties (String user, String password);
+
+
+ /**
+ * Gibt SQL-Stringfragment zurück, mit dem nach einem insert-Befehl ermittelt
+ * werden kann, wie man den primary-Key des eingefügten Datensatzes bekommt.
+ *
+ * @param theDB Database-Objekt, aus dem ggf. noetige Informationen geholt
+ * werden können, wie z.B. der Tabellenname
+ * @return SQL-Statement als String
+ */
+ public abstract String getLastInsertSQL (Database theDB);
+}
+
+
--- /dev/null
+package mir.storage;
+
+import java.util.*;
+import mir.misc.*;
+
+/**
+ * <b>Diese Klasse implementiert die abstrakte Klasse DatabaseAdaptor
+ *
+ * @author <RK>
+ * @version 27.6.1999
+ */
+
+public final class DatabaseAdaptorMySQL implements DatabaseAdaptor{
+
+ public String getDriver() {
+ return Configuration.getProperty("Adaptor.MySQL.Driver");
+ }
+
+ public String getURL(String user, String pass, String host) {
+ return Configuration.getProperty("Adaptor.MySQL.URL");
+ }
+
+ public boolean hasLimit() {
+ return true;
+ }
+
+ public boolean reverseLimit() {
+ return false;
+ }
+
+ public Properties getProperties(String user, String password) {
+ return null;
+ }
+
+ public String getLastInsertSQL(Database theDB) {
+ return "select last_insert_id()";
+ }
+}
+
+
--- /dev/null
+/*
+ * put your module comment here
+ */
+
+
+package mir.storage;
+
+import java.util.*;
+import mir.misc.*;
+
+
+/**
+ * Diese Klasse implementiert Interface DatabaseAdaptor fuer Oracle
+ *
+ * @author <RK>
+ * @version 15.05.2000
+ */
+public final class DatabaseAdaptorOracle
+ implements DatabaseAdaptor {
+
+ /**
+ * Liefert den Namen der Adaptorklasse <code>Adaptor.Oracle.Driver</code>
+ * für Oracle zurück.
+ * @return Adaptorklasse als String
+ */
+ public String getDriver() {
+ return Configuration.getProperty("Adaptor.Oracle.Driver");
+ }
+
+ /**
+ * Liefert die URL für JDBC zurück, in den die Parameter user, pass und host
+ * eingefügt werden. Die URL wird aus der Konfiguration geholt.
+ *
+ * @param user user als String
+ * @param pass passwort als String
+ * @param host host als String
+ * @return url als String
+ */
+ public String getURL(String user, String pass, String host) {
+ return Configuration.getProperty("Adaptor.Oracle.URL");
+ /** @todo hier muesste bessererweise $HOST durch HOST ersetzt, etc. werden */
+
+ }
+
+ /**
+ * Gibt zurück, ob das SQL der Datenbank den <code>limit</code>-Befehl beherrscht.
+ * @return false
+ */
+ public boolean hasLimit() {
+ return false;
+ }
+
+ /**
+ * Liefert zurück, ob der <code>limit</code>-Befehl erst start und dann offset
+ * hat (true), oder umgekehrt. Nur Relevant, wenn hasLimit true zurückliefert.
+ *
+ * @return false
+ */
+ public boolean reverseLimit() {
+ return false;
+ }
+
+ /**
+ * Liefert ein Properties-Objekt zurueck mit user und password.
+ * @param user
+ * @param password
+ * @return Properties
+ */
+ public Properties getProperties(String user, String password) {
+ return null;
+ }
+
+
+
+
+
+
+
+
+ public String getLastInsertSQL(Database theDB) {
+ return "select currval('"+theDB.getCoreTable()+"_id_seq')";
+ }
+}
--- /dev/null
+package mir.storage;
+
+import java.util.*;
+import mir.misc.*;
+
+/**
+ * <b>Diese Klasse implementiert die abstrakte Klasse DatabaseAdaptor für Postgresql-Datenbanken
+ *
+ * @author <RK>
+ * @version 30.12.2000
+ */
+
+public final class DatabaseAdaptorPostgresql implements DatabaseAdaptor{
+
+ public String getDriver() {
+ return Configuration.getProperty("Adaptor.PostgreSQL.Driver");
+ }
+
+ public String getURL(String user, String pass, String host) {
+ return Configuration.getProperty("Adaptor.PostgreSQL.URL");
+ }
+
+ public boolean hasLimit() {
+ return true;
+ }
+
+ public boolean reverseLimit() {
+ return true;
+ }
+
+ public Properties getProperties(String user, String password) {
+ return null;
+ }
+
+ public String getLastInsertSQL(Database theDB) {
+ return "select currval('"+theDB.getCoreTable()+"_id_seq')";
+ }
+}
+
+
--- /dev/null
+/*
+ * Implementiert DatabaseAdaptor Interface für Sybase.
+ */
+
+
+package mir.storage;
+
+import java.util.*;
+import mir.misc.*;
+
+
+/**
+ * Diese Klasse implementiert Interface DatabaseAdaptor fuer Sybase
+ *
+ * @author <RK>
+ * @version 15.05.2000
+ */
+public final class DatabaseAdaptorSybase
+ implements DatabaseAdaptor {
+
+ /**
+ * Liefert den Namen der Adaptorklasse <code>Adaptor.Sybase.Driver</code>
+ * für Sybase zurück.
+ * @return Adaptorklasse als String
+ */
+ public String getDriver() {
+ return Configuration.getProperty("Adaptor.Sybase.Driver");
+ }
+
+ /**
+ * Liefert die URL für JDBC zurück, in den die Parameter user, pass und host
+ * eingefügt werden. Die URL wird aus der Konfiguration geholt.
+ *
+ * @param user user als String
+ * @param pass passwort als String
+ * @param host host als String
+ * @return url als String
+ */
+ public String getURL(String user, String pass, String host) {
+ return Configuration.getProperty("Adaptor.Sybase.URL");
+ /** @todo hier muesste bessererweise $HOST durch HOST ersetzt, etc. werden */
+ }
+
+ /**
+ * Gibt zurück, ob das SQL der Datenbank den <code>limit</code>-Befehl beherrscht.
+ * @return false
+ */
+ public boolean hasLimit () {
+ return false;
+ }
+
+ /**
+ * Liefert zurück, ob der <code>limit</code>-Befehl erst start und dann offset
+ * hat (true), oder umgekehrt. Nur Relevant, wenn hasLimit true zurückliefert.
+ *
+ * @return false
+ */
+ public boolean reverseLimit() {
+ return false;
+ }
+
+ /**
+ * Liefert ein Properties-Objekt zurueck mit user und password.
+ * @param user
+ * @param password
+ * @return Properties
+ */
+ public Properties getProperties(String user, String password) {
+ Properties props = new Properties();
+ props.put("user", user);
+ props.put("password", password);
+ return props;
+ }
+
+
+
+
+
+
+
+
+ public String getLastInsertSQL(Database theDB) {
+ return "select currval('"+theDB.getCoreTable()+"_id_seq')";
+ }
+}
--- /dev/null
+/*
+ * Implementiert Interface für die Speicherschicht.
+ * Bislang gibt es in der Bibliothek nur die Möglichkeit
+ * in einer Datenbank zu speichern.
+ */
+package mir.storage;
+
+import java.lang.*;
+import java.util.*;
+import java.sql.*;
+import freemarker.template.*;
+import mir.entity.*;
+
+
+/**
+ * Implementiert Interface für die Speicherschicht.
+ * Bislang gibt es in der Bibliothek nur die Möglichkeit
+ * in einer Datenbank zu speichern.
+ * @author RK
+ * @version 29.6.1999
+ */
+public interface StorageObject {
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param id
+ * @return Entity
+ * @exception StorageObjectException
+ */
+ abstract public Entity selectById (String id) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param aField
+ * @param aValue
+ * @return EntityList
+ * @exception StorageObjectException
+ */
+ abstract public EntityList selectByFieldValue (String aField, String aValue) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param whereClause
+ * @return EntityList
+ * @exception StorageObjectException
+ */
+ abstract public EntityList selectByWhereClause (String whereClause) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param whereClause
+ * @param offset
+ * @return EntityList
+ * @exception StorageObjectException
+ */
+ abstract public EntityList selectByWhereClause (String whereClause, int offset) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param whereClause
+ * @param orderBy
+ * @param offset
+ * @return EntityList
+ * @exception StorageObjectException
+ */
+ abstract public EntityList selectByWhereClause (String whereClause, String orderBy,
+ int offset) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param whereClause
+ * @param orderBy
+ * @param offset
+ * @param limit
+ * @return EntityList
+ * @exception StorageObjectException
+ */
+ abstract public EntityList selectByWhereClause (String whereClause, String orderBy,
+ int offset, int limit) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param id
+ * @return boolen
+ * @exception StorageObjectException
+ */
+ abstract public boolean delete (String id) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return ArrayList
+ * @exception StorageObjectException
+ */
+ abstract public ArrayList getFields () throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return int[]
+ * @exception StorageObjectException
+ */
+ abstract public int[] getTypes () throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return ArrayList
+ * @exception StorageObjectException
+ */
+ abstract public ArrayList getLabels () throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param a
+ * @exception StorageObjectException
+ */
+ abstract public void update (Entity a) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param a
+ * @return String id
+ * @exception StorageObjectException
+ */
+ abstract public String insert (Entity a) throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return Class Klasse der Entity
+ */
+ abstract public Class getEntityClass();
+
+
+
+ /**
+ * put your documentation comment here
+ * @return
+ */
+ abstract public String getIdName();
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return String
+ */
+ abstract public String getTableName();
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return SimpleHash
+ */
+ abstract public SimpleHash getHashData();
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return Connection
+ * @exception StorageObjectException
+ */
+ abstract public Connection getPooledCon () throws StorageObjectException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param a
+ * @param sql
+ * @return ResultSet
+ * @exception StorageObjectException, SQLException
+ */
+ abstract public ResultSet executeSql (Statement a, String sql) throws StorageObjectException,
+ SQLException;
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @param con
+ * @param stmt
+ */
+ abstract public void freeConnection(Connection con, Statement stmt);
+
+
+
+ /**
+ * Dokumentation siehe Database.java
+ * @return
+ */
+ abstract public SimpleList getPopupData ();
+
+ abstract public int executeUpdate(Statement a, String sql) throws StorageObjectException, SQLException ;
+ abstract public int executeUpdate(String sql) throws StorageObjectException, SQLException ;
+ abstract public int getSize(String where) throws SQLException,StorageObjectException;
+
+}
+
+
+
--- /dev/null
+/**
+ * <b>Exception fuer StorageObject</b><p>
+ *
+ * @author RK
+ * @version 30.6.1999
+ *
+ *
+ */
+
+
+package mir.storage;
+
+import java.lang.*;
+
+
+/**
+ * Expception Objekt fuer alle Fehler, die in der Speicherzugriffsschicht
+ * (mir.storage) auftauchen
+ */
+public class StorageObjectException extends Exception {
+
+ /**
+ * Leerer Konstruktor
+ */
+ public StorageObjectException () {
+ super();
+ }
+
+ /**
+ * Konstruktor mit Nachricht
+ * @param String msg
+ */
+ public StorageObjectException (String msg) {
+ super(msg);
+ }
+}
+
+
+
+
projects / mir.git / commitdiff