001: package de.webman.content.workflow;
002:
003: import com.teamkonzept.lib.*;
004: import com.teamkonzept.db.*;
005: import de.webman.content.workflow.db.queries.*;
006: import com.teamkonzept.web.*;
007:
008: import java.io.*;
009: import java.util.*;
010: import java.sql.*;
011:
012: import org.apache.log4j.Category;
013:
014: /**
015: Repraesentiert einen Statusfilter:
016: Neu: Nur noch EXCLUDE oder Force sollte in die Datenbank
017: INCLUDE ist default
018: * @author $Author: alex $
019: * @version $Revision: 1.2 $
020:
021: */
022: public class VersionStatusFilter implements TKHashable {
023: /** Logging Category */
024: private static Category cat = Category
025: .getInstance(VersionStatusFilter.class);
026:
027: /** Name des Filters */
028: private String filter_name = null;
029:
030: public int filter_mode = -1;
031:
032: public int filter_id = -1;
033:
034: public TKHashtable rules = new TKHashtable();
035: public TKHashtable hashed;
036:
037: public final static int SOURCE_MODE_ID = 1;
038: public final static int DEST_MODE_ID = 2;
039:
040: /** Status egal*/
041: public final static int INCLUDE_RULE_ID = 1;
042:
043: /** Status darf nicht vorkommen */
044: public final static int EXCLUDE_RULE_ID = 2;
045:
046: /** Status muß vorkommen */
047: public final static int FORCE_RULE_ID = 3;
048:
049: public VersionStatusFilter(int filter_id, String filter_name,
050: int filter_mode) {
051:
052: this .filter_name = filter_name;
053: this .filter_mode = filter_mode;
054: this .filter_id = filter_id;
055: }
056:
057: public String getName() {
058: return com.teamkonzept.international.LanguageManager.getText(
059: "workflow", filter_name, null);
060: }
061:
062: /**
063: ergaenzt die Definitionen der Regel um die Standardregel INCLUDE
064: d.h. Regeln fuer Stati, die nicht in der Datenbank definiert sind, werden automatisch ergaenzt
065: */
066: public void complete()
067: {
068: // durch alle Stati iterieren
069: Hashtable stati = VersionStatics.getStatics().getStatusPool();
070: Enumeration enum = stati.keys();
071: while (enum.hasMoreElements())
072: {
073: Integer status = (Integer) enum.nextElement();
074: // falls nicht in filters definiert, Standard dazu
075: String rule = (String)rules.get(status);
076: if (rule == null)
077: rules.put(status, "INCLUDE");
078: }
079: }
080:
081: /**
082: speichert die einzelnen Rules in die DB
083: */
084: public void saveRulesToDB(TKHashtable newRules) throws SQLException
085: {
086: Enumeration enum = newRules.keys();
087: while (enum.hasMoreElements())
088: {
089: Integer status = (Integer)enum.nextElement();
090: String rule = (String)newRules.get(status);
091: // gibt es die Definition schon in der DB ?
092: TKQuery query = TKDBManager.newQuery(SelectFilterRule.class);
093: query.setQueryParams("FILTER_ID", new Integer(filter_id));
094: query.setQueryParams("STATUS_ID", status);
095: query.execute();
096: ResultSet rs = query.fetchResultSet();
097: if (rs.next())
098: {
099: query = TKDBManager.newQuery(UpdateFilterRule.class);
100: }
101: else
102: {
103: query = TKDBManager.newQuery(InsertFilterRule.class);
104: }
105: query.setQueryParams("FILTER_ID", new Integer(filter_id));
106: query.setQueryParams("STATUS_ID", status);
107: query.setQueryParams("RULE_TYPE", new Integer(rule2Id(rule)));
108: query.execute();
109: }
110: }
111:
112: public void saveToDB() {
113: try {
114: TKQuery query = null;
115: // Id da ?
116: if (filter_id != -1) {
117: query = TKDBManager.newQuery(UpdateFilter.class);
118: query.setQueryParams("FILTER_ID",
119: new Integer(filter_id));
120: } else {
121: query = TKDBManager.newQuery(InsertFilter.class);
122: }
123: query.setQueryParams("FILTER_NAME", filter_name);
124: query.setQueryParams("FILTER_MODE",
125: new Integer(filter_mode));
126: query.execute();
127: if (filter_id == -1) {
128: ResultSet rs = query.fetchResultSet();
129: if (rs.next()) {
130: filter_id = rs.getInt("FILTER_ID");
131: }
132: }
133: } catch (SQLException e) {
134: cat.error("Error during saveToDB ", e);
135: }
136:
137: }
138:
139: /**
140: erzeugt eine Hashtable aus den internen Daten
141: */
142: public void makeHashed() {
143:
144: hashed = new TKHashtable();
145:
146: hashed.put("FILTER_ID", new Integer(this .filter_id));
147: hashed.put("FILTER_MODE_ID", new Integer(this .filter_mode));
148:
149: if (this .filter_name != null)
150: hashed.put("FILTER_NAME", getName());
151: if (this .rules != null)
152: hashed.put("FILTER_RULES", this .rules);
153:
154: hashed.put("FILTER_MODE", filter_mode == SOURCE_MODE_ID ? "Von"
155: : "Nach");
156: }
157:
158: /**
159: Implementierung des Interface TKHashable
160: */
161: public TKHashtable toHashtable() {
162: if (hashed == null)
163: makeHashed();
164: return hashed;
165: }
166:
167: /**
168: Setter fuer den Filter Mode
169: */
170: public void setMode(String mode) {
171: if (mode.equals("Von"))
172: filter_mode = SOURCE_MODE_ID;
173: else
174: filter_mode = DEST_MODE_ID;
175: }
176:
177: /**
178: Setter fuer Namen (nicht internationalisiert
179: */
180: public void setName(String name) {
181: filter_name = name;
182: }
183:
184: /**
185: Für Internationalisierung !
186: */
187: public TKHashtable getHash() {
188: TKHashtable back = new TKHashtable();
189:
190: back.put("FILTER_ID", new Integer(this .filter_id));
191: back.put("FILTER_MODE_ID", new Integer(this .filter_mode));
192: back.put("FILTER_NAME_DB", filter_name);
193: if (this .filter_name != null)
194: back.put("FILTER_NAME", getName());
195: if (this .rules != null)
196: back.put("FILTER_RULES", this .rules);
197:
198: back.put("FILTER_MODE", filter_mode == SOURCE_MODE_ID ? "Von"
199: : "Nach");
200:
201: return back;
202: }
203:
204: /**
205: gibt den entsprechenden String zur Rule ID zurueck
206: unschoen mal aendern
207: */
208: public static String ruleId2String(int id) {
209:
210: if (id == INCLUDE_RULE_ID)
211: return "INCLUDE";
212: if (id == EXCLUDE_RULE_ID)
213: return "EXCLUDE";
214: if (id == FORCE_RULE_ID)
215: return "FORCE";
216: return "UNKNOWN";
217: }
218:
219: /**
220: gibt die entsprechende RuleID zum String zurueck
221: unschoen mal aendern
222: */
223: public static int rule2Id(String rule) {
224:
225: if (rule.equalsIgnoreCase("INCLUDE"))
226: return INCLUDE_RULE_ID;
227: if (rule.equalsIgnoreCase("EXCLUDE"))
228: return EXCLUDE_RULE_ID;
229: if (rule.equalsIgnoreCase("FORCE"))
230: return FORCE_RULE_ID;
231: return -1;
232: }
233:
234: /**
235: wendet den Filter auf das uebergebene Template an
236: */
237: public TKHashtable makeFilter(TKHTMLTemplate t,
238: TKHashtable statusPool) throws Throwable {
239:
240: // Filter durchschleifen
241: t.set("FILTER_MODE", filter_mode == SOURCE_MODE_ID ? "SRC"
242: : "DEST");
243:
244: Enumeration e = statusPool.elements();
245: while (e.hasMoreElements()) {
246:
247: VersionStatus status = (VersionStatus) e.nextElement();
248: if (status.comment)
249: continue;
250:
251: String cmd = (String) rules.get(new Integer(
252: status.status_id));
253: if (cmd != null)
254: t.set("FILTER." + status.status_id, cmd);
255: }
256:
257: return rules;
258: }
259:
260: /**
261: laedt die Filter aus der Datenbank
262: */
263: public static TKHashtable load() throws SQLException {
264: TKHashtable filters = new TKHashtable();
265: VersionStatusFilter current = null;
266:
267: TKQuery query = TKDBManager
268: .newQuery(VersionStatusFiltersGetAll.class);
269: query.execute();
270: ResultSet rs = query.fetchResultSet();
271:
272: while (rs.next()) {
273: int filter_id = rs.getInt("FILTER_ID");
274: int filter_mode = rs.getInt("FILTER_MODE");
275: int status_id = rs.getInt("STATUS_ID");
276: int rule_type = rs.getInt("RULE_TYPE");
277:
278: // erstmal nur der Platzhalter
279: String filter_name = rs.getString("FILTER_NAME");
280:
281: if (current == null || current.filter_id != filter_id) {
282: if (current != null)
283: current.complete();
284: current = new VersionStatusFilter(filter_id,
285: filter_name, filter_mode);
286: filters.put(new Integer(filter_id), current);
287: }
288: if (!ruleId2String(rule_type).equals("UNKNOWN")) {
289: current.rules.put(new Integer(status_id),
290: ruleId2String(rule_type));
291: }
292: }
293: current.complete(); // fehlende Definitionen ergaenzen
294: return filters;
295: }
296:
297: /**
298: Filter als SQL Statement in den PrintStream schreiben
299: */
300: public synchronized void script(PrintStream outf) {
301: outf
302: .println("INSERT INTO VERSION_STATUS_FILTER (FILTER_ID, FILTER_NAME, FILTER_MODE) "
303: + "VALUES ("
304: + filter_id
305: + ",\""
306: + filter_name
307: + "\"," + filter_mode + ") ");
308: Enumeration e = rules.keys();
309: while (e.hasMoreElements()) {
310: Integer status_id = (Integer) e.nextElement();
311: String rule_type = (String) rules.get(status_id);
312: outf
313: .println("INSERT INTO VERSION_STATUS_FILTER_RULE (FILTER_ID, STATUS_ID, RULE_TYPE) "
314: + "VALUES ("
315: + filter_id
316: + ","
317: + status_id
318: + "," + rule2Id(rule_type) + ") ");
319: }
320: }
321: }
|