Java > Open Source Codes > de > webman > content > eventhandler > CEUtils


1 package de.webman.content.eventhandler;
2
3 import com.teamkonzept.webman.*;
4 import de.webman.acl.Policy;
5 import com.teamkonzept.web.*;
6 import com.teamkonzept.webman.mainint.*;
7 import com.teamkonzept.webman.mainint.db.*;
8 import com.teamkonzept.webman.mainint.db.queries.*;
9 import com.teamkonzept.webman.mainint.events.*;
10 import com.teamkonzept.lib.*;
11 import com.teamkonzept.field.*;
12 import com.teamkonzept.db.*;
13 import com.teamkonzept.international.LanguageManager;
14 import de.webman.acl.*;
15 import de.webman.content.workflow.*;
16 import de.webman.content.db.queries.SelectShortnamesFromContentTree;
17 import de.webman.sitetree.eventhandler.SiteTreeUtils;
18 import de.webman.content.Content;
19 import com.oroinc.text.regex.*;
20 import java.util.*;
21 import java.sql.*;
22 import java.text.CharacterIterator ;
23 import java.text.StringCharacterIterator ;
24 import java.io.File ;
25
26 import org.apache.log4j.Category;
27
28 /**
29  * Sammlung von Content Utility Routinen
30  * @author $Author: uli $
31  * @version $Revision: 1.33 $
32 */
33 public class CEUtils implements DatabaseDefaults, UserCodes, ParameterTypes
34 {
35     /** logging category */
36     private static Category cat = Category.getInstance(CEUtils.class);
37
38     /** �berpr�ft ob der User das Recht f�r den Event auf dem aktuellen
39         Contentnode besitzt
40         @param evt - der aktuelle Event
41         @throws Throwable - if Error occures during Right checking
42     */
43     public static void checkEvent(TKEvent evt) throws Throwable
44     {
45         String cid=evt.getParameter(PARAMETER, "CONTENT_NODE_ID");
46         WebManEvent.checkEvent(evt.getRemoteUser(), evt.getName(), ContextConstants.CONTENT_EDIT, Policy.CONTENT_TREE_ID, new Integer (cid != null && cid.length() > 0 ? cid : "1"));
47     }
48
49     /** �bergebe String s mache daraus vector (wobei die Elemente in s durch ; getrennt sind **/
50
51     private static Vector getPartSelectedContentsList(String s)
52     {
53         Vector back = new Vector();
54         if ((s == null) || (s.length() == 0))
55             return(null);
56         int top = 0;
57         int bottom = s.indexOf(';');
58         while (bottom != -1)
59         {
60             back.add(new String (s.substring(top, bottom)));
61             top = bottom + 1;
62             bottom = s.indexOf(';',bottom + 1);
63         }
64         return(back);
65     }
66
67     /**
68       * macht aus dem Parameter SELECTED_CONTENTS_LIST einen Vector mit allen Contents
69     **/
70     public static Vector getSelectedContentsList(TKEvent evt)
71     {
72         Vector back = new Vector();
73         String sList = evt.getParameter(PARAMETER, "SELECTED_CONTENTS_LIST");
74         String notList = evt.getParameter(PARAMETER, "NOT_SELECTED_CONTENTS_LIST");
75
76         if ((sList == null) || (sList.length() == 0))
77             return(null);
78
79         back = getPartSelectedContentsList(sList.substring(0,sList.indexOf('-')));
80         Vector nachher = getPartSelectedContentsList(sList.substring(sList.indexOf('-') + 1));
81         if (back == null)
82             return(nachher);
83
84         // nehme nicht selectierte Contents raus
85 Vector notinList = getPartSelectedContentsList(notList);
86         if (notinList != null)
87         {
88             for (int i = 0;i < notinList.size();i++)
89                 back.remove(notinList.elementAt(i));
90         }
91
92         if (nachher == null)
93             return(back);
94
95         for (int i = 0;i < nachher.size();i++)
96         {
97             if (! back.contains(nachher.elementAt(i)))
98                 back.add(nachher.elementAt(i));
99         }
100         return( back );
101     }
102
103     /**
104       * schreibt den Vector der Instances in einen String
105       *
106       * @param vec
107       *
108     */
109     public static String getSelectedContentsString(Vector vec)
110     {
111         String back = "";
112         if (vec != null)
113         {
114             for (int i = 0;i < vec.size();i++)
115                 back = (String )(vec.elementAt(i)) + ";" + back;
116         }
117         return back;
118     }
119
120     /**
121       * schleift die Liste der markierten Contents durch
122       *
123       * @param evt (dort holt er die Parameter raus)
124       * @param t (hier setzt er die Parameter ein)
125     */
126     public static void keepSelectedContents(TKEvent evt,TemplateBasic t)
127     {
128         Vector keep = getSelectedContentsList(evt);
129         t.set("SELECTED_CONTENTS_LIST", new String (getSelectedContentsString(keep)));
130     }
131
132     /** checked ob das Recht f�r den evt (evtname) auf dem contentnode nodeID verf�gbar ist
133      *
134      * @param user (der momentane User)
135      * @param evtname (Name des Events)
136      * @param nodeID (Content_Node_ID)
137      * @return boolean (true falls erlaubt sonst false)
138     */
139     public static boolean isAllowedEvent(String user, String evtname, Integer nodeID) throws TKException
140     {
141             /* hole Login */
142             LoginFactory factory = LoginFactory.getInstance();
143             Login login = factory.getLogin(user);
144             /* hole Event */
145             Event evt = EventFactory.getInstance().getEvent(evtname);
146
147             if (login.isAllowed(evt.getID(), ContextConstants.CONTENT_EDIT, Policy.CONTENT_TREE_ID, nodeID))
148                 return true;
149         return false;
150     }
151
152     /** checked ob das Recht f�r den evt (evtname) im Context content_edit verf�gbar ist
153      *
154      * @param user (der momentane user)
155      * @param evtname (Name des Events)
156      * @return boolean (true falls erlaubt sonst false)
157     */
158     public static boolean isAllowedEvent(String user, String evtname) throws TKException
159     {
160         /* hole Login */
161         LoginFactory factory = LoginFactory.getInstance();
162         Login login = factory.getLogin(user);
163         /* hole Event */
164         Event evt = EventFactory.getInstance().getEvent(evtname);
165
166         if (login.isAllowed(evt.getID(), ContextConstants.CONTENT_EDIT))
167             return true;
168         return false;
169     }
170
171
172     /**
173         ueberprueft Abhaengigkeiten ContentTree / Sitetree
174         @param contentNodeID Id des zu checkenden Contents
175         @param subtree nur der Knoten oder auch seine Kinder ?
176     */
177     public static boolean checkDependencies(Integer contentNodeID, TKVector depends, boolean subtree) throws SQLException
178     {
179         TKQuery q = TKDBManager.newQuery(TKDBContentTreeIsDependent.class);
180         q.setQueryParams( "CONTENT_NODE_ID", contentNodeID );
181         q.execute();
182         ResultSet rs = q.fetchResultSet();
183         boolean isDependent = false;
184         while( rs.next() )
185         {
186             int id = rs.getInt("CT_CONTENT_NODE_ID");
187             if (subtree || id == contentNodeID.intValue())
188             {
189                 TKHashtable temp = new TKHashtable();
190                 String cName = rs.getString("CT_CONTENT_NODE_NAME");
191                 String sNodeID = rs.getString("ST_SITE_NODE_ID");
192                 if (sNodeID == null)
193                     sNodeID = rs.getString("SD_SITE_NODE_ID");
194                 String docName = rs.getString("SD_DOCUMENT_SHORTNAME");
195                 String contentNodeType = rs.getString("CT_CONTENT_NODE_TYPE");
196                 if (sNodeID == null)
197                 {
198                     Object [] tmp = new Object [1];
199                     tmp[0] = cName;
200                     String text = "NOT_REFERENCED";
201                     if (contentNodeType.equals(GROUP))
202                         text = "GROUP_NOT_REFERENCED";
203                     String message = LanguageManager.getText("content", text, tmp);
204                     temp.put("REF2", message );
205                     depends.addElement(temp);
206                     continue; // keine Abhaengigkeit
207 }
208                 isDependent = true;
209                 String path = SiteTreeUtils.getCurrentPath(new Integer (sNodeID));
210                 if (docName != null)
211                     path += docName;
212                 Object [] tmp = new Object [2];
213                 tmp[0] = cName;
214                 tmp[1] = path;
215                 String text = "REFERENCED";
216                 if (contentNodeType.equals(GROUP))
217                     text = "GROUP_REFERENCED";
218
219                 String message = LanguageManager.getText("content", text, tmp);
220                 cat.debug("Got : ");
221                 temp.put("REF2", message );
222                 depends.addElement(temp);
223             }
224         }
225         return isDependent;
226     }
227
228     /**
229         checkt, ob innerhalb einer Contentgruppe ein Shortname schon mal vergeben wurde
230         @param contentNodeId ID des Contents, null falls neu
231         @param shortName der zu speichernde Shortname (Kennung)
232         @param neu, wird ein neuer Content
233         @exception falls es einen Konflikt gibt
234     */
235     public static void checkShortName(Integer contentNodeId, Integer groupID, String shortName) throws SQLException, TKUserException
236     {
237         // Query
238 TKQuery q = TKDBManager.newQuery(SelectShortnamesFromContentTree.class);
239         q.setQueryParams("CONTENT_NODE_ID", groupID);
240         q.setQueryParams("CONTENT_NODE_SHORTNAME", shortName);
241         q.execute();
242         // System.out.println("Checking Shortname : " + shortName);
243 // resultSet auswerten
244 ResultSet rs = q.fetchResultSet();
245         int count = 0;
246         if (rs.next())
247         {
248             count ++;
249             // System.out.println("Got result : " + count);
250 if (contentNodeId == null)
251                 throw new TKUserException("Doppelte Kennung", DOUBLE_SHORTNAME, USER_SEVERITY, false, null); // Exception
252 else
253             {
254                 int existingId = rs.getInt("CONTENT_NODE_ID");
255                 if (existingId != contentNodeId.intValue())
256                 {
257                     throw new TKUserException("Doppelte Kennung", DOUBLE_SHORTNAME, USER_SEVERITY, false, null); // Exception
258 }
259             }
260         }
261     }
262
263     /**
264       * schleift die Sortierparameter durch
265       *
266       * @param evt (dort holt er die Parameter raus)
267       * @param t (hier setzt er die Parameter ein)
268     */
269     public static void keepSortParameter(TKEvent evt,TemplateBasic t){
270             String evtName = evt.getName();
271             String sort_by = evt.getParameter("SORT_BY", evtName);
272         if (sort_by != null){
273
274             String sort_up_down = evt.getParameter("SORT_UP_DOWN",evtName);
275             evt.getParams().put(PARAMETER, "SORT_BY", sort_by);
276             evt.getParams().put(PARAMETER, "SORT_UP_DOWN", sort_up_down);
277         }
278         // warum wird das hier noch mal abgefragt,
279 // das haben wir doch gesetzt???
280 // weil es auch direkt �bergeben werden kann (wenn sort_by == null)
281 if (evt.getParameter(PARAMETER,"SORT_BY") != null)
282         {
283             t.set("SORT_BY",new String (evt.getParameter(PARAMETER,"SORT_BY")));
284             t.set("SORT_UP_DOWN",new String (evt.getParameter(PARAMETER,"SORT_UP_DOWN")));
285         }
286     }
287
288
289         /**
290      * �berf�hrt den String <name> in einen brauchbaren Dateinamen, d.h.
291      * es werde spaces, Umlaute etc. ersetzt.
292      */
293     public static String toFilename( final String name ) {
294         final StringBuffer fname = new StringBuffer ( name.length() );
295         final StringCharacterIterator iter = new StringCharacterIterator ( name );
296         for ( char ch = iter.current(); ch != CharacterIterator.DONE; ch = iter.next() ) {
297             switch ( ch ) {
298             case '�':
299                 fname.append( "ae" );
300                 break;
301             case '�':
302                 fname.append( "Ae" );
303                 break;
304             case '�':
305                 fname.append( "oe" );
306                 break;
307             case '�':
308                 fname.append( "Oe" );
309                 break;
310             case '�':
311                 fname.append( "ue" );
312                 break;
313             case '�':
314                 fname.append( "Ue" );
315                 break;
316             case '�':
317                 fname.append( "ss" );
318                 break;
319             case '_':
320             default:
321                 if ( Character.isWhitespace( ch )
322                         || Character.isISOControl( ch )
323                         || ch == File.separatorChar ) {
324                     fname.append( '_' );
325                 } else {
326                     fname.append( ch );
327                 }
328                 break;
329             }
330         }
331         return fname.toString();
332     }
333
334     /**
335         ersetzt Leerzeichen durch _
336     */
337     public static String checkFileName( String fileName )
338     {
339         fileName = toFilename(fileName);
340         /*
341         char[] theChars = fileName.toCharArray();
342
343         for(int i=0; i < theChars.length; i++) {
344
345             if( ((theChars[i] >= 'A') && (theChars[i] <= 'Z')) ||
346                 ((theChars[i] >= 'a') && (theChars[i] <= 'z')) ||
347                 ((theChars[i] >= '0') && (theChars[i] <= '9'))
348
349             ){
350             }
351             else {
352                 if(theChars[i] != '.')
353                     theChars[i] = '_';
354             }
355         }
356
357         return new String(theChars);
358         */
359         return fileName.replace(' ', '_');
360     }
361
362     public static ContentContext keepCEContext( TKEvent evt, TemplateBasic t ) throws Throwable
363     {
364         return keepCEContext (evt, t, evt.getName());
365     }
366
367     /**
368      * holt aus den params die durchzuschleifenden Params und setzt sie ins
369      * Template t
370      *
371      * @param Template t
372      */
373     public static ContentContext keepCEContext( TKEvent evt, TemplateBasic t, String event ) throws Throwable
374     {
375         ContentContext ceContext = new ContentContext (evt.getParams(), event);
376         ceContext.fillIntoTemplate (t);
377         return ceContext;
378     }
379
380     /**
381      * testen, ob der name ein gueltiger pathname ist
382      *
383      * @param
384      */
385     public static boolean isValidPathname(String name ) throws Throwable
386     {
387         if( name == null || name.equals( "" ) ) { // leer is natuerlich auch nicht gut...
388 throw new TKUserException("Es mu� ein Name angegeben werden", NO_PATHNAME, USER_SEVERITY, true, null);
389         }
390
391         PatternMatcher matcher = TKReg.getMatcher();
392         PatternCompiler compiler = TKReg.getCompiler();
393         Pattern patNotAllowed;
394
395         // nur wordcharacter (alphanumeric) fuer dirnamen: a-zA-Z_0-9 und das -
396 // to DO :: Das pa�t nicht zur Localisation !!!
397 patNotAllowed = compiler.compile( "[^a-zA-Z_0-9\\-.]" );
398         if( matcher.contains( name, patNotAllowed ) ) {
399             // kein gueltiger pathname! interner name (content_node_shortname)
400 // wird vom generator als verzeichnisname verwendet
401 throw new TKUserException("Kein g�ltiger Pfadname: " + name, NO_VALID_PATHNAME, USER_SEVERITY, true, null);
402         } else {
403             return true;
404         }
405     }
406
407     /**
408      * Ermitteln der Zust�nde von Content-Instanzen
409      *
410      *
411      * @param
412      */
413     private static void filterInstances (
414         VersionStatics statics, TKVector vec,
415         TKHashtable versions, TKHashtable filter) {
416
417         int instIndex = 0;
418         while (instIndex < vec.size()) {
419
420             TKHashtable instHash = (TKHashtable) vec.elementAt(instIndex);
421             TKVector instanceVersions = (TKVector) instHash.get("VERSIONS");
422             TKHashtable interestingKeys = new TKHashtable();
423
424             int index = -1;
425             Enumeration e = instanceVersions.elements();
426             while (e.hasMoreElements ())
427             {
428                 TKSortableInteger versionKey = (TKSortableInteger) e.nextElement();
429                 Integer statusKey = (Integer ) versions.get (versionKey);
430                 index++;
431
432                 VersionSelection.selectContentVersionByStatus
433                     (statics,interestingKeys,null,versionKey,statusKey);
434             }
435
436             boolean removed = false;
437             TKHashtable forced = VersionSelection.getForcedStatusList (filter);
438
439             for (index = 0; index < instanceVersions.size(); index++)
440             {
441                 TKSortableInteger versionKey = (TKSortableInteger) instanceVersions.elementAt(index);
442                 if (versionKey == null) continue;
443
444                 Integer statusKey = (Integer ) interestingKeys.get(versionKey);
445                 if (statusKey == null) continue;
446
447                 String filterCommand = (String ) filter.get (statusKey);
448
449                 if (filterCommand != null && filterCommand.equalsIgnoreCase("EXCLUDE")) {
450
451                     vec.removeElementAt (instIndex);
452                     removed = true;
453                     break;
454
455                 } else if (filterCommand != null && filterCommand.equalsIgnoreCase("FORCE"))
456                     forced.remove (statusKey);
457             }
458
459             if (!removed) {
460
461                 if (forced.size() > 0) vec.removeElementAt (instIndex);
462                 else instIndex++;
463             }
464         }
465     }
466
467     /**
468      * Erzeugt eine Liste aller Instanzen zu einem Gruppen-Knoten,
469      * die einem Filterkriterium gen�gen
470      *
471      *
472      * @param
473      */
474     public static TKVector getFilteredInstances (int nodeId, TKHashtable filter) throws Throwable
475     {
476         // statische Daten der Versionsverwaltuung abrufen
477 VersionStatics statics = VersionStatics.setup();
478
479         if (filter == null) filter = VersionSelection.initContentFilter(statics.getStatusPool());
480
481         TKQuery q = TKDBManager.newQuery(TKDBGetAllNodeContentVersions.class);
482         q.setQueryParams( "CONTENT_NODE_ID",new Integer (nodeId));
483
484         q.execute();
485         ResultSet rs = q.fetchResultSet();
486         TKVector vec = new TKVector();
487         TKHashtable instances = new TKHashtable();
488         TKHashtable versions = new TKHashtable();
489
490         while (rs.next()) {
491
492             int versionId = rs.getInt ("VERSION_ID");
493             int instanceId = rs.getInt ("INSTANCE_ID");
494             int contentNodeId = rs.getInt ("CONTENT_NODE_ID");
495             int contentNodeType = rs.getInt ("CONTENT_NODE_TYPE");
496             // Auskommentiert wegen JTest begin
497 // int contentId = rs.getInt ("CONTENT_ID");
498 // Auskommentiert wegen JTest end
499
500             int statusId = rs.getInt ("STATUS_ID");
501
502             VersionStatus statusDesc = (VersionStatus) statics.getStatusPool().get(new Integer (statusId));
503             if (statusDesc.comment) continue;
504
505             String contentNodename = rs.getString ("CONTENT_NODE_NAME");
506             String contentNodeShortName = rs.getString ("CONTENT_NODE_SHORTNAME");
507             String instanceName = rs.getString ("NAME");
508
509             TKVector instanceVersions = null;
510
511             TKHashtable instHash = (TKHashtable) instances.get (new Integer (instanceId));
512             if (instHash == null) {
513
514                 instHash = new TKHashtable();
515                 vec.addElement (instHash);
516                 instances.put (new Integer (instanceId), instHash);
517
518                 instHash.put ("INSTANCE_ID",new Integer (instanceId));
519                 instHash.put ("CONTENT_NODE_ID",new Integer (contentNodeId));
520                 instHash.put ("CONTENT_NODE_NAME",contentNodename);
521                 instHash.put ("CONTENT_NODE_SHORTNAME",contentNodeShortName);
522                 instHash.put ("CONTENT_NODE_TYPE",new Integer (contentNodeType));
523                 instHash.put ("NAME",instanceName);
524
525                 instanceVersions = new TKVector ();
526                 instHash.put ("VERSIONS",instanceVersions);
527
528             } else {
529                 instanceVersions = (TKVector) instHash.get("VERSIONS");
530             }
531
532             TKSortableInteger versionKey = new TKSortableInteger (versionId);
533             versions.put (versionKey,new Integer (statusId));
534             instanceVersions.addElement (versionKey);
535         }
536
537         filterInstances (statics,vec,versions,filter);
538
539         return vec;
540     }
541
542     public static int getVersionInfo (
543         ContentContext ceContext, TemplateBasic t, VersionStatics statics) throws Throwable
544     {
545         if (ceContext.toStatusId.intValue() < 0)
546             throw new Exception ("WebManThread.getVersionInfo: No dest status");
547         int transitionableVersion = ceContext.instanceId.intValue() < 0 ? -1 :
548             getTransitionableInstanceVersion (statics,ceContext.instanceId,ceContext.versionId,ceContext.toStatusId);
549         if (transitionableVersion >= 0)
550         {
551             t.set ("TRANS_VERSION",new Integer (transitionableVersion));
552             if (ceContext.versionId.intValue() < 0) ceContext.versionId = new Integer (transitionableVersion);
553
554         } else if (ceContext.instanceId.intValue() >= 0) t.set ("MODE","RO");
555
556         // ceContext.sVersionId = ceContext.versionId.intValue() < 0 ? null : ceContext.versionId;
557 return transitionableVersion;
558     }
559
560     /**
561      * Liefert die aktuellste Version einer Content-Instanz die, bzw. �berpr�ft ob eine
562      * uebergebene Version jeweils eine Transition mit dem �bergebenen Zielzustand
563      * schaltet
564      *
565      * @param statics statische Versionsinfos
566      * @param instanceId ID der Instanz
567      * @param testVersion
568      * @param destStatus Zielstatus
569      */
570     public static int getTransitionableInstanceVersion (
571         VersionStatics statics,
572         Integer instanceId, Integer testVersion, Integer destStatus) throws Throwable
573     {
574         // Alle Versionsinformationen zu einer Instanz aus DB holen
575 // geordnet nach Contentids und dann chronologisch
576 TKQuery q = TKDBManager.newQuery(TKDBGetAllInstanceVersions.class);
577         q.setQueryParams( "INSTANCE_ID",instanceId);
578         q.execute();
579         ResultSet rs = q.fetchResultSet();
580
581         // ordnet jeder Version ihre Versionsdaten (Hashtabelle) zu
582 TKHashtable versions = new TKHashtable();
583
584         // Liste der Ids aller Versionen (geordnet)
585 TKVector instanceVersions = new TKVector ();
586
587         // Resultset abarbeiten, kommentierende Versionsinformationen abfiltern
588 while (rs.next())
589         {
590             int versionId = rs.getInt("VERSION_ID");
591             int statusId = rs.getInt("STATUS_ID");
592
593             VersionStatus statusDesc = (VersionStatus) statics.getStatusPool().get(new Integer (statusId));
594             if (statusDesc.comment) continue;
595
596             TKHashtable versionData = new TKHashtable();
597             versionData.put("STATUS_ID", new Integer (statusId));
598
599             TKSortableInteger versionKey = new TKSortableInteger (versionId);
600             versions.put(versionKey, versionData);
601             instanceVersions.addElement(versionKey);
602         }
603
604         // ordnet jeder "relevanten" Version ihren Zustand zu
605 TKHashtable interestingKeys = new TKHashtable();
606
607         // ordnet jeder "relevanten" Version ihre m�glichen Folgetransitionen, d.h.
608 // erlaubte �berg�nge zu neuen Zust�nden zu
609 TKHashtable interesting = new TKHashtable();
610
611         // Durchl�uft die Versionsgeschichte einer Instanz in der Reihenfolge der Versionierung
612 // �ber die ContentValues und innerhalb dieser chronologisch �ber die Versionsinformationen
613 //
614 // F�r jede solche Version wird untersucht, ob die davor liegenden Versionen noch
615 // relevant sind, andernfalls werden sie aus interestingKeys und interesting entfernt.
616 // Die aktuelle Version ist auf jeden Fall relevant und wird in interestingKeys und
617 // interesting eingetragen. F�r interestingKeys wird der Zustand vermerkt, f�r
618 // interesting wird wird ein zun�chst leerer Vector mit m�glichen Folgetransitionen
619 // angelegt. Diese werden in einem weiteren Schritt ermittelt
620
621         int index = -1;
622         Enumeration e = instanceVersions.elements();
623         while (e.hasMoreElements ())
624         {
625             TKSortableInteger versionKey = (TKSortableInteger) e.nextElement();
626
627             TKHashtable versionData = (TKHashtable) versions.get (versionKey);
628             Integer statusKey = (Integer ) versionData.get ("STATUS_ID");
629             index++;
630
631             // Ausfiltern der nicht mehr relevanten Versionen aus interestingKeys und
632 // interesting und Erg�nzung um die laufende Version.
633 VersionSelection.selectContentVersionByStatus
634                 (statics,interestingKeys,testVersion.intValue() < 0 ? interesting : null,versionKey,statusKey);
635
636             TKVector transVec = new TKVector();
637             interesting.put (versionKey,transVec);
638
639             // Bestimmung der m�glichen Folgetransitionen zu der laufenden Version
640 VersionSelection.selectContentTransitions
641                 (statics,versions,statics.getStatusPool(),instanceVersions,
642                  interestingKeys,transVec,versionKey.intValue(),index);
643         }
644
645         VersionStatus statusDesc = (VersionStatus) statics.getStatusPool().get(destStatus);
646
647         // Aktuelleste Version die schaltet
648 TKSortableInteger transitionableVersion = null;
649
650         // Durchl�uft die Versionsgeschichte einer Instanz in der Reihenfolge der Versionierung
651 // �ber die ContentValues und innerhalb dieser chronologisch �ber die Versionsinformationen
652 for (index = 0; index < instanceVersions.size(); index++) {
653
654             TKSortableInteger versionKey = (TKSortableInteger) instanceVersions.elementAt(index);
655             if (versionKey == null) continue;
656
657             // Geht es nur darum zu ueberpruefen, ob eine �bergebene Version schaltet,
658 // k�nnen die anderen Versionen (nicht aber die oben ausgewertete
659 // Versionsgeschichte) verworfen werden.
660 if (testVersion.intValue() >= 0 && versionKey.intValue() != testVersion.intValue()) continue;
661
662             TKVector trans = (TKVector) interesting.get(versionKey);
663             if (trans == null) continue;
664
665             int transIndex = 0;
666             while (transIndex < trans.size()) {
667
668                 // Auskommentiert wegen JTest begin
669 // TKVersionStatusTransitionDBData dbData =
670 // (TKVersionStatusTransitionDBData) trans.elementAt(transIndex);
671 // Auskommentiert JTest end
672
673                 // �berpr�fen ob der beim schalten erreichte Zielzustand noch
674 // mit den relevanten anderen Versionen vereinbar ist
675 // Erfolgt die �berpr�fung anhand testVersion, reicht es, da� eine
676 // beliebige "relevante" Version aus interestingKeys schaltet,
677 // ansonsten mu� es die laufende sein
678 if (statusDesc.newVersion &&
679                     VersionSelection.testContentTransition
680                         (statics,testVersion.intValue() >= 0,interestingKeys,versionKey.intValue(),
681                          destStatus) != null)
682                     transitionableVersion = versionKey;
683
684                 transIndex++;
685             }
686         }
687
688         return transitionableVersion == null ? -1 : transitionableVersion.intValue();
689     }
690
691     /**
692      * Speichern von eingegebenem Content
693      *
694      * @param
695      * @return die erzeugte Instanz ID
696      */
697     public static Content createContentInstance (Integer instanceId, Integer contentNodeType, String name, String shortName, Integer groupId, Integer formId, Integer contentNodeId) throws Throwable
698     {
699         if (contentNodeType.intValue() == GROUP_INTEGER.intValue() || contentNodeType.intValue() == DIRECTORY_NODE_INTEGER.intValue()) {
700
701             if (contentNodeId.intValue() == -1 || (contentNodeType.intValue() == DIRECTORY_NODE_INTEGER.intValue() && instanceId.intValue() == -1) )
702             {
703                 // Content Neu
704 cat.debug("Inserting new content ! : " + name);
705                 TKQuery q = TKDBManager.newQuery(TKDBContentTreeInsertNode.class);
706                 Integer parentId = contentNodeType.intValue() == GROUP_INTEGER.intValue() ? groupId : contentNodeId;
707                 q.setQueryParams( "NODE_ID", parentId );
708                 q.setQueryParams( "CONTENT_NODE_NAME", name );
709                 q.setQueryParams( "CONTENT_NODE_SHORTNAME", shortName );
710                 q.setQueryParams( "CONTENT_NODE_TYPE", SINGLE_INTEGER );
711                 q.setQueryParams( "CONTENT_FORM", formId.intValue() < 0 ? ((Object ) TKNull.NULL) : formId);
712                 q.setQueryParams( "TREE_ID", new Integer (0) );
713                 q.setQueryParams( "PROTOTYPE_ID", TKNull.NULL );
714                 q.execute();
715                 ResultSet rs = q.fetchResultSet();
716                 if( !rs.next() ) throw new Error ("WebManThread.doCESave: Query gives no result");
717                 contentNodeId = new Integer (rs.getInt("CONTENT_NODE_ID"));
718                 cat.debug("Got new content node id : " + contentNodeId);
719                 TKContentInstanceDBData instDB = new TKContentInstanceDBData(contentNodeId.intValue(), "default" );
720                 TKContentInstanceDBInterface.New( instDB );
721                 return new Content(contentNodeId, name, shortName, new Integer (instDB.instance_id), formId, contentNodeType.intValue() == DIRECTORY_NODE_INTEGER.intValue(), parentId);
722             }
723
724         } else if (instanceId.intValue() == -1)
725         {
726             // Content Neu sollte im Moment nicht auftreten !
727 throw new RuntimeException ("Not implemented !");
728             /*
729             TKContentInstanceDBData instDB = new TKContentInstanceDBData(contentNodeId.intValue(), "default" );
730             TKContentInstanceDBInterface.New( instDB );
731             return new Integer(instDB.instance_id);*/
732         }
733         return null;
734     }
735
736     /**
737      * stellt den path ab der documentroot bis zum aktuellen CONTENT_NODE (CONTENT_NODE_ID)
738      * beginnend mit der root, sich zusammensetzend aus den CONTENT_NODE_SHORTNAMEs
739      * zusammen
740      *
741      * @param contentNodeId Id des Content Nodes
742      * @return aktueller Pfad
743      * @throws SQLException Datenbankfehler
744      */
745     public static String getCurrentPath (Integer contentNodeId)
746         throws SQLException
747     {
748         TKQuery q = TKDBManager.newQuery(TKDBContentTreeGetParents.class);
749         q.setQueryParams( "CONTENT_NODE_ID", contentNodeId );
750         q.execute();
751         ResultSet rs = q.fetchResultSet();
752         String res = "/";
753         while( rs.next() ) {
754             res += rs.getString( "CONTENT_NODE_SHORTNAME" )+"/";
755         }
756         return res;
757     }
758
759     /**
760      * stellt den path ab der documentroot bis zum aktuellen CONTENT_NODE (CONTENT_NODE_ID)
761      * beginnend mit der root, sich zusammensetzend aus den CONTENT_NODE_NAMEs
762      * zusammen
763      *
764      * @param contentNodeId Id des Content Nodes
765      * @return aktueller Pfad
766      * @throws SQLException Datenbankfehler
767      */
768     public static String getCurrentNamePath (Integer contentNodeId)
769         throws SQLException
770     {
771         TKQuery q = TKDBManager.newQuery(TKDBContentTreeGetParents.class);
772         q.setQueryParams( "CONTENT_NODE_ID", contentNodeId );
773         q.execute();
774         ResultSet rs = q.fetchResultSet();
775         String res = "/";
776         while( rs.next() ) {
777             res += rs.getString( "CONTENT_NODE_NAME" )+"/";
778         }
779         return res;
780     }
781
782     /**
783      * Returns the full path of the specified content node.
784      *
785      * @param id the id of the content node.
786      * @return the full path of the specified content node.
787      * @throws TKException if any error occurred during
788      * content node path construction.
789      */
790     public static String getParentPath (Integer id)
791         throws TKException
792     {
793         try
794         {
795             TKQuery query = TKDBManager.newQuery(TKDBContentTreeGetParents.class);
796             query.setQueryParams("CONTENT_NODE_ID", id);
797             query.execute();
798
799             ResultSet result = query.fetchResultSet();
800             StringBuffer path = new StringBuffer ();
801
802             while (result.next())
803             {
804                 path.append("/")
805                     .append(result.getString("CONTENT_NODE_NAME"));
806             }
807
808             if (path.length() == 0)
809             {
810                 path.append("/");
811             }
812
813             return path.toString();
814         }
815         catch (Exception e)
816         {
817             throw WebmanExceptionHandler.getException(e);
818         }
819     }
820
821 }
822

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Free Books   Free Magazines  

Popular Tags