001: package com.teamkonzept.webman.mainint;
002:
003: import com.teamkonzept.db.*;
004: import com.teamkonzept.lib.*;
005: import com.teamkonzept.webman.*;
006: import com.teamkonzept.web.*;
007: import com.teamkonzept.webman.db.*;
008: import com.teamkonzept.webman.mainint.events.*;
009:
010: import java.util.Stack;
011: import java.sql.*;
012:
013: /**
014: provides several Util methods for trees
015: * @author $Author: alex $
016: * @version $Revision: 1.5 $
017: */
018: public class TreeUtils implements ParameterTypes {
019: /**
020: * mischen zweier teilbaeume (zwei TKDBResults)
021: *
022: * @param
023: */
024: public static TKDBResult mergeIntoTree(TKDBResult tree,
025: TKDBResult branch, String whichNodeId) throws Throwable {
026: int i = 0;
027: int j = 0;
028: TKDBResult resTree = (TKDBResult) tree.clone();
029: resTree.removeAllElements();
030: TKDBResultRow treeRow = (tree == null) ? null
031: : (TKDBResultRow) (tree.get(i++));
032: TKDBResultRow branchRow = (branch == null) ? null
033: : (TKDBResultRow) (branch.get(j++));
034: while (true) {
035: if (treeRow == null && branchRow == null) {
036: break;
037: }
038: int treeLeft = getDBResultRowColumnVal(treeRow, "LEFT_NR");
039: int branchLeft = getDBResultRowColumnVal(branchRow,
040: "LEFT_NR");
041: if (treeRow == null) {
042: resTree.addElement(branchRow);
043: branchRow = (TKDBResultRow) (branch.get(j++));
044: } else if (branchRow == null) {
045: resTree.addElement(treeRow);
046: treeRow = (TKDBResultRow) (tree.get(i++));
047: } else if (treeLeft == branchLeft) {
048: int branchNodeId = getDBResultRowColumnVal(branchRow,
049: "NODE_ID");
050: int branchConNodeId = getDBResultRowColumnVal(
051: branchRow, whichNodeId);
052: if (branchNodeId != branchConNodeId) {
053: resTree.addElement(branchRow);
054: } else {
055: resTree.addElement(treeRow);
056: }
057: treeRow = (TKDBResultRow) (tree.get(i++));
058: branchRow = (TKDBResultRow) (branch.get(j++));
059: } else if (treeLeft < branchLeft) {
060: resTree.addElement(treeRow);
061: treeRow = (TKDBResultRow) (tree.get(i++));
062: } else if (treeLeft > branchLeft) {
063: resTree.addElement(branchRow);
064: branchRow = (TKDBResultRow) (branch.get(j++));
065: }
066: }
067: return resTree;
068: }
069:
070: /**
071: * ermitteln der maximalen tiefe eines baumes
072: *
073: * @param
074: */
075: public static int getMaxDepth(TKDBResult tree, String treeName)
076: throws Throwable {
077: int depth = 0;
078: int maxDepth = 0;
079: int lastLeft = -1;
080: int lastRight = -1;
081: int this Parent;
082: Stack parents = new Stack();
083: for (int i = 0; i < tree.size(); i++) {
084: TKDBResultRow resultRow = (TKDBResultRow) (tree.get(i));
085: int this Left = Integer.parseInt((String) resultRow
086: .getColumn("LEFT_NR"));
087: int this Right = Integer.parseInt((String) resultRow
088: .getColumn("RIGHT_NR"));
089: String tmp = (String) resultRow.getColumn(treeName
090: + "_NODE_PARENT");
091: this Parent = (tmp == null || tmp.equals("")) ? Integer
092: .parseInt((String) resultRow.getColumn(treeName
093: + "_NODE_ID")) : Integer.parseInt(tmp);
094: if (this Left > lastLeft && this Right < lastRight) { // absteigen
095: depth++;
096: parents.push(new Integer(this Parent));
097: } else if (!parents.empty()) { // aufsteigen
098: if (!(parents.peek().equals(new Integer(this Parent)))) {
099: while (!parents.empty()) {
100: if (parents.pop().equals(
101: new Integer(this Parent))) {
102: parents.push(new Integer(this Parent));
103: break;
104: }
105: depth--;
106: }
107: }
108: }
109: maxDepth = (depth >= maxDepth) ? depth : maxDepth;
110: lastLeft = this Left;
111: lastRight = this Right;
112: }
113: return maxDepth;
114: }
115:
116: /**
117: *
118: * lesen einer spalte einer TKDBResultRow und als int zurueck
119: *
120: * @param
121: */
122: public static int getDBResultRowColumnVal(TKDBResultRow row,
123: String name) {
124: if (row != null) {
125: String sVal = (String) row.getColumn(name);
126: if (sVal.equals(""))
127: return -1;
128: int val = Integer.parseInt(sVal);
129: return val;
130: } else
131: return -1;
132: }
133:
134: /**
135: * keepOpenNodes
136: *
137: * schleift Liste der offenen nodes durch: Lesen des Vectors und einsetzen ins templ.
138: *
139: * @param Template
140: */
141: public static void keepOpenNodes(TKEvent evt, TKHTMLTemplate tmpl)
142: throws Throwable {
143: TKVector openNodes = new TKVector();
144: if (evt.getParams().hasMultiple(PARAMETER, "OPEN_NODES")) {
145: openNodes = evt.getParams().getVector(PARAMETER,
146: "OPEN_NODES");
147: } else {
148: //openNodes.put( 0, evt.getParameter( PARAMETER, "OPEN_NODES" )==null?"-1":evt.getParameter( PARAMETER, "OPEN_NODES" ) );
149: openNodes.put(0, evt.getParameter(PARAMETER, "OPEN_NODES"));
150: }
151: // die liste der offenen nodes kommt ins template
152: if (openNodes.get(0) != null) {
153: TKStandardIterator iterator1 = new TKStandardIterator(
154: openNodes, tmpl.getListIterator(), "OPEN_NODES",
155: "OPEN_NODES");
156: tmpl.setListIterator(iterator1);
157: }
158: }
159:
160: /**
161: *
162: * CHECK fuers Schliessen oeder LOESCHEN
163: * liste von offenen nodes holen und fuer jeden offenen node checken, ob er kind
164: * des closeNodeId ist: ist er kind, dann raus aus der liste der offenen nodes
165: * openNodeId kommt dann zu der liste dazu
166: *
167: * CHECK fuers Oeffnen
168: * fuer den zu oeffnenden node nachsehen, ob er Kind eines schon offenen node
169: * ist, wenn ja, dann den schon offenen raus und schliesslich den neuen rein in die Liste
170: *
171: * @param
172: */
173: public static TKVector updateOpenNodes(TKVector openNodes,
174: String openNodeId, String closeNodeId, String me,
175: Class isChildQuery) throws Throwable {
176: if (!closeNodeId.equals("-1")) { // beim schliessen/loeschen checken, ob offene nodes vom
177: int size = openNodes.size(); // schliessen/loeschen des me betroffen sind
178: TKQuery q;
179: int i = 0;
180: while (i < size) {
181: String id = (String) openNodes.get(i);
182: if (id != null) {
183: if (id.equals(me)) {
184: openNodes.removeElementAt(i);
185: size--;
186: } else {
187: q = TKDBManager.newQuery(isChildQuery);
188: q.setQueryParams("PARENT_ID", new Integer(me));
189: q.setQueryParams("CHILD_ID", new Integer(id));
190: q.execute();
191: ResultSet rs = q.fetchResultSet();
192: if (rs.next()) {
193: int isChild = rs.getInt("ISCHILD");
194: if (isChild == 1) {
195: openNodes.removeElementAt(i); // dieser knoten ist nach dem
196: size--; // schliessen nich mehr offen -> raus aus der liste
197: } else {
198: i++;
199: }
200: }
201: }
202: }
203: }
204: } else { // check beim Oeffnen: ist einer der offenen nodes Parent des openNodeId?
205: int size = openNodes.size();
206: TKQuery q;
207: int i = 0;
208: while (i < size) {
209: String id = (String) openNodes.get(i);
210: if (id != null) {
211: q = TKDBManager.newQuery(isChildQuery);
212: q.setQueryParams("PARENT_ID", new Integer(id));
213: q.setQueryParams("CHILD_ID",
214: new Integer(openNodeId));
215: q.execute();
216: ResultSet rs = q.fetchResultSet();
217: if (rs.next()) {
218: int isChild = rs.getInt("ISCHILD");
219: if (isChild == 1) {
220: openNodes.removeElementAt(i); // dieser knoten ist im gleichen Ast wie der zu oeffnende
221: size--;
222: } else {
223: i++;
224: }
225: }
226: }
227: }
228: }
229: if (!openNodes.contains(openNodeId) && openNodeId != null)
230: openNodes.addElement(openNodeId);
231: if (openNodes.size() >= 2 && openNodes.contains("-1")) {
232: openNodes.removeElement("-1");
233: //log.println("------ entferne -1 -----");
234: }
235: return openNodes;
236: }
237:
238: }
|