source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/core/TransformingReceptionist.java@ 27617

Last change on this file since 27617 was 27617, checked in by sjm84, 11 years ago

Various improvements and fixes mostly to do with adding depositor functionality
  • Property svn:keywords set to Author Date Id Revision
File size: 39.2 KB
Line 
1package org.greenstone.gsdl3.core;
2
3import java.io.File;
4import java.io.FileReader;
5import java.io.Serializable;
6import java.io.StringWriter;
7import java.util.ArrayList;
8import java.util.HashMap;
9
10import javax.xml.transform.Transformer;
11import javax.xml.transform.TransformerException;
12import javax.xml.transform.TransformerFactory;
13import javax.xml.transform.dom.DOMSource;
14import javax.xml.transform.stream.StreamResult;
15
16import org.apache.commons.lang3.StringUtils;
17import org.apache.log4j.Logger;
18import org.apache.xerces.parsers.DOMParser;
19import org.greenstone.gsdl3.action.Action;
20import org.greenstone.gsdl3.util.GSConstants;
21import org.greenstone.gsdl3.util.GSFile;
22import org.greenstone.gsdl3.util.GSParams;
23import org.greenstone.gsdl3.util.GSXML;
24import org.greenstone.gsdl3.util.GSXSLT;
25import org.greenstone.gsdl3.util.UserContext;
26import org.greenstone.gsdl3.util.XMLConverter;
27import org.greenstone.gsdl3.util.XMLTransformer;
28import org.greenstone.util.GlobalProperties;
29import org.w3c.dom.Comment;
30import org.w3c.dom.Document;
31import org.w3c.dom.Element;
32import org.w3c.dom.Node;
33import org.w3c.dom.NodeList;
34import org.w3c.dom.Text;
35import org.xml.sax.InputSource;
36
37/**
38 * A receptionist that uses xslt to transform the page_data before returning it.
39 * . Receives requests consisting of an xml representation of cgi args, and
40 * returns the page of data - in html by default. The requests are processed by
41 * the appropriate action class
42 *
43 * @see Action
44 */
45public class TransformingReceptionist extends Receptionist
46{
47 protected static final int CONFIG_PASS = 1;
48 protected static final int TEXT_PASS = 2;
49
50 static Logger logger = Logger.getLogger(org.greenstone.gsdl3.core.TransformingReceptionist.class.getName());
51
52 /** The preprocess.xsl file is in a fixed location */
53 static final String preprocess_xsl_filename = GlobalProperties.getGSDL3Home() + File.separatorChar + "interfaces" + File.separatorChar + "core" + File.separatorChar + "transform" + File.separatorChar + "preProcess.xsl";
54
55 /** the list of xslt to use for actions */
56 protected HashMap<String, String> xslt_map = null;
57
58 /** a transformer class to transform xml using xslt */
59 protected XMLTransformer transformer = null;
60
61 protected TransformerFactory transformerFactory = null;
62 protected DOMParser parser = null;
63
64 protected HashMap<String, ArrayList<String>> _metadataRequiredMap = new HashMap<String, ArrayList<String>>();
65
66 boolean _debug = true;
67
68 public TransformingReceptionist()
69 {
70 super();
71 this.xslt_map = new HashMap<String, String>();
72 this.transformer = new XMLTransformer();
73 try
74 {
75 transformerFactory = org.apache.xalan.processor.TransformerFactoryImpl.newInstance();
76 this.converter = new XMLConverter();
77 //transformerFactory.setURIResolver(new MyUriResolver()) ;
78
79 parser = new DOMParser();
80 parser.setFeature("http://xml.org/sax/features/validation", false);
81 // don't try and load external DTD - no need if we are not validating, and may cause connection errors if a proxy is not set up.
82 parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
83 // a performance test showed that having this on lead to increased
84 // memory use for small-medium docs, and not much gain for large
85 // docs.
86 // http://www.sosnoski.com/opensrc/xmlbench/conclusions.html
87 parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", false);
88 parser.setFeature("http://apache.org/xml/features/continue-after-fatal-error", true);
89 // setting a handler for when fatal errors, errors or warnings happen during xml parsing
90 // call XMLConverter's getParseErrorMessage() to get the errorstring that can be rendered as web page
91 this.parser.setErrorHandler(new XMLConverter.ParseErrorHandler());
92 }
93 catch (Exception e)
94 {
95 e.printStackTrace();
96 }
97 }
98
99 /** configures the receptionist - overwrite this to set up the xslt map */
100 public boolean configure()
101 {
102 if (this.config_params == null)
103 {
104 logger.error(" config variables must be set before calling configure");
105 return false;
106 }
107 if (this.mr == null)
108 {
109 logger.error(" message router must be set before calling configure");
110 return false;
111 }
112
113 // find the config file containing a list of actions
114 File interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.INTERFACE_NAME))));
115 if (!interface_config_file.exists())
116 {
117 logger.error(" interface config file: " + interface_config_file.getPath() + " not found!");
118 return false;
119 }
120 Document config_doc = this.converter.getDOM(interface_config_file, "utf-8");
121 if (config_doc == null)
122 {
123 logger.error(" could not parse interface config file: " + interface_config_file.getPath());
124 return false;
125 }
126 Element config_elem = config_doc.getDocumentElement();
127 String base_interface = config_elem.getAttribute("baseInterface");
128 setUpBaseInterface(base_interface);
129 setUpInterfaceOptions(config_elem);
130
131 Element action_list = (Element) GSXML.getChildByTagName(config_elem, GSXML.ACTION_ELEM + GSXML.LIST_MODIFIER);
132 NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM);
133
134 for (int i = 0; i < actions.getLength(); i++)
135 {
136 Element action = (Element) actions.item(i);
137 String class_name = action.getAttribute("class");
138 String action_name = action.getAttribute("name");
139 Action ac = null;
140 try
141 {
142 ac = (Action) Class.forName("org.greenstone.gsdl3.action." + class_name).newInstance();
143 }
144 catch (Exception e)
145 {
146 logger.error(" couldn't load in action " + class_name);
147 e.printStackTrace();
148 continue;
149 }
150 ac.setConfigParams(this.config_params);
151 ac.setMessageRouter(this.mr);
152 ac.configure();
153 ac.addActionParameters(this.params);
154 this.action_map.put(action_name, ac);
155
156 // now do the xslt map
157 String xslt = action.getAttribute("xslt");
158 if (!xslt.equals(""))
159 {
160 this.xslt_map.put(action_name, xslt);
161 }
162 NodeList subactions = action.getElementsByTagName(GSXML.SUBACTION_ELEM);
163 for (int j = 0; j < subactions.getLength(); j++)
164 {
165 Element subaction = (Element) subactions.item(j);
166 String subname = subaction.getAttribute(GSXML.NAME_ATT);
167 String subxslt = subaction.getAttribute("xslt");
168
169 String map_key = action_name + ":" + subname;
170 logger.debug("adding in to xslt map, " + map_key + "->" + subxslt);
171 this.xslt_map.put(map_key, subxslt);
172 }
173 }
174 Element lang_list = (Element) GSXML.getChildByTagName(config_elem, "languageList");
175 if (lang_list == null)
176 {
177 logger.error(" didn't find a language list in the config file!!");
178 }
179 else
180 {
181 this.language_list = (Element) this.doc.importNode(lang_list, true);
182 }
183
184 getRequiredMetadataNamesFromXSLFiles();
185
186 return true;
187 }
188
189 protected void getRequiredMetadataNamesFromXSLFiles()
190 {
191 ArrayList<File> xslFiles = GSFile.getAllXSLFiles((String) this.config_params.get(GSConstants.INTERFACE_NAME), (String) this.config_params.get(GSConstants.SITE_NAME));
192
193 HashMap<String, ArrayList<String>> includes = new HashMap<String, ArrayList<String>>();
194 HashMap<String, ArrayList<File>> files = new HashMap<String, ArrayList<File>>();
195 HashMap<String, ArrayList<String>> metaNames = new HashMap<String, ArrayList<String>>();
196
197 //First exploratory pass
198 for (File currentFile : xslFiles)
199 {
200 Document currentDoc = this.converter.getDOM(currentFile);
201 if (currentDoc == null)
202 {
203 // Can happen if an editor creates an auto-save temporary file
204 // (such as #header.xsl#) that is not well formed XML
205 continue;
206 }
207
208 NodeList metadataElems = currentDoc.getElementsByTagNameNS(GSXML.GSF_NAMESPACE, "metadata"); //gsf:metadata
209 NodeList foreachMetadataElems = currentDoc.getElementsByTagNameNS(GSXML.GSF_NAMESPACE, "foreach-metadata"); //gsf:foreach-metadata
210 NodeList imageElems = currentDoc.getElementsByTagNameNS(GSXML.GSF_NAMESPACE, "image"); //gsf:image
211 NodeList includeElems = currentDoc.getElementsByTagNameNS(GSXML.XSL_NAMESPACE, "include");
212 NodeList importElems = currentDoc.getElementsByTagNameNS(GSXML.XSL_NAMESPACE, "import");
213
214 ArrayList<String> names = new ArrayList<String>();
215 for (int i = 0; i < metadataElems.getLength(); i++)
216 {
217 Element current = (Element) metadataElems.item(i);
218 String name = current.getAttribute(GSXML.NAME_ATT);
219 if (name != null && name.length() > 0 && !names.contains(name))
220 {
221 names.add(name);
222 }
223 }
224
225 for (int i = 0; i < foreachMetadataElems.getLength(); i++)
226 {
227 Element current = (Element) foreachMetadataElems.item(i);
228 String name = current.getAttribute(GSXML.NAME_ATT);
229 if (name != null && name.length() > 0 && !names.contains(name))
230 {
231 names.add(name);
232 }
233 }
234
235 for (int i = 0; i < imageElems.getLength(); i++)
236 {
237 Element current = (Element) imageElems.item(i);
238 String type = current.getAttribute(GSXML.TYPE_ATT);
239 if (type == null || type.length() == 0)
240 {
241 continue;
242 }
243
244 if (type.equals("source"))
245 {
246 String[] standardSourceMeta = new String[] { "SourceFile", "ImageHeight", "ImageWidth", "ImageType", "srcicon" };
247 for (String meta : standardSourceMeta)
248 {
249 if (!names.contains(meta))
250 {
251 names.add(meta);
252 }
253 }
254 }
255 else if (type.equals("screen"))
256 {
257 String[] standardScreenMeta = new String[] { "Screen", "ScreenHeight", "ScreenWidth", "ScreenType", "screenicon" };
258 for (String meta : standardScreenMeta)
259 {
260 if (!names.contains(meta))
261 {
262 names.add(meta);
263 }
264 }
265 }
266 else if (type.equals("thumb"))
267 {
268 String[] standardThumbMeta = new String[] { "Thumb", "ThumbHeight", "ThumbWidth", "ThumbType", "thumbicon" };
269 for (String meta : standardThumbMeta)
270 {
271 if (!names.contains(meta))
272 {
273 names.add(meta);
274 }
275 }
276 }
277 }
278
279 metaNames.put(currentFile.getAbsolutePath(), names);
280
281 ArrayList<String> includeAndImportList = new ArrayList<String>();
282 for (int i = 0; i < includeElems.getLength(); i++)
283 {
284 includeAndImportList.add(((Element) includeElems.item(i)).getAttribute(GSXML.HREF_ATT));
285 }
286 for (int i = 0; i < importElems.getLength(); i++)
287 {
288 includeAndImportList.add(((Element) importElems.item(i)).getAttribute(GSXML.HREF_ATT));
289 }
290 includes.put(currentFile.getAbsolutePath(), includeAndImportList);
291
292 String filename = currentFile.getName();
293 if (files.get(filename) == null)
294 {
295 ArrayList<File> fileList = new ArrayList<File>();
296 fileList.add(currentFile);
297 files.put(currentFile.getName(), fileList);
298 }
299 else
300 {
301 ArrayList<File> fileList = files.get(filename);
302 fileList.add(currentFile);
303 }
304 }
305
306 //Second pass
307 for (File currentFile : xslFiles)
308 {
309 ArrayList<File> filesToGet = new ArrayList<File>();
310 filesToGet.add(currentFile);
311
312 ArrayList<String> fullNameList = new ArrayList<String>();
313
314 while (filesToGet.size() > 0)
315 {
316 File currentFileTemp = filesToGet.remove(0);
317
318 //Add the names from this file
319 ArrayList<String> currentNames = metaNames.get(currentFileTemp.getAbsolutePath());
320 if (currentNames == null)
321 {
322 continue;
323 }
324
325 fullNameList.addAll(currentNames);
326
327 ArrayList<String> includedHrefs = includes.get(currentFileTemp.getAbsolutePath());
328
329 for (String href : includedHrefs)
330 {
331 int lastSepIndex = href.lastIndexOf("/");
332 if (lastSepIndex != -1)
333 {
334 href = href.substring(lastSepIndex + 1);
335 }
336
337 ArrayList<File> filesToAdd = files.get(href);
338 if (filesToAdd != null)
339 {
340 filesToGet.addAll(filesToAdd);
341 }
342 }
343 }
344
345 _metadataRequiredMap.put(currentFile.getAbsolutePath(), fullNameList);
346 }
347 }
348
349 protected void preProcessRequest(Element request)
350 {
351 String action = request.getAttribute(GSXML.ACTION_ATT);
352 String subaction = request.getAttribute(GSXML.SUBACTION_ATT);
353
354 String name = null;
355 if (!subaction.equals(""))
356 {
357 String key = action + ":" + subaction;
358 name = this.xslt_map.get(key);
359 }
360 // try the action by itself
361 if (name == null)
362 {
363 name = this.xslt_map.get(action);
364 }
365
366 String stylesheetFile = GSFile.interfaceStylesheetFile(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.INTERFACE_NAME), name);
367 stylesheetFile = stylesheetFile.replace("/", File.separator);
368
369 ArrayList<String> requiredMetadata = _metadataRequiredMap.get(stylesheetFile);
370
371 if (requiredMetadata != null)
372 {
373 Element extraMetadataList = this.doc.createElement(GSXML.EXTRA_METADATA + GSXML.LIST_MODIFIER);
374
375 for (String metadataString : requiredMetadata)
376 {
377 Element metadataElem = this.doc.createElement(GSXML.EXTRA_METADATA);
378 metadataElem.setAttribute(GSXML.NAME_ATT, metadataString);
379 extraMetadataList.appendChild(metadataElem);
380 }
381 request.appendChild(request.getOwnerDocument().importNode(extraMetadataList, true));
382 }
383 }
384
385 protected Node postProcessPage(Element page)
386 {
387 // might need to add some data to the page
388 addExtraInfo(page);
389 // transform the page using xslt
390 Node transformed_page = transformPage(page);
391
392 // if the user has specified they want only a part of the full page then subdivide it
393 boolean subdivide = false;
394 String excerptID = null;
395 String excerptTag = null;
396 Element request = (Element) GSXML.getChildByTagName(page, GSXML.PAGE_REQUEST_ELEM);
397 Element cgi_param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
398 if (cgi_param_list != null)
399 {
400 HashMap<String, Serializable> params = GSXML.extractParams(cgi_param_list, false);
401 if ((excerptID = (String) params.get(GSParams.EXCERPT_ID)) != null)
402 {
403 subdivide = true;
404 }
405 if ((excerptTag = (String) params.get(GSParams.EXCERPT_TAG)) != null)
406 {
407 subdivide = true;
408 }
409 }
410
411 if (subdivide)
412 {
413 Node subdivided_page = subdivide(transformed_page, excerptID, excerptTag);
414 if (subdivided_page != null)
415 {
416 return subdivided_page;
417 }
418 }
419
420 return transformed_page;
421 }
422
423 protected Node subdivide(Node transformed_page, String excerptID, String excerptTag)
424 {
425 if (excerptID != null)
426 {
427 Node selectedElement = getNodeByIdRecursive(transformed_page, excerptID);
428 modifyNodesByTagRecursive(selectedElement, "a");
429 return selectedElement;
430 }
431 else if (excerptTag != null)
432 {
433 Node selectedElement = getNodeByTagRecursive(transformed_page, excerptTag);
434 return selectedElement;
435 }
436 return transformed_page;
437 }
438
439 protected Node getNodeByIdRecursive(Node parent, String id)
440 {
441 if (parent.hasAttributes() && ((Element) parent).getAttribute("id").equals(id))
442 {
443 return parent;
444 }
445
446 NodeList children = parent.getChildNodes();
447 for (int i = 0; i < children.getLength(); i++)
448 {
449 Node result = null;
450 if ((result = getNodeByIdRecursive(children.item(i), id)) != null)
451 {
452 return result;
453 }
454 }
455 return null;
456 }
457
458 protected Node getNodeByTagRecursive(Node parent, String tag)
459 {
460 if (parent.getNodeType() == Node.ELEMENT_NODE && ((Element) parent).getTagName().equals(tag))
461 {
462 return parent;
463 }
464
465 NodeList children = parent.getChildNodes();
466 for (int i = 0; i < children.getLength(); i++)
467 {
468 Node result = null;
469 if ((result = getNodeByTagRecursive(children.item(i), tag)) != null)
470 {
471 return result;
472 }
473 }
474 return null;
475 }
476
477 protected Node modifyNodesByTagRecursive(Node parent, String tag)
478 {
479 if (parent == null || (parent.getNodeType() == Node.ELEMENT_NODE && ((Element) parent).getTagName().equals(tag)))
480 {
481 return parent;
482 }
483
484 NodeList children = parent.getChildNodes();
485 for (int i = 0; i < children.getLength(); i++)
486 {
487 Node result = null;
488 if ((result = modifyNodesByTagRecursive(children.item(i), tag)) != null)
489 {
490 //TODO: DO SOMETHING HERE?
491 }
492 }
493 return null;
494 }
495
496 /**
497 * overwrite this to add any extra info that might be needed in the page
498 * before transformation
499 */
500 protected void addExtraInfo(Element page)
501 {
502 }
503
504 /**
505 * transform the page using xslt we need to get any format element out of
506 * the page and add it to the xslt before transforming
507 */
508 protected Node transformPage(Element page)
509 {
510 _debug = false;
511
512 boolean allowsClientXSLT = (Boolean) config_params.get(GSConstants.ALLOW_CLIENT_SIDE_XSLT);
513 //System.out.println("Client side transforms allowed? " + allowsClientXSLT);
514
515 String currentInterface = (String) config_params.get(GSConstants.INTERFACE_NAME);
516
517 Element request = (Element) GSXML.getChildByTagName(page, GSXML.PAGE_REQUEST_ELEM);
518 String output = request.getAttribute(GSXML.OUTPUT_ATT);
519
520 //System.out.println("Current output mode is: " + output + ", current interface name is: " + currentInterface);
521
522 if (allowsClientXSLT)
523 {
524 if (!currentInterface.endsWith(GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX) && output.equals("html"))
525 {
526 System.out.println("output is html and we are not currently using a client side version, switching");
527 // Switch the interface
528 config_params.put(GSConstants.INTERFACE_NAME, currentInterface.concat(GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX));
529 }
530 else if ((currentInterface.endsWith(GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX) && !output.equals("html")) || output.equals("server"))
531 {
532 // The reverse needs to happen too
533 config_params.put(GSConstants.INTERFACE_NAME, currentInterface.substring(0, currentInterface.length() - GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX.length()));
534 }
535 }
536 else if (currentInterface.endsWith(GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX))
537 {
538 config_params.put(GSConstants.INTERFACE_NAME, currentInterface.substring(0, currentInterface.length() - GSConstants.CLIENT_SIDE_XSLT_INTERFACE_SUFFIX.length()));
539 }
540
541 // DocType defaults in case the skin doesn't have an "xsl:output" element
542 String qualifiedName = "html";
543 String publicID = "-//W3C//DTD HTML 4.01 Transitional//EN";
544 String systemID = "http://www.w3.org/TR/html4/loose.dtd";
545
546 // We need to create an empty document with a predefined DocType,
547 // that will then be used for the transformation by the DOMResult
548 Document docWithDoctype = converter.newDOM(qualifiedName, publicID, systemID);
549
550 if (output.equals("xsltclient"))
551 {
552 // If you're just getting the client-side transform page, why bother with the rest of this?
553 Element html = docWithDoctype.createElement("html");
554 Element img = docWithDoctype.createElement("img");
555 img.setAttribute("src", "interfaces/default/images/loading.gif"); // Make it dynamic
556 img.setAttribute("alt", "Please wait...");
557 Text title_text = docWithDoctype.createTextNode("Please wait..."); // Make this language dependent
558 Element head = docWithDoctype.createElement("head");
559 Element title = docWithDoctype.createElement("title");
560 title.appendChild(title_text);
561 Element body = docWithDoctype.createElement("body");
562 Element script = docWithDoctype.createElement("script");
563 Element jquery = docWithDoctype.createElement("script");
564 jquery.setAttribute("src", "jquery.js");
565 jquery.setAttribute("type", "text/javascript");
566 Comment jquery_comment = docWithDoctype.createComment("jQuery");
567 Comment script_comment = docWithDoctype.createComment("Filler for browser");
568 script.setAttribute("src", "test.js");
569 script.setAttribute("type", "text/javascript");
570 Element pagevar = docWithDoctype.createElement("script");
571 Element style = docWithDoctype.createElement("style");
572 style.setAttribute("type", "text/css");
573 Text style_text = docWithDoctype.createTextNode("body { text-align: center; padding: 50px; font: 14pt Arial, sans-serif; font-weight: bold; }");
574 pagevar.setAttribute("type", "text/javascript");
575 Text page_var_text = docWithDoctype.createTextNode("var placeholder = true;");
576
577 html.appendChild(head);
578 head.appendChild(title);
579 head.appendChild(style);
580 style.appendChild(style_text);
581 html.appendChild(body);
582 head.appendChild(pagevar);
583 head.appendChild(jquery);
584 head.appendChild(script);
585 pagevar.appendChild(page_var_text);
586 jquery.appendChild(jquery_comment);
587 script.appendChild(script_comment);
588 body.appendChild(img);
589 docWithDoctype.appendChild(html);
590
591 return (Node) docWithDoctype;
592 }
593
594 // Passing in the pretty string here means it needs to be generated even when not debugging; so use custom function to return blank when debug is off
595 logger.debug("page before transforming:");
596 logger.debug(this.converter.getPrettyStringLogger(page, logger));
597
598 String action = request.getAttribute(GSXML.ACTION_ATT);
599 String subaction = request.getAttribute(GSXML.SUBACTION_ATT);
600
601 // we should choose how to transform the data based on output, eg diff
602 // choice for html, and wml??
603 // for now, if output=xml, we don't transform the page, we just return
604 // the page xml
605 Document theXML = null;
606
607 if (output.equals("xml") || (output.equals("json")) || output.equals("clientside"))
608 {
609 // Append some bits and pieces first...
610 theXML = converter.newDOM();
611 // Import into new document first!
612 Node newPage = theXML.importNode(page, true);
613 theXML.appendChild(newPage);
614 Element root = theXML.createElement("xsltparams");
615 newPage.appendChild(root);
616
617 Element libname = theXML.createElement("param");
618 libname.setAttribute("name", "library_name");
619 Text libnametext = theXML.createTextNode((String) config_params.get(GSConstants.LIBRARY_NAME));
620 libname.appendChild(libnametext);
621
622 Element intname = theXML.createElement("param");
623 intname.setAttribute("name", "interface_name");
624 Text intnametext = theXML.createTextNode((String) config_params.get(GSConstants.INTERFACE_NAME));
625 intname.appendChild(intnametext);
626
627 Element siteName = theXML.createElement("param");
628 siteName.setAttribute("name", "site_name");
629 Text siteNameText = theXML.createTextNode((String) config_params.get(GSConstants.SITE_NAME));
630 siteName.appendChild(siteNameText);
631
632 Element filepath = theXML.createElement("param");
633 filepath.setAttribute("name", "filepath");
634 Text filepathtext = theXML.createTextNode(GlobalProperties.getGSDL3Home());
635 filepath.appendChild(filepathtext);
636
637 root.appendChild(libname);
638 root.appendChild(intname);
639 root.appendChild(siteName);
640 root.appendChild(filepath);
641
642 if ((output.equals("xml")) || output.equals("json"))
643 {
644 // in the case of "json", calling method responsible for converting to JSON-string
645 return theXML.getDocumentElement();
646 }
647 }
648
649 Element cgi_param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
650 String collection = "";
651 String inlineTemplate = "";
652 if (cgi_param_list != null)
653 {
654 // Don't waste time getting all the parameters
655 HashMap<String, Serializable> params = GSXML.extractParams(cgi_param_list, false);
656 collection = (String) params.get(GSParams.COLLECTION);
657 if (collection == null)
658 {
659 collection = "";
660 }
661
662 inlineTemplate = (String) params.get(GSParams.INLINE_TEMPLATE);
663
664 if (params.get(GSParams.DEBUG) != null && (((String) params.get(GSParams.DEBUG)).equals("on") || ((String) params.get(GSParams.DEBUG)).equals("1") || ((String) params.get(GSParams.DEBUG)).equals("true")))
665 {
666 String[] groups = new UserContext(request).getGroups();
667
668 boolean found = false;
669 for (String g : groups)
670 {
671 if (g.equals("administrator"))
672 {
673 found = true;
674 }
675 }
676 if (found)
677 {
678 _debug = true;
679 }
680 }
681 }
682
683 config_params.put("collName", collection);
684
685 Document style_doc = getXSLTDocument(action, subaction, collection);
686 if (style_doc == null)
687 {
688 String errorPage = this.converter.getParseErrorMessage();
689 if (errorPage != null)
690 {
691 return XMLTransformer.constructErrorXHTMLPage("Cannot parse the xslt file\n" + errorPage);
692 }
693 return page;
694 }
695
696 // put the page into a document - this is necessary for xslt to get
697 // the paths right if you have paths relative to the document root
698 // eg /page.
699 Document doc = this.converter.newDOM();
700 doc.appendChild(doc.importNode(page, true));
701 Element page_response = (Element) GSXML.getChildByTagName(page, GSXML.PAGE_RESPONSE_ELEM);
702 Element format_elem = (Element) GSXML.getChildByTagName(page_response, GSXML.FORMAT_ELEM);
703
704 NodeList pageElems = doc.getElementsByTagName("page");
705 if (pageElems.getLength() > 0)
706 {
707 Element pageElem = (Element) pageElems.item(0);
708 String langAtt = pageElem.getAttribute(GSXML.LANG_ATT);
709
710 if (langAtt != null && langAtt.length() > 0)
711 {
712 config_params.put("lang", langAtt);
713 }
714 }
715
716 if (output.equals("formatelem"))
717 {
718 return format_elem;
719 }
720 if (format_elem != null)
721 {
722 //page_response.removeChild(format_elem);
723 logger.debug("format elem=" + this.converter.getPrettyStringLogger(format_elem, logger));
724 // need to transform the format info
725 String configStylesheet_file = GSFile.stylesheetFile(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces, "config_format.xsl");
726 Document configStylesheet_doc = this.converter.getDOM(new File(configStylesheet_file));
727
728 if (configStylesheet_doc != null)
729 {
730 Document format_doc = this.converter.newDOM();
731 format_doc.appendChild(format_doc.importNode(format_elem, true));
732
733 if (_debug)
734 {
735 String siteHome = GSFile.siteHome(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME));
736 GSXSLT.insertDebugElements(format_doc, GSFile.collectionConfigFile(siteHome, collection));
737 }
738
739 Node result = this.transformer.transform(configStylesheet_doc, format_doc, config_params); // Needs addressing <-
740
741 // Since we started creating documents with DocTypes, we can end up with
742 // Document objects here. But we will be working with an Element instead,
743 // so we grab the DocumentElement() of the Document object in such a case.
744 Element new_format;
745 if (result.getNodeType() == Node.DOCUMENT_NODE)
746 {
747 new_format = ((Document) result).getDocumentElement();
748 }
749 else
750 {
751 new_format = (Element) result;
752 }
753 logger.debug("new format elem=" + this.converter.getPrettyStringLogger(new_format, logger));
754 if (output.equals("newformat"))
755 {
756 return new_format;
757 }
758
759 // add extracted GSF statements in to the main stylesheet
760 if (_debug)
761 {
762 String siteHome = GSFile.siteHome(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME));
763 GSXSLT.mergeStylesheetsDebug(style_doc, new_format, true, true, "OTHER1", GSFile.collectionConfigFile(siteHome, collection));
764 }
765 else
766 {
767 GSXSLT.mergeStylesheets(style_doc, new_format, true);
768 }
769 //System.out.println("added extracted GSF statements into the main stylesheet") ;
770
771 // add extracted GSF statements in to the debug test stylesheet
772 //GSXSLT.mergeStylesheets(oldStyle_doc, new_format);
773 }
774 else
775 {
776 logger.error(" couldn't parse the config_format stylesheet, adding the format info as is");
777 GSXSLT.mergeStylesheets(style_doc, format_elem, true);
778 //GSXSLT.mergeStylesheets(oldStyle_doc, format_elem);
779 }
780 logger.debug("the converted stylesheet is:");
781 logger.debug(this.converter.getPrettyStringLogger(style_doc.getDocumentElement(), logger));
782 }
783
784 //for debug purposes only
785 Document oldStyle_doc = style_doc;
786 Document preprocessingXsl;
787 try
788 {
789 preprocessingXsl = getDoc(preprocess_xsl_filename);
790 String errMsg = ((XMLConverter.ParseErrorHandler) parser.getErrorHandler()).getErrorMessage();
791 if (errMsg != null)
792 {
793 return XMLTransformer.constructErrorXHTMLPage("error loading preprocess xslt file: " + preprocess_xsl_filename + "\n" + errMsg);
794 }
795 }
796 catch (java.io.FileNotFoundException e)
797 {
798 return fileNotFoundErrorPage(e.getMessage());
799 }
800 catch (Exception e)
801 {
802 e.printStackTrace();
803 System.out.println("error loading preprocess xslt");
804 return XMLTransformer.constructErrorXHTMLPage("error loading preprocess xslt\n" + e.getMessage());
805 }
806
807 Document libraryXsl = null;
808 try
809 {
810 String gsLibFile = this.getGSLibXSLFilename();
811 if (new File(gsLibFile).exists())
812 {
813 libraryXsl = getDoc(gsLibFile);
814 String errMsg = ((XMLConverter.ParseErrorHandler) parser.getErrorHandler()).getErrorMessage();
815 if (errMsg != null)
816 {
817 return XMLTransformer.constructErrorXHTMLPage("Error loading xslt file: " + this.getGSLibXSLFilename() + "\n" + errMsg);
818 }
819 }
820 }
821 catch (java.io.FileNotFoundException e)
822 {
823 return fileNotFoundErrorPage(e.getMessage());
824 }
825 catch (Exception e)
826 {
827 e.printStackTrace();
828 System.out.println("error loading gslib xslt");
829 return XMLTransformer.constructErrorXHTMLPage("error loading gslib xslt\n" + e.getMessage());
830 }
831
832 // Combine the skin file and library variables/templates into one document.
833 // Please note: We dont just use xsl:import because the preprocessing stage
834 // needs to know what's available in the library.
835
836 Document skinAndLibraryXsl = null;
837 Document skinAndLibraryDoc = converter.newDOM();
838
839 // Applying the preprocessing XSLT - in its own block {} to allow use of non-unique variable names
840 {
841
842 skinAndLibraryXsl = converter.newDOM();
843 Element root = skinAndLibraryXsl.createElement("skinAndLibraryXsl");
844 skinAndLibraryXsl.appendChild(root);
845
846 Element s = skinAndLibraryXsl.createElement("skinXsl");
847 s.appendChild(skinAndLibraryXsl.importNode(style_doc.getDocumentElement(), true));
848 root.appendChild(s);
849
850 Element l = skinAndLibraryXsl.createElement("libraryXsl");
851 if (libraryXsl != null)
852 {
853 Element libraryXsl_el = libraryXsl.getDocumentElement();
854 l.appendChild(skinAndLibraryXsl.importNode(libraryXsl_el, true));
855 }
856 root.appendChild(l);
857
858 //System.out.println("Skin and Library XSL are now together") ;
859
860 //System.out.println("Pre-processing the skin file...") ;
861
862 //pre-process the skin style sheet
863 //In other words, apply the preProcess.xsl to 'skinAndLibraryXsl' in order to
864 //expand all GS-Lib statements into complete XSL statements and also to create
865 //a valid xsl style sheet document.
866
867 XMLTransformer preProcessor = new XMLTransformer();
868 // Perform the transformation, by passing in:
869 // preprocess-stylesheet, source-xsl (skinAndLibraryXsl), and the node that should
870 // be in the result (skinAndLibraryDoc)
871 preProcessor.transform_withResultNode(preprocessingXsl, skinAndLibraryXsl, skinAndLibraryDoc);
872 //System.out.println("GS-Lib statements are now expanded") ;
873 }
874
875 // there is a thing called a URIResolver which you can set for a
876 // transformer or transformer factory. may be able to use this
877 // instead of this absoluteIncludepaths hack
878
879 //GSXSLT.absoluteIncludePaths(skinAndLibraryDoc, GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces);
880
881 //Same but for the debug version when we want the do the transformation like we use to do
882 //without any gslib elements.
883 GSXSLT.absoluteIncludePaths(oldStyle_doc, GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces);
884
885 //Send different stages of the skin xslt to the browser for debug purposes only
886 //using &o=skindoc or &o=skinandlib etc...
887 if (output.equals("skindoc"))
888 {
889 return converter.getDOM(getStringFromDocument(style_doc));
890 }
891 if (output.equals("skinandlib"))
892 {
893 return converter.getDOM(getStringFromDocument(skinAndLibraryXsl));
894 }
895 if (output.equals("skinandlibdoc") || output.equals("clientside"))
896 {
897
898 Node skinAndLib = converter.getDOM(getStringFromDocument(skinAndLibraryDoc));
899
900 if (output.equals("skinandlibdoc"))
901 {
902 return skinAndLib;
903 }
904 else
905 {
906 // Send XML and skinandlibdoc down the line together
907 Document finalDoc = converter.newDOM();
908 Node finalDocSkin = finalDoc.importNode(skinAndLibraryDoc.getDocumentElement(), true);
909 Node finalDocXML = finalDoc.importNode(theXML.getDocumentElement(), true);
910 Element root = finalDoc.createElement("skinlibPlusXML");
911 root.appendChild(finalDocSkin);
912 root.appendChild(finalDocXML);
913 finalDoc.appendChild(root);
914 return (Node) finalDoc.getDocumentElement();
915 }
916 }
917 if (output.equals("oldskindoc"))
918 {
919 return converter.getDOM(getStringFromDocument(oldStyle_doc));
920 }
921
922 // We now no longer create a document with doctype before the transformation
923 // We let the XMLTransformer do the work of first working out the doctype from any
924 // that may be set in the (merged) stylesheets and then setting the doctype when transforming
925
926 /*
927 // Try to get the system and public ID from the current skin xsl document
928 // otherwise keep the default values.
929 Element root = skinAndLibraryDoc.getDocumentElement();
930 NodeList nodes = root.getElementsByTagName("xsl:output");
931 // If there is at least one "xsl:output" command in the final xsl then...
932 if (nodes.getLength() != 0)
933 {
934 // There should be only one element called xsl:output,
935 // but if this is not the case get the last one
936 Element xsl_output = (Element) nodes.item(nodes.getLength() - 1);
937 if (xsl_output != null)
938 {
939 // Qualified name will always be html even for xhtml pages
940 //String attrValue = xsl_output.getAttribute("method");
941 //qualifiedName = attrValue.equals("") ? qualifiedName : attrValue;
942
943 String attrValue = xsl_output.getAttribute("doctype-system");
944 systemID = attrValue.equals("") ? systemID : attrValue;
945
946 attrValue = xsl_output.getAttribute("doctype-public");
947 publicID = attrValue.equals("") ? publicID : attrValue;
948 }
949 }
950
951 //System.out.println(converter.getPrettyString(docWithDoctype));
952 //System.out.println("Doctype vals: " + qualifiedName + " " + publicID + " " + systemID) ;
953
954 docWithDoctype = converter.newDOM(qualifiedName, publicID, systemID);
955 */
956
957 //System.out.println("Generate final HTML from current skin") ;
958 //Transformation of the XML message from the receptionist to HTML with doctype
959
960 if (inlineTemplate != null)
961 {
962 try
963 {
964 Document inlineTemplateDoc = this.converter.getDOM("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"" + GSXML.XSL_NAMESPACE + "\" xmlns:java=\"" + GSXML.JAVA_NAMESPACE + "\" xmlns:util=\"" + GSXML.UTIL_NAMESPACE + "\" xmlns:gsf=\"" + GSXML.GSF_NAMESPACE + "\">" + inlineTemplate + "</xsl:stylesheet>", "UTF-8");
965
966 if (_debug)
967 {
968 GSXSLT.mergeStylesheetsDebug(skinAndLibraryDoc, inlineTemplateDoc.getDocumentElement(), true, true, "OTHER2", "INLINE");
969 }
970 else
971 {
972 GSXSLT.mergeStylesheets(skinAndLibraryDoc, inlineTemplateDoc.getDocumentElement(), true);
973 }
974 }
975 catch (Exception ex)
976 {
977 ex.printStackTrace();
978 }
979 }
980
981 if (_debug)
982 {
983 GSXSLT.inlineImportAndIncludeFilesDebug(skinAndLibraryDoc, null, _debug, this.getGSLibXSLFilename(), (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces);
984 }
985 else
986 {
987 GSXSLT.inlineImportAndIncludeFiles(skinAndLibraryDoc, null, (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces);
988 }
989 skinAndLibraryDoc = (Document) performFormatPass(collection, skinAndLibraryDoc, doc, new UserContext(request), TEXT_PASS);
990 skinAndLibraryDoc = (Document) performFormatPass(collection, skinAndLibraryDoc, doc, new UserContext(request), CONFIG_PASS);
991
992 if (output.equals("xmlfinal"))
993 {
994 return doc;
995 }
996
997 if (output.equals("skinandlibdocfinal"))
998 {
999 return converter.getDOM(getStringFromDocument(skinAndLibraryDoc));
1000 }
1001
1002 // The transformer will now work out the resulting doctype from any set in the (merged) stylesheets and
1003 // will set this in the output document it creates. So don't pass in any docWithDocType to the transformer
1004 //Node finalResult = this.transformer.transform(skinAndLibraryDoc, doc, config_params, docWithDoctype);
1005 Node finalResult = this.transformer.transform(skinAndLibraryDoc, doc, config_params);
1006
1007 if (_debug)
1008 {
1009 GSXSLT.fixTables((Document) finalResult);
1010 }
1011
1012 return finalResult;
1013
1014 // The line below will do the transformation like we use to do before having Skin++ implemented,
1015 // it will not contain any GS-Lib statements expanded, and the result will not contain any doctype.
1016
1017 //return (Element)this.transformer.transform(style_doc, doc, config_params);
1018 //return null; // For now - change later
1019 }
1020
1021 protected Node performFormatPass(String collection, Document skinAndLibraryDoc, Document doc, UserContext userContext, int pass)
1022 {
1023 String formatFile;
1024 if (pass == CONFIG_PASS)
1025 {
1026 formatFile = "config_format.xsl";
1027 }
1028 else
1029 {
1030 formatFile = "text_fragment_format.xsl";
1031 }
1032 String configStylesheet_file = GSFile.stylesheetFile(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces, formatFile);
1033 Document configStylesheet_doc = this.converter.getDOM(new File(configStylesheet_file));
1034
1035 if (configStylesheet_doc != null)
1036 {
1037 return this.transformer.transform(configStylesheet_doc, skinAndLibraryDoc, config_params);
1038 }
1039 return skinAndLibraryDoc;
1040 }
1041
1042 // method to convert Document to a proper XML string for debug purposes only
1043 protected String getStringFromDocument(Document doc)
1044 {
1045 String content = "";
1046 try
1047 {
1048 DOMSource domSource = new DOMSource(doc);
1049 StringWriter writer = new StringWriter();
1050 StreamResult result = new StreamResult(writer);
1051 TransformerFactory tf = TransformerFactory.newInstance();
1052 Transformer transformer = tf.newTransformer();
1053 transformer.transform(domSource, result);
1054 content = writer.toString();
1055 System.out.println("Change the & to &Amp; for proper debug display");
1056 content = StringUtils.replace(content, "&", "&amp;");
1057 writer.flush();
1058 }
1059 catch (TransformerException ex)
1060 {
1061 ex.printStackTrace();
1062 return null;
1063 }
1064 return content;
1065 }
1066
1067 protected synchronized Document getDoc(String docName) throws Exception
1068 {
1069 File xslt_file = new File(docName);
1070
1071 FileReader reader = new FileReader(xslt_file);
1072 InputSource xml_source = new InputSource(reader);
1073 this.parser.parse(xml_source);
1074 Document doc = this.parser.getDocument();
1075
1076 return doc;
1077 }
1078
1079 protected Document getXSLTDocument(String action, String subaction, String collection)
1080 {
1081 String name = null;
1082 if (!subaction.equals(""))
1083 {
1084 String key = action + ":" + subaction;
1085 name = this.xslt_map.get(key);
1086 }
1087 // try the action by itself
1088 if (name == null)
1089 {
1090 name = this.xslt_map.get(action);
1091 }
1092 if (name == null)
1093 {
1094 // so we can reandomly create any named page
1095 if (action.equals("p") && !subaction.equals(""))
1096 {
1097 // TODO: pages/ won't work for interface other than default!!
1098 name = "pages/" + subaction + ".xsl";
1099 }
1100
1101 }
1102 Document finalDoc = GSXSLT.mergedXSLTDocumentCascade(name, (String) this.config_params.get(GSConstants.SITE_NAME), collection, (String) this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces, _debug);
1103 return finalDoc;
1104 }
1105
1106 // returns the path to the gslib.xsl file that is applicable for the current interface
1107 protected String getGSLibXSLFilename()
1108 {
1109 return GSFile.xmlTransformDir(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.INTERFACE_NAME))) + File.separatorChar + "gslib.xsl";
1110 }
1111
1112 // Call this when a FileNotFoundException could be thrown when loading an xsl (xml) file.
1113 // Returns an error xhtml page indicating which xsl (or other xml) file is missing.
1114 protected Document fileNotFoundErrorPage(String filenameMessage)
1115 {
1116 String errorMessage = "ERROR missing file: " + filenameMessage;
1117 Element errPage = XMLTransformer.constructErrorXHTMLPage(errorMessage);
1118 logger.error(errorMessage);
1119 return errPage.getOwnerDocument();
1120 }
1121}
Note: See TracBrowser for help on using the repository browser.