001: package de.webman.sitetree.eventhandler;
002:
003: import java.util.*;
004: import java.sql.*;
005: import java.io.*;
006:
007: import com.teamkonzept.web.*;
008: import com.teamkonzept.lib.*;
009: import com.teamkonzept.field.*;
010: import com.teamkonzept.field.db.*;
011: import com.teamkonzept.db.*;
012:
013: import com.teamkonzept.webman.mainint.*;
014: import de.webman.generator.*;
015: import de.webman.content.eventhandler.CEUtils;
016: import com.teamkonzept.international.LanguageManager;
017:
018: import com.teamkonzept.webman.*;
019: import com.teamkonzept.webman.db.*;
020: import com.teamkonzept.webman.mainint.db.*;
021: import com.teamkonzept.webman.mainint.db.queries.*;
022: import com.teamkonzept.webman.mainint.db.queries.sitetree.CheckDocumentDependency;
023: import com.teamkonzept.webman.mainint.db.queries.DocDependency;
024: import com.teamkonzept.webman.mainint.events.*;
025:
026: import com.oroinc.text.regex.*;
027:
028: /**
029: * Utility Methoden für
030: * SITE TREE (ST) Allgemeines
031: * @author $Author: uli $
032: * @version $Revision: 1.10 $
033: */
034: public class SiteTreeUtils implements ParameterTypes, DatabaseDefaults,
035: UserCodes {
036:
037: /**
038: checkt beim Loeschen eines Dokuments/Verzeichnis, ob noch absolute Referenzen
039: auf das Dokument zeigen
040: @param shortName des Dokuments, falls null wird das Verzeichnis gecheckt
041: */
042: public static boolean checkReferences(Integer siteNodeId,
043: String shortName, TKVector back) throws SQLException {
044: TKQuery q;
045: if (shortName != null) {
046: q = TKDBManager.newQuery(CheckDocumentDependency.class);
047: q.setQueryParams("DOCUMENT_SHORTNAME", shortName);
048: } else {
049: q = TKDBManager.newQuery(DocDependency.class);
050: }
051: q.setQueryParams("SITE_NODE_ID", siteNodeId);
052: q.execute();
053: ResultSet rs = q.fetchResultSet();
054: while (rs.next()) {
055: TKHashtable tmp = new TKHashtable();
056: Integer sID = new Integer(rs.getInt("SITE_NODE_ID"));
057: String path = getCurrentPath(sID);
058: String sName = rs.getString("DOCUMENT_SHORTNAME");
059: tmp.put("REF2", path + sName);
060: back.addElement(tmp);
061: }
062: if (back.size() == 0) {
063: TKHashtable tmp = new TKHashtable();
064: tmp.put("REF2", LanguageManager.getText("sitestructure",
065: "NOT_REFERENCED"));
066: back.addElement(tmp);
067: return false;
068: }
069: return true;
070: }
071:
072: /** keepSTContext
073: *
074: * schleift Context durch; nicht durch t.set( params.getClass( PARAMETER ) ),
075: * da bei diesen field-Geschichten noch eine Menge anderer Parameter am
076: * Start sind...
077: *
078: * @param Template t
079: */
080: public static void keepSTContext(TKEvent evt, TemplateBasic t)
081: throws Throwable {
082: t.set("THE_SELECTION_TYPE", evt.getNotNullParameter(PARAMETER,
083: "THE_SELECTION_TYPE"));
084: t.set("THE_CONTENT_NODE_ID", evt.getNotNullParameter(PARAMETER,
085: "THE_CONTENT_NODE_ID"));
086: t.set("SITE_NODE_ID", evt.getParameter(PARAMETER,
087: "SITE_NODE_ID"));
088: t.set("SITE_NODE_TYPE", evt.getParameter(PARAMETER,
089: "SITE_NODE_TYPE"));
090: t.set("FORM_ID", evt.getParameter(PARAMETER, "FORM_ID"));
091: t.set("CONTENT_ID", evt.getNotNullParameter(PARAMETER,
092: "CONTENT_ID"));
093: t.set("SITE_NODE_NAME", evt.getNotNullParameter(PARAMETER,
094: "SITE_NODE_NAME"));
095: t.set("SITE_NODE_SHORTNAME", evt.getNotNullParameter(PARAMETER,
096: "SITE_NODE_SHORTNAME"));
097: }
098:
099: /**
100: * Speichern einer content componenten zuordnung
101: *
102: *
103: *
104: * @param selData, nodeName
105: *
106: * selData: die SELECTION_DATA
107: * nodeName: der Name des Parameters, in dem die CONTENT_NODE_ID steht
108: * z.B. SINGLE_CONTENT_NODE_ID, oder NODE_ID, da Aufruf
109: * von verschiedenen Stellen (Templates) aus
110: */
111: public static void saveContentComponent(TKEvent evt,
112: String selData, String nodeName) throws Throwable {
113: String sNodeId = evt.getParameter(PARAMETER, "SITE_NODE_ID");
114: String sDocIdx = evt.getParameter(PARAMETER,
115: "SITE_NODE_DOC_IDX");
116: String sPresIdx = evt.getParameter(PARAMETER,
117: "PRESENTATION_COMPONENT_IDX");
118: String sNodeType = evt
119: .getParameter(PARAMETER, "SITE_NODE_TYPE");
120: String sIntType = evt.getParameter(PARAMETER,
121: "INTEGRATION_TYPE");
122:
123: TKQuery q = TKDBManager.newQuery(TKDBDocContentPut.class);
124: q.setQueryParams("SITE_NODE_ID", new Integer(sNodeId));
125: q.setQueryParams("SITE_NODE_DOC_IDX", new Integer(sDocIdx));
126: q.setQueryParams("PRESENTATION_COMPONENT_IDX", new Integer(
127: sPresIdx));
128:
129: String sContNodeId;
130: String sSelType;
131: if (sNodeType.equals(SINGLE) && sIntType.equals(SINGLE)) { // single node (SiteTree) und Single Integration
132: if (evt.getParameter(PARAMETER, "ATTACH_SEL").equals("SC")) { // Single Content Node ausgewaehlt
133: sContNodeId = evt.getParameter(PARAMETER, nodeName);
134: sSelType = null;
135: } else { // single sel aus contents zu einem group node (content tree)
136: sContNodeId = selData == null ? evt.getParameter(
137: PARAMETER, "THE_CONTENT_NODE_ID") : evt
138: .getParameter(PARAMETER, "NODE_ID");
139: sSelType = selData == null ? null : evt.getParameter(
140: PARAMETER, "SEL_TYPE");
141: }
142: q.setQueryParams("CONTENT_NODE_ID",
143: new Integer(sContNodeId));
144: q.setQueryParams("SELECTION_TYPE", sSelType);
145: } else if (sNodeType.equals(GROUP) && sIntType.equals(SINGLE)) { // group node (SiteTree) und Single Integration
146: if (evt.getParameter(PARAMETER, "ATTACH_SEL").equals("PGC")) { // Primary Group Content ausgewaehlt
147: q.setQueryParams("CONTENT_NODE_ID", null);
148: q.setQueryParams("SELECTION_TYPE", null);
149: } else {
150: sContNodeId = evt.getParameter(PARAMETER, nodeName);
151: q.setQueryParams("CONTENT_NODE_ID", new Integer(
152: sContNodeId));
153: q.setQueryParams("SELECTION_TYPE", null);
154: }
155: } else { // group integration
156: sContNodeId = selData == null ? evt.getParameter(PARAMETER,
157: "THE_CONTENT_NODE_ID") : evt.getParameter(
158: PARAMETER, "NODE_ID");
159: sSelType = selData == null ? null : evt.getParameter(
160: PARAMETER, "SEL_TYPE");
161: q.setQueryParams("CONTENT_NODE_ID",
162: new Integer(sContNodeId));
163: q.setQueryParams("SELECTION_TYPE", sSelType);
164: }
165: q.setQueryParams("SELECTION_DATA", selData);
166: q.execute();
167: q.fetchResultSet();
168: }
169:
170: /**
171: * Update einer content componenten zuordnung
172: *
173: *
174: *
175: * @param selData, nodeName
176: *
177: * selData: die SELECTION_DATA
178: * nodeName: der Name des Parameters, in dem die CONTENT_NODE_ID steht
179: * z.B. SINGLE_CONTENT_NODE_ID, oder NODE_ID, da Aufruf
180: * von verschiedenen Stellen (Templates) aus
181: */
182: public static void updateContentComponent(TKEvent evt,
183: String selData, String nodeName) throws Throwable {
184: String sNodeId = evt.getParameter(PARAMETER, "SITE_NODE_ID");
185: String sDocIdx = evt.getParameter(PARAMETER,
186: "SITE_NODE_DOC_IDX");
187: String sPresIdx = evt.getParameter(PARAMETER,
188: "PRESENTATION_COMPONENT_IDX");
189: String sNodeType = evt
190: .getParameter(PARAMETER, "SITE_NODE_TYPE");
191: String sIntType = evt.getParameter(PARAMETER,
192: "INTEGRATION_TYPE");
193:
194: TKQuery q = TKDBManager.newQuery(TKDBDocContentUpdate.class);
195: q.setQueryParams("SITE_NODE_ID", new Integer(sNodeId));
196: q.setQueryParams("SITE_NODE_DOC_IDX", new Integer(sDocIdx));
197: q.setQueryParams("PRESENTATION_COMPONENT_IDX", new Integer(
198: sPresIdx));
199:
200: String sContNodeId;
201: String sSelType;
202: if (sNodeType.equals(SINGLE) && sIntType.equals(SINGLE)) { // single node (SiteTree) und Single Integration
203: if (evt.getParameter(PARAMETER, "ATTACH_SEL").equals("SC")) { // Single Content Node ausgewaehlt
204: sContNodeId = evt.getParameter(PARAMETER, nodeName);
205: sSelType = null;
206: } else { // single sel aus contents zu einem group node (content tree)
207: sContNodeId = selData == null ? evt.getParameter(
208: PARAMETER, "THE_CONTENT_NODE_ID") : evt
209: .getParameter(PARAMETER, "NODE_ID");
210: sSelType = selData == null ? null : evt.getParameter(
211: PARAMETER, "SEL_TYPE");
212: }
213: q.setQueryParams("CONTENT_NODE_ID",
214: new Integer(sContNodeId));
215: q.setQueryParams("SELECTION_TYPE", sSelType);
216: } else if (sNodeType.equals(GROUP) && sIntType.equals(SINGLE)) { // group node (SiteTree) und Single Integration
217: if (evt.getParameter(PARAMETER, "ATTACH_SEL").equals("PGC")) { // Primary Group Content ausgewaehlt
218: q.setQueryParams("CONTENT_NODE_ID", null);
219: q.setQueryParams("SELECTION_TYPE", null);
220: } else if (evt.getParameter(PARAMETER, "ATTACH_SEL")
221: .equals("GC")) { // Group Content ausgewaehlt
222: sContNodeId = evt.getParameter(PARAMETER, nodeName);
223: sSelType = selData == null ? null : evt.getParameter(
224: PARAMETER, "SEL_TYPE");
225: q.setQueryParams("CONTENT_NODE_ID", new Integer(
226: sContNodeId));
227: q.setQueryParams("SELECTION_TYPE", sSelType);
228: } else { // Single Content
229: sContNodeId = evt.getParameter(PARAMETER, nodeName);
230: q.setQueryParams("CONTENT_NODE_ID", new Integer(
231: sContNodeId));
232: q.setQueryParams("SELECTION_TYPE", null);
233: }
234: } else { // group integration
235: sContNodeId = selData == null ? evt.getParameter(PARAMETER,
236: "THE_CONTENT_NODE_ID") : evt.getParameter(
237: PARAMETER, "NODE_ID");
238: sSelType = selData == null ? null : evt.getParameter(
239: PARAMETER, "SEL_TYPE");
240: q.setQueryParams("CONTENT_NODE_ID",
241: new Integer(sContNodeId));
242: q.setQueryParams("SELECTION_TYPE", sSelType);
243: }
244: q.setQueryParams("SELECTION_DATA", selData);
245: q.execute();
246: q.fetchResultSet();
247: }
248:
249: /**
250: * Speichern eines SiteTree node
251: *
252: *
253: *
254: * @param selData, selType, pGCNode
255: *
256: * selData: die SELECTION_DATA
257: * selType: der SELECTION_TYPE
258: * pGCNode: der primary group content node (nur bei group nodes (SiteTree))
259: */
260: public static String saveSiteTreeNode(TKEvent evt, String selData,
261: String selType, int pGCNode) throws Throwable {
262: String sNodeName = evt
263: .getParameter(PARAMETER, "SITE_NODE_NAME");
264: String sNodeShortName = evt.getParameter(PARAMETER,
265: "SITE_NODE_SHORTNAME");
266: sNodeShortName = CEUtils.checkFileName(sNodeShortName);
267: String nodeType = evt.getParameter(PARAMETER, "SITE_NODE_TYPE");
268: String parId = evt.getParameter(PARAMETER, "SITE_NODE_ID");
269:
270: TKQuery q = TKDBManager.newQuery(TKDBSiteTreeInsertNode.class);
271: q.setQueryParams("NODE_ID", new Integer(parId));
272: q.setQueryParams("SITE_NODE_TYPE", new Integer(nodeType));
273: q.setQueryParams("SITE_NODE_NAME", sNodeName);
274: q.setQueryParams("SITE_NODE_SHORTNAME", sNodeShortName);
275: q.setQueryParams("PG_CONTENT_NODE", pGCNode == -1 ? null
276: : new Integer(pGCNode));
277: q.setQueryParams("SELECTION_TYPE", selType);
278: q.setQueryParams("SELECTION_DATA", selData);
279: q.execute();
280: ResultSet rs = q.fetchResultSet();
281: String nodeID = null;
282: if (rs.next()) {
283: nodeID = Integer.toString(rs.getInt("SITE_NODE_ID"));
284: }
285: return nodeID;
286: }
287:
288: /**
289: * Update eines SiteTree node
290: *
291: *
292: *
293: * @param selData, selType, pGCNode
294: *
295: * selData: die SELECTION_DATA
296: * selType: der SELECTION_TYPE
297: * pGCNode: der primary group content node (nur bei group nodes (SiteTree))
298: */
299: public static void updateSiteTreeNode(TKEvent evt, String selData,
300: String selType, int pGCNode) throws Throwable {
301: String sNodeName = evt
302: .getParameter(PARAMETER, "SITE_NODE_NAME");
303: String sNodeShortName = evt.getParameter(PARAMETER,
304: "SITE_NODE_SHORTNAME");
305: String nodeType = evt.getParameter(PARAMETER, "SITE_NODE_TYPE");
306: String nodeId = evt.getParameter(PARAMETER, "SITE_NODE_ID");
307: sNodeShortName = CEUtils.checkFileName(sNodeShortName);
308:
309: TKQuery q = TKDBManager.newQuery(TKDBSiteTreeUpdateNode.class);
310: q.setQueryParams("SITE_NODE_ID", new Integer(nodeId));
311: q.setQueryParams("SITE_NODE_TYPE", new Integer(nodeType));
312: q.setQueryParams("SITE_NODE_NAME", sNodeName);
313: q.setQueryParams("SITE_NODE_SHORTNAME", sNodeShortName);
314: q.setQueryParams("PG_CONTENT_NODE", pGCNode == -1 ? null
315: : new Integer(pGCNode));
316: q.setQueryParams("SELECTION_TYPE", selType);
317: q.setQueryParams("SELECTION_DATA", selData);
318: q.execute();
319: q.fetchResultSet();
320: }
321:
322: /**
323: * ist der String destName als DOCUMENT_SHORTNAME nicht im ResultSet ?
324: *
325: * @param
326: */
327: public static boolean isNotInRs(TKDBResult rs, String destName)
328: throws Throwable {
329: int curr = 0;
330: TKDBResultRow row;
331: boolean res = true;
332: String checkName;
333: while ((row = (TKDBResultRow) rs.get(curr++)) != null) {
334: checkName = (String) row.getColumn("DOCUMENT_SHORTNAME");
335: res = checkName.equals(destName) == true ? false : true;
336: if (!res)
337: return res;
338: }
339: return res;
340: }
341:
342: /**
343: * ist der String checkId als CONTENT_NODE_ID im ResultSet ?
344: *
345: * @param
346: */
347: public static boolean isGroupNode(String checkId, TKDBResult rs)
348: throws Throwable {
349: int curr = 0;
350: TKDBResultRow row;
351: boolean res = false;
352: String rsId;
353: while ((row = (TKDBResultRow) rs.get(curr++)) != null) {
354: rsId = (String) row.getColumn("CONTENT_NODE_ID");
355: res = rsId.equals(checkId);
356: if (res)
357: return res;
358: }
359: return res;
360: }
361:
362: /**
363: * Maske fuellen fuer neuen Node
364: * (entweder durch click auf new,
365: * bei cancel einer selection verfeinerung,
366: * oder bei edit eines node)
367: *
368: * @param
369: */
370: public static void prepareNodeParams(TKHTMLTemplate t,
371: String nodeType) throws Throwable {
372: if (nodeType.equals(GROUP)) {
373: TKQuery q = TKWebmanDBManager
374: .newQuery(TKDBContentTreeGetTypeOrderByName.class);
375: q.setQueryParams("CONTENT_NODE_TYPE", GROUP_INTEGER); // alle group contents
376: q.execute();
377: ResultSet rs = q.fetchResultSet();
378:
379: TKDBTemplate.prepareListTemplate(rs, t, "ST_PGC_LIST");
380:
381: q = TKWebmanDBManager
382: .newQuery(TKDBContentSelClassGet.class);
383: q.setQueryParams("RESULT_TYPE", GROUP_INTEGER);
384: q.execute();
385: rs = q.fetchResultSet();
386:
387: TKDBTemplate.prepareListTemplate(rs, t, "ST_PGCST_LIST");
388: }
389: }
390:
391: /**
392: * stellt den path ab der documentroot bis zum aktuellen SITE_NODE (SITE_NODE_ID)
393: * beginnend mit der root, sich zusammensetzend aus den SITE_NODE_SHORTNAMEs
394: * zusammen. ROOT wird hier ignoriert !!!!!
395: *
396: * @param siteNodeId ID des Endknotens
397: * @return aktueller Pfad
398: * @throws SQLException Datenbankfehler
399: */
400: public static String getCurrentPath(Integer siteNodeId)
401: throws SQLException {
402: TKQuery q = TKDBManager.newQuery(TKDBSiteTreeGetParents.class);
403: q.setQueryParams("SITE_NODE_ID", siteNodeId);
404: q.execute();
405: ResultSet rs = q.fetchResultSet();
406: String res = "/";
407: if (!rs.next()) // Root ignorieren und SQL Fehler vorbeugen
408: return res;
409: while (rs.next()) {
410: res += rs.getString("SITE_NODE_SHORTNAME") + "/";
411: }
412: return res;
413: }
414:
415: /**
416: * Returns the full path of the specified site node.
417: *
418: * @param id the id of the site node.
419: * @return the full path of the specified site node.
420: * @throws TKException if any error occurred during
421: * site node path construction.
422: */
423: public static String getParentPath(Integer id) throws TKException {
424: try {
425: TKQuery query = TKDBManager
426: .newQuery(TKDBSiteTreeGetParents.class);
427: query.setQueryParams("SITE_NODE_ID", id);
428: query.execute();
429:
430: ResultSet result = query.fetchResultSet();
431: StringBuffer path = new StringBuffer();
432:
433: if (result.next()) {
434: while (result.next()) {
435: path.append("/").append(
436: result.getString("SITE_NODE_NAME"));
437: }
438: }
439:
440: if (path.length() == 0) {
441: path.append("/");
442: }
443:
444: return path.toString();
445: } catch (Exception e) {
446: throw WebmanExceptionHandler.getException(e);
447: }
448: }
449:
450: /**
451: * Vorbereiten der verfeinerten Content-Selection:
452: * holen der selection_data, falls vorhanden, vorsetzen dieser in der sel class
453: *
454: *
455: * @param
456: */
457: public static void prepareRefineSelection(TKEvent evt,
458: TKHTMLTemplate t) throws Throwable {
459: String selId = evt.getNotNullParameter(PARAMETER,
460: "SELECTION_ID");
461: String selData = "";
462: if (!selId.equals("")) {
463: TKQuery q = TKDBManager
464: .newQuery(TKDBContentSelectionGet.class);
465: q.setQueryParams("SELECTION_ID", new Integer(selId));
466: q.execute();
467: ResultSet rs = q.fetchResultSet();
468: if (rs.next()) {
469: selData = rs.getString("SELECTION_DATA");
470: }
471: }
472: String selectedContent = evt.getParameter(PARAMETER,
473: "THE_CONTENT_NODE_ID");
474: if (selectedContent == null)
475: throw new TKUserException("Kein Objekt gewählt", NO_OBJECT,
476: USER_SEVERITY, true, null);
477: if (selData != null && !selData.equals("")) {
478: TKWMContentSelectorReg.edit(t, evt.getParameter(PARAMETER,
479: "THE_SELECTION_TYPE"), Integer
480: .parseInt(selectedContent), selData);
481: } else {
482: TKWMContentSelectorReg.edit(t, evt.getParameter(PARAMETER,
483: "THE_SELECTION_TYPE"), Integer
484: .parseInt(selectedContent));
485: }
486: }
487:
488: }
|