FormDependencies


1   package de.webman.form;
2   
3   import java.sql.ResultSet  ;
4   import java.util.Enumeration  ;
5   import java.util.Hashtable  ;
6   import java.util.Vector  ;
7   import com.teamkonzept.web.TKEvent;
8   import com.teamkonzept.db.TKDBManager;
9   import com.teamkonzept.db.TKQuery;
10  import com.teamkonzept.lib.TKException;
11  import com.teamkonzept.lib.TKHashtable;
12  import com.teamkonzept.lib.TKVector;
13  import com.teamkonzept.webman.mainint.DatabaseDefaults;
14  import com.teamkonzept.webman.mainint.WebmanExceptionHandler;
15  import de.webman.content.eventhandler.CEUtils;
16  import de.webman.form.Form;
17  import de.webman.form.db.FormConstants;
18  import de.webman.form.db.queries.FormExists;
19  import de.webman.form.db.queries.SelectReferencedContents;
20  import de.webman.form.db.queries.SelectReferencedDocumentTypes;
21  import de.webman.form.db.queries.SelectReferencedForms;
22  import de.webman.form.db.queries.SelectReferencedNonEmptyContents;
23  import de.webman.form.db.queries.SelectReferencedSiteNodes;
24  import de.webman.form.eventhandler.CTUtils;
25  import de.webman.sitetree.eventhandler.SiteTreeUtils;
26  
27  /**
28   * Provides form dependency checking.
29   *
30   * @author $Author: uli $
31   * @version $Revision: 1.7.2.2 $
32   */
33  public class FormDependencies
34  {
35  
36      /**
37       * Returns a list of objects depending on the specified
38       * form definition.
39       *
40       * @param form the form holder.
41       * @return a list of objects depending on the specified
42       * form definition.
43       * @throws TKException if an error occurred during dependency tracking.
44       */
45      public static TKVector getDependencies (Form form)
46          throws TKException
47      {
48          TKVector container = new TKVector();
49  
50          if (form.isFormFragment())
51          {
52              getDependingForms(form, container);
53              return container;
54          }
55  
56          if (form.isContentForm())
57          {
58              getDependingContents(form, container);
59              getDependingDocumentTypes(form, container);
60  
61              return container;
62          }
63  
64          if (form.isStructureForm())
65          {
66              getDependingSiteNodes(form, container);
67              getDependingDocumentTypes(form, container);
68  
69              return container;
70          }
71  
72          return container;
73      }
74  
75      /**
76       * Returns a list of forms depending on the specified
77       * form definition.
78       *
79       * @param form the form holder.
80       * @param container the list to be used.
81       * @return a list of forms depending on the specified
82       * form definition.
83       * @throws TKException if an error occurred during dependency tracking.
84       */
85      public static TKVector getDependingForms (Form form,
86                                                TKVector container)
87          throws TKException
88      {
89          try
90          {
91              Hashtable   registry = new Hashtable  ();
92              Vector   indirections = readDependingForms(form, registry);
93  
94              TKVector directList = new TKVector();
95              Enumeration   keys = registry.keys();
96  
97              while (keys.hasMoreElements())
98              {
99                  Form holder = (Form) registry.get(keys.nextElement());
100 
101                 TKHashtable entry = new TKHashtable();
102                 entry.put("OBJECT_ID", holder.getIdentifier());
103                 entry.put("OBJECT_NAME", holder.getDescription());
104                 entry.put("OBJECT_TYPE", CTUtils.getFormTypeDescription(holder));
105 
106                 directList.addElement(entry);
107             }
108 
109             if (directList.size() > 0)
110             {
111                 TKHashtable directForms = new TKHashtable();
112                 directForms.put("CONTEXT_NAME", "FORMS_DIRECT");
113                 directForms.put("OBJECT_LIST", directList);
114 
115                 container.addElement(directForms);
116             }
117 
118             TKVector indirectList = new TKVector();
119 
120             if (indirections.size() > 0)
121             {
122                 registry = new Hashtable  ();
123 
124                 for (int index = 0; index < indirections.size(); index++)
125                 {
126                     resolveDependingForms((Form) indirections.elementAt(index), registry);
127                 }
128 
129                 keys = registry.keys();
130 
131                 while (keys.hasMoreElements())
132                 {
133                     Form holder = (Form) registry.get(keys.nextElement());
134 
135                     TKHashtable entry = new TKHashtable();
136                     entry.put("OBJECT_ID", holder.getIdentifier());
137                     entry.put("OBJECT_NAME", holder.getDescription());
138                     entry.put("OBJECT_TYPE", CTUtils.getFormTypeDescription(holder));
139 
140                     indirectList.addElement(entry);
141                 }
142             }
143 
144             if (indirectList.size() > 0)
145             {
146                 TKHashtable indirectForms = new TKHashtable();
147                 indirectForms.put("CONTEXT_NAME", "FORMS_INDIRECT");
148                 indirectForms.put("OBJECT_LIST", indirectList);
149 
150                 container.addElement(indirectForms);
151             }
152 
153             return container;
154         }
155         catch (Exception   e)
156         {
157             throw WebmanExceptionHandler.getException(e);
158         }
159     }
160 
161     /**
162      * Resolves the forms depending on the specified form definition.
163      *
164      * @param form the form holder.
165      * @param registry the table of resolved forms.
166      * @throws TKException if an error occurred during dependency tracking.
167      */
168     private static void resolveDependingForms (Form form,
169                                                Hashtable   registry)
170         throws TKException
171     {
172         Vector   indirections = readDependingForms(form, registry);
173 
174         for (int index = 0; index < indirections.size(); index++)
175         {
176             resolveDependingForms((Form) indirections.elementAt(index), registry);
177         }
178     }
179 
180     /**
181      * Reads the forms depending on the specified form definition.
182      *
183      * @param form the form holder.
184      * @param registry the table of resolved forms.
185      * @return a list of forms to be resolved.
186      * @throws TKException if an error occurred during dependency tracking.
187      */
188     private static Vector   readDependingForms (Form form,
189                                               Hashtable   registry)
190         throws TKException
191     {
192         try
193         {
194             Vector   indirections = new Vector  ();
195 
196             TKQuery query = TKDBManager.newQuery(SelectReferencedForms.class);
197             query.setQueryParams(FormConstants.COLUMN_NAMES[FormConstants.FORM_ID],
198                                  form.getIdentifier());
199             query.execute();
200 
201             ResultSet   result = query.fetchResultSet();
202 
203             while (result.next())
204             {
205                 Form dependency = new Form(new Integer  (result.getInt("FORM_ID")));
206 
207                 if (dependency.isFormFragment())
208                 {
209                     indirections.addElement(dependency);
210                 }
211 
212                 if (! dependency.isTemporaryForm())
213                 {
214                     registry.put(dependency.getIdentifier(), dependency);
215                 }
216 
217             }
218 
219             return indirections;
220         }
221         catch (Exception   e)
222         {
223             throw WebmanExceptionHandler.getException(e);
224         }
225     }
226 
227     /**
228      * Returns a list of site nodes depending on the specified
229      * form definition.
230      *
231      * @param form the form holder.
232      * @param container the list to be used.
233      * @return a list of site nodes depending on the specified
234      * form definition.
235      * @throws TKException if an error occurred during dependency tracking.
236      */
237     public static TKVector getDependingSiteNodes (Form form,
238                                                   TKVector container)
239         throws TKException
240     {
241         try
242         {
243             TKVector objectList = new TKVector();
244 
245             TKQuery query = TKDBManager.newQuery(SelectReferencedSiteNodes.class);
246             query.setQueryParams(FormConstants.COLUMN_NAMES[FormConstants.FORM_ID],
247                                  form.getIdentifier());
248             query.execute();
249 
250             ResultSet   result = query.fetchResultSet();
251 
252             while (result.next())
253             {
254                 Integer   id = new Integer  (result.getInt("SITE_NODE_ID"));
255 
256                 TKHashtable entry = new TKHashtable();
257                 entry.put("OBJECT_ID", form.getIdentifier());
258                 entry.put("OBJECT_NAME", form.getDescription());
259                 entry.put("PARENT_ID", id);
260                 entry.put("PARENT_NAME", SiteTreeUtils.getParentPath(id));
261 
262                 objectList.addElement(entry);
263             }
264 
265             if (objectList.size() > 0)
266             {
267                 TKHashtable siteStructure = new TKHashtable();
268                 siteStructure.put("CONTEXT_NAME", "SITE_STRUCTURE");
269                 siteStructure.put("OBJECT_LIST", objectList);
270                 siteStructure.put("OBJECT_TYPE", "SITE_CONTENT");
271 
272                 container.addElement(siteStructure);
273             }
274 
275             return container;
276         }
277         catch (Exception   e)
278         {
279             throw WebmanExceptionHandler.getException(e);
280         }
281     }
282 
283     /**
284      * Returns a list of contents depending on the specified
285      * form definition.
286      *
287      * @param form the form holder.
288      * @param container the list to be used.
289      * @return a list of contents depending on the specified
290      * form definition.
291      * @throws TKException if an error occurred during dependency tracking.
292      */
293     public static final TKVector getDependingContents (Form form,
294                                                        TKVector container)
295         throws TKException
296     {
297         return FormDependencies.getDependingContents(form, container, true);
298     }
299 
300     /**
301      * Returns a list of contents depending on the specified
302      * form definition.
303      *
304      * @param form the form holder.
305      * @param container the list to be used.
306      * @param empty specifies wether empty group contents should be
307      * included in the list.
308      * @return a list of contents depending on the specified
309      * form definition.
310      * @throws TKException if an error occurred during dependency tracking.
311      */
312     public static final TKVector getDependingContents (Form form,
313                                                        TKVector container,
314                                                        boolean empty)
315         throws TKException
316     {
317         try
318         {
319             TKVector objectList = new TKVector();
320 
321             TKQuery query = TKDBManager.newQuery(empty
322                                                     ? SelectReferencedContents.class
323                                                     : SelectReferencedNonEmptyContents.class);
324             query.setQueryParams(FormConstants.COLUMN_NAMES[FormConstants.FORM_ID],
325                                  form.getIdentifier());
326             query.execute();
327 
328             ResultSet   result = query.fetchResultSet();
329 
330             while (result.next())
331             {
332                 boolean groupie = result.getString("CONTENT_NODE_TYPE").equals(DatabaseDefaults.GROUP);
333                 Integer   parent = new Integer  (result.getInt("CONTENT_NODE_PARENT"));
334 
335                 TKHashtable entry = new TKHashtable();
336                 entry.put("OBJECT_ID", new Integer  (result.getInt("CONTENT_NODE_ID")));
337                 entry.put("OBJECT_NAME", result.getString("CONTENT_NODE_NAME"));
338                 entry.put("OBJECT_TYPE", groupie ? "GROUP_CONTENT" : "CONTENT");
339                 entry.put("PARENT_ID", parent);
340                 entry.put("PARENT_NAME", CEUtils.getParentPath(parent));
341 
342                 objectList.addElement(entry);
343             }
344 
345             if (objectList.size() > 0)
346             {
347                 TKHashtable contentTree = new TKHashtable();
348                 contentTree.put("CONTEXT_NAME", "CONTENTS");
349                 contentTree.put("OBJECT_LIST", objectList);
350 
351                 container.addElement(contentTree);
352             }
353 
354             return container;
355         }
356         catch (Exception   e)
357         {
358             throw WebmanExceptionHandler.getException(e);
359         }
360     }
361 
362     /**
363      * Returns a list of document types depending on the specified
364      * form definition.
365      *
366      * @param form the form holder.
367      * @param container the list to be used.
368      * @return a list of document types depending on the specified
369      * form definition.
370      * @throws TKException if an error occurred during dependency tracking.
371      */
372     public static final TKVector getDependingDocumentTypes (Form form,
373                                                             TKVector container)
374         throws TKException
375     {
376         try
377         {
378             TKVector objectList = new TKVector();
379 
380             TKQuery query = TKDBManager.newQuery(SelectReferencedDocumentTypes.class);
381             query.setQueryParams(FormConstants.COLUMN_NAMES[FormConstants.FORM_ID],
382                                  form.getIdentifier());
383             query.execute();
384 
385             ResultSet   result = query.fetchResultSet();
386 
387             while (result.next())
388             {
389                 TKHashtable entry = new TKHashtable();
390                 entry.put("OBJECT_ID", new Integer  (result.getInt("PRESENTATION_COMPONENT_IDX")));
391                 entry.put("OBJECT_NAME", result.getString("INTEGRATION_NAME"));
392                 entry.put("PARENT_ID", new Integer  (result.getInt("PRESENTATION_ID")));
393                 entry.put("PARENT_NAME", "/" + result.getString("PRESENTATION_NAME"));
394 
395                 objectList.addElement(entry);
396             }
397 
398             if (objectList.size() > 0)
399             {
400                 TKHashtable documentTypes = new TKHashtable();
401                 documentTypes.put("CONTEXT_NAME", "DOCUMENT_TYPE_COMPONENTS");
402                 documentTypes.put("OBJECT_LIST", objectList);
403                 documentTypes.put("OBJECT_TYPE", "DOCUMENT_TYPE_COMPONENT");
404 
405                 container.addElement(documentTypes);
406             }
407 
408             return container;
409         }
410         catch (Exception   e)
411         {
412             throw WebmanExceptionHandler.getException(e);
413         }
414     }
415 
416 }
417
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags