001: package com.teamkonzept.web;
002:
003: import com.teamkonzept.lib.*;
004: import com.teamkonzept.lib.templates.TemplateTypes;
005: import de.webman.template.jsp.*;
006: import de.webman.template.xslt.*;
007: import com.teamkonzept.web.servlet.ServletInterface;
008: import java.io.*;
009: import java.util.*;
010: import java.net.*;
011: import com.teamkonzept.international.LanguageManager;
012: import org.apache.log4j.Category;
013: import org.apache.log4j.NDC;
014: import javax.servlet.*;
015: import javax.servlet.http.*;
016:
017: /**
018: * Title: <p>
019: * Description: <p>
020: * Copyright: Copyright (c) <p>
021: * Company: <p>
022: * @author $Author: uli $
023: * @version $Revision: 1.46 $
024: */
025: public class TKEvent implements ErrorCodes, TemplateTypes {
026: private static Category cat = Category.getInstance(TKEvent.class);
027:
028: /** der anonyme User */
029: String DEFAULT_USER = "NO_USER";
030:
031: /** noch in Properties auslagern !! */
032: public static final String IMAGE_DIR = TemplateUtils
033: .getWebmanTemplateDirectory()
034: + "/images/";
035:
036: public static String STARTEVENT = "START";
037:
038: /** Die entsprechend den Namenskonventionen analysierten Request-Parameter */
039: protected TKParams params;
040:
041: /** Event ist im default nicht consumed */
042: private boolean isConsumed = false;
043:
044: ByteArrayOutputStream outbuf;
045:
046: /** AusgabeStream */
047: PrintStream out;
048:
049: /** Die Response-Header */
050: protected TKHashtable headers;
051:
052: private String identifier;
053:
054: TKHttpInterface httpInterface;
055:
056: /** zur Weitergabe von Objekten zwischen Eventhandlern, die keine Strings sind */
057: private TKHashtable attributes = new TKHashtable();
058:
059: public PrintStream log;
060:
061: /** speichert Events zu Threads */
062: private static Hashtable events = new Hashtable();
063:
064: public TKEvent(TKHttpInterface _interface) {
065: httpInterface = _interface;
066: outbuf = new ByteArrayOutputStream();
067: out = new PrintStream(outbuf);
068: log = new TKByteArrayPrintStream(httpInterface.getLogStream());
069: init();
070: putEventForThread(this );
071: }
072:
073: public static TKEvent getEventForThread() {
074: Thread me = Thread.currentThread();
075: TKEvent evt = (TKEvent) events.get(me);
076: return evt;
077: }
078:
079: /**
080: ist in TKUserEvent implementiert
081: */
082: public String getSelectedLanguage() {
083: return null;
084: }
085:
086: private static void putEventForThread(TKEvent evt) {
087: // fuer die Spracheinstellung
088: events.put(Thread.currentThread(), evt);
089: // fuers Logging
090: NDC.push(evt.getRemoteUser());
091: }
092:
093: static void removeEventForThread() {
094: events.remove(Thread.currentThread());
095: NDC.pop();
096: }
097:
098: /**
099: danach wird der Event nicht mehr weiter verarbeitet
100: Template wird ausgegeben
101: */
102: public void consume() throws IOException {
103: try {
104: if (isConsumed)
105: return;
106: log.flush();
107: isConsumed = true;
108: printHeaders();
109: if (outbuf.size() > 0) {
110: outbuf.writeTo(httpInterface.getOutputStream());
111: }
112: } finally {
113: removeEventForThread();
114: }
115: }
116:
117: /*
118: * Der Content-type fuer die Methode TKHttp.println wird gesetzt, wenn
119: * diese Methode aufgerufen wird
120: * Aufruf in der applikation: printHeaders()
121: */
122: public void printHeaders() {
123: httpInterface.addHeader("Content-Length", Integer
124: .toString(outbuf.size()));
125: Enumeration e = headers.keys();
126: while (e.hasMoreElements()) {
127: Object k = e.nextElement();
128: httpInterface.addHeader(k.toString(), headers.get(k)
129: .toString());
130: }
131: }
132:
133: public void finishTemplate(TemplateBasic template)
134: throws TKTemplateSyntaxException {
135: template.doTagSubstitution();
136: template.printTemplate(out);
137: // hier noch Sessiondaten umkopieren
138: if (template instanceof JSPTemplate)
139: copySessionValues((JSPTemplate) template);
140: }
141:
142: /**
143: kopiert Session Values aus den eigenen (.wsp) Templates
144: in den Servlet Context um
145: */
146: private void copySessionValues(JSPTemplate t)
147: {
148: HttpSession session = httpInterface.getSession(true);
149: HttpServletRequest req = t.getRequest();
150: if (req == null)
151: return;
152: HttpSession old = req.getSession();
153: Enumeration enum = old.getAttributeNames();
154: while (enum.hasMoreElements())
155: {
156: String key = (String)enum.nextElement();
157: Object value = old.getAttribute(key);
158: session.setAttribute(key, value);
159: }
160: }
161:
162: /**
163: kopiert Session Values aus dem Request in die eigenen (.wsp) Templates
164: um
165: */
166: private void copyOriginalSessionValues(JSPTemplate t)
167: {
168: HttpSession oldSession = httpInterface.getSession(true);
169: HttpServletRequest req = t.getRequest();
170: if (req == null)
171: return;
172: HttpSession neuSession = req.getSession();
173: Enumeration enum = oldSession.getAttributeNames();
174: while (enum.hasMoreElements())
175: {
176: String key = (String)enum.nextElement();
177: Object value = oldSession.getAttribute(key);
178: neuSession.setAttribute(key, value);
179: }
180: }
181:
182: public boolean isConsumed() {
183: return isConsumed;
184: }
185:
186: public TKHttpInterface getHttpInterface() {
187: return httpInterface;
188: }
189:
190: public String getRemoteUser() {
191: String user = httpInterface.getRemoteUser();
192: if (user == null)
193: return DEFAULT_USER;
194: return user;
195: }
196:
197: // erst bei Aufruf Kontext Informationen generieren ?
198: public String getKontext() {
199: if (identifier.equals(STARTEVENT)) {
200: return "";
201: }
202: return identifier.substring(0, 2);
203: }
204:
205: /**
206: * Initializes the event.
207: */
208: public void init() {
209: // pureParams = httpInterface.getParams();
210: params = new TKParams(httpInterface.getParams());
211: headers = new TKHashtable();
212: TKHashtable evClass = params.getClass("EV");
213: Enumeration evEnum = (evClass != null ? evClass.keys() : null);
214: String event = (evEnum != null && evEnum.hasMoreElements() ? (String) evEnum
215: .nextElement()
216: : null);
217:
218: if (event == null)
219: event = STARTEVENT;
220: // Kontext erarbeiten
221: identifier = analyzeEvent(event);
222: // headers.put( "Content-type", "text/html;charset=ISO-8859-1" ); wohin das ???
223: }
224:
225: /**
226: analyzes Event, a unique string is the result
227: */
228: String analyzeEvent(String event) {
229: if (event.equalsIgnoreCase("MODIFY")
230: || event.startsWith("EXT_MODIFY")) {
231: String context = params.get("PAR", "MODIFY_CONTEXT");
232: return context + "_" + event; // das ist der eindeutige String
233: }
234: return event;
235: }
236:
237: public String getParameter(Object classId, Object key) {
238: return params.get(classId, key);
239: }
240:
241: public String getNotNullParameter(Object classId, Object key) {
242: String value = params.get(classId, key);
243: return value == null ? "" : value;
244: }
245:
246: public void setAttribute(Object key, Object value) {
247: attributes.put(key, value);
248: }
249:
250: public Object getAttribute(Object key) {
251: return attributes.get(key);
252: }
253:
254: public TKParams getParams() {
255: return params;
256: }
257:
258: /**
259: * liefert das vorbereitete (schon mit SELF) HTML-Template zurueck
260: *
261: *
262: * @param name Name des gewuenschten Template
263: */
264: public TKHTMLTemplate getPrepHTMLTemplate(String name)
265: throws TKTemplateSyntaxException, FileNotFoundException {
266: cat.debug("Template : " + name);
267: TKHTMLTemplate template = new TKHTMLTemplate("file://"
268: + httpInterface.getDocumentRoot() + File.separator
269: + TemplateUtils.getWebmanTemplateDirectory()
270: + File.separator + name);
271: prepTemplate(template);
272: return template;
273: }
274:
275: public TemplateBasic getPrepTemplate(String name)
276: throws TKTemplateSyntaxException, FileNotFoundException {
277: cat.debug("Template : " + name);
278: TemplateBasic t = TemplateUtils.getTemplate(name, httpInterface
279: .getDocumentRoot(), true);
280: prepTemplate(t);
281: return t;
282: }
283:
284: public void prepTemplate(TemplateBasic t) {
285: if (t instanceof JSPTemplate) {
286: // Session Daten wieder kopieren !
287: ((JSPTemplate) t).initRequest();
288: copyOriginalSessionValues((JSPTemplate) t);
289: }
290: if (httpInterface instanceof ServletInterface) {
291: ServletInterface sInterface = (ServletInterface) httpInterface;
292: t.setOriginalRequest(sInterface.getRequest());
293: }
294: t.set("SELF", httpInterface.getOwnURL());
295: t.set("ABSOLUTE_SELF", httpInterface.getAbsoluteURL());
296: t.set("APP_CONTEXT", httpInterface.getContextPath());
297: t.set("LOGIN", getRemoteUser());
298: t.set("IMAGE_DIR", IMAGE_DIR);
299: String language = getSelectedLanguage();
300: if (language == null)
301: language = LanguageManager.getStandardLocale()
302: .getLanguage();
303: t.set("IMAGE_DIR_INT", IMAGE_DIR + language + "/");
304: // t.setAppName( httpInterface.getOwnName() );
305: }
306:
307: /**
308: * Liefert eine leere Seite zurueck
309: *
310: *
311: * @param
312: */
313: public void doEmptyPage() {
314: try {
315: TKHTMLTemplate t = getPrepHTMLTemplate("empty.tmpl");
316: finishTemplate(t);
317: } catch (TKTemplateSyntaxException e) {
318: // kann eigentlich nicht passieren
319: // Exception schmeissen
320: } catch (FileNotFoundException e) {
321: ; //TODO das kann schon passieren!
322: }
323: }
324:
325: public PrintStream getOutputStream() {
326: return out;
327: }
328:
329: public PrintStream getLogStream() {
330: return log;
331: }
332:
333: /**
334: * Returns a string representation of this event.
335: *
336: * @return a string representation of this event.
337: */
338: public String toString() {
339: return identifier;
340: }
341:
342: public String getName() {
343: return identifier;
344: }
345:
346: /**
347: Checks, if the whole request has arrived here,
348: throws an exception otherwise
349: */
350: public void checkChecker() throws TKException {
351: if (identifier.equals(STARTEVENT))
352: return;
353: String checker = getNotNullParameter("PAR", "CHECKER");
354: if (!checker.equals("1")) {
355: // Aendern !!!!!
356: throw new TKException("Zu schnelle Bedienung", USER + 1,
357: USER_SEVERITY, true, null);
358: }
359: }
360:
361: }
|