001: /*
002: * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/web/TKParams.java,v 1.8 2001/06/11 14:04:38 alex Exp $
003: *
004: */
005: /**
006: * Wird ein HTTP-Request ueber das CGI an den Server gestellt, werden spezielle Informationen
007: * in Form eines Query-Strings an den URL angehangen. Die Applikation, die durch diesen
008: * Request auf dem Server ausgefuehrt werden soll kann nun den Query-String auslesen und diese
009: * fuer die Genereirung eines Templates benutzen.
010: * Team-Konzept hat eine eigene Parameter-Sysntax entwickelt, die in einem Querystring uebergeben
011: * werden.
012: * Der Klasse TKParams wird ein Hash uebergeben, der den Query-String bereits grob bearbeitet hat.
013: * Diese Informationen werden gesplittet und sinnvoll in einem neuen Hash abgelegt.
014: *-------------------------------------------------------------------------------------------------------
015: *
016: * 1. Die Konstruktoren rufen die Methode init() aus, der Folgender Hash uebergeben wird:
017: * keys: URLParameterNamen = TK_PARClassId[TKParameterName;
018: * TKParameterSubklassenName:TKParameterSubklassenWert]
019: *
020: * vals: URLParameterWerte
021: *-------------------------------------------------------------------------------------------------------
022: *
023: * 2. Die URLParameterNamen werden in einem Bsp. mit folgendem Ergebnis bearbeitet:
024: * URLParameterName = URLParameterWert -> TK_PAR[ALTER;TYPE:INT] = 33
025: * Ergebnishash:
026: * -------------------------
027: * | PARAM | --------------- |
028: * | | | ALTER | 33 | |
029: * | | | .... | .. | |
030: * | | -------------- |
031: * ---------------------------
032: * | TYPE | --------------- |
033: * | | | ALTER | INT | |
034: * | | | .... | .. | |
035: * | | -------------- |
036: * ---------------------------
037: *
038: *-------------------------------------------------------------------------------------------------------
039: *
040: * 3. Als Parameter gilt:
041: * a) siehe Punkt1 mit TK_PARClassId = TK_PAR[...]
042: * b) ein Event gilt auch als Parameter: TP_EV[Eventname]=
043: * c) Dies sind bereits implementierte Beispiele, die jedoch nur exemplarisch sind.
044: *
045: *-------------------------------------------------------------------------------------------------------
046: */package com.teamkonzept.web;
047:
048: import java.util.*;
049: import com.teamkonzept.lib.*;
050: import com.oroinc.text.regex.*;
051: import org.apache.log4j.Category;
052:
053: /**
054: * Klasse TKParams ist Subklasse von TKHashtable
055: * Klasse TKHashtable ist Subklasse von Hashtable
056: * Somit werden alle Felder und Methoden von Hashtable und TKHashtable vererbt.
057: * Das Objekt TKParams ist somit selbst eine Hashtable
058: */
059: public class TKParams extends TKHashtable {
060: private static final Category cat = Category
061: .getInstance(TKParams.class);
062:
063: static boolean initialized = false;
064: static private final String patTrailer = "TK_";
065: static private Pattern patParName;
066: static private Pattern patSubClass;
067:
068: /**
069: * Konstruktor1
070: *
071: * Wird der Konstruktor ohne Parameter aufgerufen, so muss (z.Z.) zuvor ein Objekt der Klasse
072: * TKHttp erzeugt worden sein und das TKHttpInterface, welches die Methode getParams()
073: * zur Verfuegung stellt.
074: * Die Klasse TkHttp stellt die abstrakte Klassenmethode GetInterface() zur
075: * Verfuegung.
076: *
077: * Der Methode init() wird somit ein TKHashtable uebergeben, der die Parameter enthaelt.
078: */
079: public TKParams() {
080: if (!initialized)
081: init();
082: initParams(TKHttp.getInterface().getParams());
083: }
084:
085: /**
086: * Konstruktor2
087: *
088: * Dem Konstruktor wird ein Hash uebergeben, der die Parameter enthaelt. Dieser
089: * wird wiederum der Methode init() uebergeben. Das TKHttpInterface-Objekt muss
090: * bereits erzeugt worden sein.
091: *
092: * Erzeugung eines Obkjekts der Klasse TKParam:
093: * TKHashtable pureParams = httpInterface.getParams();
094: * TKParams params = new TKParams( pureParams );
095: *
096: * @param TKHashtable pureParams
097: */
098: public TKParams(TKHashtable pureParams) {
099: if (!initialized)
100: init();
101: if (pureParams != null)
102: initParams(pureParams);
103: }
104:
105: /**
106: * Gibt die Keys der Klasse TKParam zurueck
107: *-----------------------------------------------------------------
108: * Alternative in der Applikation:
109: * Enumeration paramKeys = TKParams-Objekt.keys();
110: * while(paramKeys.hasMoreElements()) {
111: * Object classId = paramKeys.nextElement();
112: * Object val = TKParams-Objekt.get(key);
113: * }
114: *-----------------------------------------------------------------
115: *
116: * @return die Keys der Klasse
117: */
118: public Enumeration classes() {
119: return keys();
120: }
121:
122: /**
123: * Ein Hash der jeweiligen classId wird zurueckgegeben.
124: * Die classId ist ein Key der Klasse TKParam
125: *
126: * Beispiel: TKParam-Objekt.getClass("PAR")
127: * ---------------
128: * | ALTER | 33 |
129: * ==> |--------------|
130: * | .... | .. |
131: * |--------------|
132: *
133: *
134: * @param Object classID, ein Key der Klasse TKParam
135: * @return Hashtable der classID
136: */
137: public final TKHashtable getClass(Object classId) {
138: Object classHash = get(classId);
139: if (classHash == null || !(classHash instanceof TKHashtable))
140: return null;
141: return (TKHashtable) classHash;
142: }
143:
144: /**
145: * Mit dieser Methode kann getestet werden, ob eine ClassId
146: * existiert.
147: *
148: * @param Object classId, ein Key der Klasse TKParam
149: * @return boolean, existiert die classId?
150: */
151: public boolean hasClass(Object classId) {
152: return getClass(classId) != null;
153: }
154:
155: /**
156: * Der URLParameterWert eines Parameters in einem Hash wird als Objekt
157: * zurueckgegeben.
158: *
159: * Beispiel: TKParam-Objekt.getObject("PAR","ALTER")
160: * ---------------
161: * | ALTER | 33 |
162: * ==>|--------------| ==> 33
163: * | .... | .. |
164: * |--------------|
165: *
166: * @param Object classId, ein Key der Klasse TKParam
167: * @param Object key, key eines TKParameterNamens
168: * @return den Wert eines Parameters, der URLParameterWert
169: */
170: public Object getObject(Object classId, Object key) {
171: TKHashtable classHash = getClass(classId);
172: if (classHash == null)
173: return null;
174: return classHash.get(key);
175: }
176:
177: /**
178: * Der URLParameterWert eines Parameters wird als String zurueckgegeben.
179: *
180: * Beispiel: TKParam-Objekt.get("PAR","ALTER")
181: * ---------------
182: * | ALTER | 33 |
183: * ==>|--------------| ==> 33 ==> "33"
184: * | .... | .. |
185: * |--------------|
186: *
187: * @param Object classId, ein Key der Klasse TKParam
188: * @param Object key, key eines TKParameterNamens
189: * @return den Wert eines Parameters, der URLParameterWert
190: */
191: public String get(Object classId, Object key) {
192: Object result = getObject(classId, key);
193: if (result == null || result instanceof TKVector)
194: return null;
195: return result.toString();
196: }
197:
198: /**
199: * 1. Key der Klasse TKParam -- Value eine Hashtabel
200: * 2. Key der Hashtable -- Value ein TKVecto
201: * 3. Ergebnis: Element des Vectors des uebergebenen Indizes
202: *
203: * Beispiel: TKParam-Objekt.get("PAR","ALTERSGRUPPEN",2)
204: * -----------------------------------
205: * | ALTERGRUPPEN | Vector: 20|30|40 |
206: * ==> |--------------|------------------- ==> 30
207: * | .... | ... | ... |
208: * |--------------|-------------------
209: *
210: * @param Object classId, ein Key der Klasse TKParam
211: * @param Object key, key eines TKParameterNamens
212: * @param int idx, ein Index
213: * @return den Wert eines Parameters, der URLParameterWert
214: */
215: public String get(Object classId, Object key, int idx) {
216: Object result = getObject(classId, key);
217: if (result == null || !(result instanceof TKVector))
218: return null;
219: return ((TKVector) result).get(idx).toString();
220: }
221:
222: /**
223: * Der Wert eines Parameters aus einem Hash ist ein TKVector und wird
224: * dann zurueckgegeben.
225: * Beispiel: TKParam-Objekt.get("PAR","ALTERSGRUPPEN")
226: * -----------------------------------
227: * | ALTERGRUPPEN | Vector: 20|30|40 |
228: * ==> |--------------|------------------- ==> TKVector(20|30|40)
229: * | .... | ... | ... |
230: * |--------------|-------------------
231: *
232: * @param Object classId, ein Key der Klasse TKParam
233: * @param Object key, key eines TKParameterNamens
234: *
235: * @return den Wert eines Parameters
236: */
237: public TKVector getVector(Object classId, Object key) {
238: Object result = getObject(classId, key);
239: if (result == null || !(result instanceof TKVector))
240: return null;
241: return (TKVector) result;
242: }
243:
244: /**
245: * Existiert der URLParameterWert eines Parameters in einem Hash wird als Objekt
246: * zurueckgegeben.
247: *
248: * Beispiel: TKParams-Objekt.has("PAR", "ALTER")
249: * ---------------
250: * | ALTER | 33 |
251: * ==>|--------------| ==> 33 ==> true
252: * | .... | .. |
253: * |--------------|
254: *
255: * @param Object classId, ein Key der Klasse TKParam
256: * @param Object key, key eines TKParameterNamens
257: *
258: * @return true, wenn der Wert eines Parameters vorhanden ist
259: */
260: public boolean has(Object classId, Object key) {
261: Object val = getObject(classId, key);
262: if (val == null)
263: return false;
264: if (val instanceof TKVector)
265: return true;
266: return (!(val instanceof TKNull));
267: }
268:
269: /**
270: * Die Methode get() liefert den Wert eines Parameters zurueck.
271: * Ist dieser Wert eine Instanz der Klasse TKVector, wird true
272: * zurueckgegeben
273: *
274: *
275: * Beispiel: TKParam-Objekt.hasMultiple("PAR","ALTERSGRUPPEN")
276: * -----------------------------------
277: * | ALTERGRUPPEN | Vector: 20|30|40 |
278: * ==> |--------------|------------------- ==> TKVector(20|30|40) ==> true
279: * | .... | ... | ... |
280: * |--------------|-------------------
281: *
282: * @param Object classId, ein Key der Klasse TKParam
283: * @param Object key, key eines TKParameterNamens
284: *
285: * @return true, wenn der Wert eines Parameters Instanz der
286: * Klasse TKVector ist.
287: */
288: public boolean hasMultiple(Object classId, Object key) {
289: Object val = getObject(classId, key);
290: if (val == null)
291: return false;
292: return (val instanceof TKVector);
293: }
294:
295: /**
296: * Ist der Wert des Parameters nicht null, wird true zurueckgegeben.
297: * Ist der Wert null, so existiert weder der key noch der value.
298: * Dies bedeutet, dass der Parameter nicht uebergeben wurde (Checkboxen)
299: * (siehe auch has())
300: *
301: * Beispiel: TKParam-Objekt.defined("PAR","ALTER")
302: * ---------------
303: * | ALTER | 33 |
304: * ==>|--------------| ==> 33 ==> "33" ==> true
305: * | .... | .. |
306: * |--------------|
307: *
308: * @param Object classId, ein Key der Klasse TKParam
309: * @param Object key, key eines TKParameterNamens
310: *
311: * @return true, wenn der Wert eines Parameters vorhanden ist
312: */
313: public boolean defined(Object classId, Object key) {
314: Object val = get(classId, key);
315: return (val != null);
316: }
317:
318: /**
319: * Erweitert den Hash um ein (key,value)-Paarmit folgender Regel
320: * Kommt der key noch nicht im Hash vor, wird das neue
321: * (Key,Value)-Paar eingetragen
322: *
323: * Beispiel: TKParam-Objekt.extend("PAR","NAME","HANS")
324: * --------------- ---------------
325: * | ALTER | 33 | | ALTER | 33 |
326: * ==>|--------------| ==> |--------------|
327: * | .... | .. | | NAME | HANS |
328: * |--------------| |--------------|
329: *
330: * @param Object classId, ein Key der Klasse TKParam
331: * @param Object key, key eines TKParameterNamens
332: * @param Objekt val, der zu setzende neue Wert
333: */
334: public void extend(Object classId, Object key, Object val) {
335: TKHashtable classHash = getClass(classId);
336: if (classHash == null) {
337: classHash = new TKHashtable(1);
338: classHash.put(key, val);
339: put(classId, classHash);
340: } else {
341: classHash.extend(key, val);
342: }
343: }
344:
345: /**
346: * Erweitert den Hash um ein (key,value)-Paar erweitert.
347: *
348: * Beispiel: TKParam-Objekt.put("PAR","NAME","HANS")
349: * --------------- ---------------
350: * | ALTER | 33 | | ALTER | 33 |
351: * ==>|--------------| ==> |--------------|
352: * | .... | .. | | NAME | HANS |
353: * |--------------| |--------------|
354: *
355: * @param Object classId
356: * @param Object key
357: * @param Objekt val, der zu setzende neue Wert
358: */
359: public void put(Object classId, Object key, Object val) {
360: TKHashtable classHash = getClass(classId);
361: if (classHash == null) {
362: classHash = new TKHashtable(1);
363: classHash.put(key, val);
364: put(classId, classHash);
365: } else {
366: classHash.put(key, val);
367: }
368: }
369:
370: /**
371: * Die Methode initParams() wird in den Konstruktoren aufgerufen. Ihr wird ein Hash
372: * uebergeben, der als Keys die URLParameterNamen und als Value die zugehoerigen
373: * URLParameterWerte enthaelt. Die URLParameternamen muessen nun aus-
374: * einandergenommen und in den Hash eingefuegt werden.
375: *
376: * @param TkHashtable pureParams, welche als Key den URL_Parameternamen
377: * und als Value den URLParameterWert beinhaltet.
378: * TK_PARClassId[TKParameterName;TKParameterSubklassenName:TKParameterSubklassenWert]=
379: * URLParameterWert
380: * Bsp: TK_PAR[ALTER;TYPE:INT]=33
381: * Bsp: TK_EV[START]=
382: *
383: *
384: */
385: protected void initParams(TKHashtable pureParams) {
386: Enumeration keys = pureParams.keys();
387:
388: PatternMatcher matcher = TKReg.getMatcher();
389:
390: while (keys.hasMoreElements()) {
391: Object key = keys.nextElement();
392: Object val = pureParams.get(key);
393:
394: //Nur die x-Koordinate wird beruecksichtigt
395: if (matcher.matches(key.toString(), patParName)) {
396: // if( nameReg.search( key.toString() ) ) {
397: MatchResult match = matcher.getMatch();
398: if (match.groups() == 4) {
399: String third = match.group(3);
400: if (third != null && third.equalsIgnoreCase(".y")) {
401: continue;
402: }
403: }
404:
405: //--------------------------------------------------------------------------------------------------------------//
406: //Die Pattern:
407: //static private final String patTrailer ="TK_";
408: //static private final Regex nameReg = new Regex( "^(?i)"+patTrailer+"(\\w+)\\[(.*)\\](\\.[xy])?$" );
409: //static private final Regex subReg = new Regex( "^(\\w+)\\b:?(.*)$" );
410: //Das Beispiel: TK_PAR[ALTER;TYPE:INT]
411: //--------------------------------------------------------------------------------------------------------------//
412:
413: //1. Pattern zwischen TK_ und [ = PAR = classId
414: String classId = match.group(1).toUpperCase();
415:
416: //2. Innerhalb der Klammern [] wird nach ";" o. "!" gesplittet
417: // Token1=ALTER Token2=TYPE:INT
418: StringTokenizer parts = new StringTokenizer(match
419: .group(2), ";!");
420:
421: //3. Das erste Token ist damit ALTER
422: String name = parts.nextToken().toUpperCase();
423:
424: //---------------------------------------------------------------------------//
425: //Hash mit dem key clasId erhaelt als value einen weiteren Hash mit key=name
426: //und value=val
427: // -------------------------
428: // | PARAM | --------------- |
429: // | | | ALTER | 33 | |
430: // | | | .... | .. | |
431: // | | -------------- |
432: // ---------------------------
433: //---------------------------------------------------------------------------//
434:
435: extend(classId, name, val);
436:
437: //---------------------------------------------------------------------------//
438: //Existieren weitere Tokens, so handelt es sich um ein Subtoken, was wiederum
439: //gesplittet wird.
440: //Der TKParameterSubklassenName wird als Key in den Hash eingefuegt und
441: //erhaelt als value wiederum einen Hasch. Dieser enthaelt als Key den
442: //TKParameterName und als value den TKParameterSubklassenWert
443: //
444: //Im Bsp: TYPE:INT
445: // -------------------------
446: // | TYPE | --------------- |
447: // | | | ALTER | INT | |
448: // | | | .... | .. | |
449: // | | -------------- |
450: // ---------------------------
451: //---------------------------------------------------------------------------//
452: while (parts.hasMoreTokens()) {
453: if (matcher.matches(parts.nextToken(), patSubClass)) {
454: MatchResult classMatch = matcher.getMatch();
455: String classVal = classMatch.group(2);
456: extend(
457: classMatch.group(1).toUpperCase(),
458: name,
459: (classVal.length() == 0 ? (Object) TKNull.NULL
460: : (Object) classVal));
461: }
462: }
463: }
464: //Es gibt nur einen Parameter ohne die Namenskonvention
465: //(kann fuer Ausnahmen genutzt werden)
466: else {
467: put(key, val);
468: }
469: }
470: }
471:
472: /**
473: * Enthalten die beiden Hashes den gleichen Key wird ein neuer Hash erzeugt
474: * mit key/value Paar vom srcHash
475: *
476: * @param Object srcId, der SourceHash
477: * @param Object refId, der ReferenzHash
478: *
479: * @return den neu erzeugten Hash
480: */
481: public TKHashtable extractClass(Object srcId, Object refId) {
482: TKHashtable refHash = getClass(refId);
483: TKHashtable srcHash = getClass(srcId);
484:
485: if (srcHash == null || refHash == null || srcHash.size() == 0
486: || refHash.size() == 0) {
487: return new TKHashtable();
488: }
489:
490: TKHashtable res = new TKHashtable(refHash.size());
491: Enumeration keys = refHash.keys();
492:
493: while (keys.hasMoreElements()) {
494: Object key = keys.nextElement();
495: Object val = srcHash.get(key);
496: if (val != null)
497: res.put(key, val);
498: }
499: return res;
500: }
501:
502: //---------------------------------------------------------------------
503: /**
504: * Pattern werden fuer die spaetere Patternsuche/ersetzung definiert und
505: * global zur Verfuegung gestellt.
506: */
507: static void init() {
508: if (initialized)
509: return;
510:
511: PatternCompiler compiler = TKReg.getCompiler();
512:
513: try {
514: patParName = compiler.compile("^" + patTrailer
515: + "(\\w+)\\[(.*)\\](\\.[xy])?$",
516: Perl5Compiler.CASE_INSENSITIVE_MASK);
517: patSubClass = compiler.compile("^(\\w+)\\b:?(.*)$");
518: } catch (MalformedPatternException e) {
519: cat.error("Bad pattern.", e);
520: }
521:
522: initialized = true;
523: }
524:
525: //---------------------------------------------------------------------
526: static {
527: init();
528: }
529:
530: }
|