source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/collection/Collection.java@ 30838

Last change on this file since 30838 was 30838, checked in by kjdon, 8 years ago

use CustomClassLoader instead of CollectionClassLoader. Also don't need to override getTextString as that is now handled by DisplayItemUtil
  • Property svn:keywords set to Author Date Id Revision
File size: 27.7 KB
Line 
1/*
2 * Collection.java
3 * Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19package org.greenstone.gsdl3.collection;
20
21import java.io.BufferedReader;
22import java.io.BufferedWriter;
23import java.io.File;
24import java.io.FileReader;
25import java.io.FileWriter;
26import java.io.IOException;
27import java.io.PrintWriter;
28import java.io.StringWriter;
29import java.util.ArrayList;
30import java.util.HashMap;
31
32import org.apache.commons.lang3.StringUtils;
33import org.apache.log4j.Logger;
34import org.greenstone.gsdl3.core.ModuleInterface;
35import org.greenstone.gsdl3.util.CustomClassLoader;
36import org.greenstone.gsdl3.util.Dictionary;
37import org.greenstone.gsdl3.util.GSFile;
38import org.greenstone.gsdl3.util.GSXML;
39import org.greenstone.gsdl3.util.GSXSLT;
40import org.greenstone.gsdl3.util.OAIXML;
41import org.greenstone.gsdl3.util.SimpleMacroResolver;
42import org.greenstone.gsdl3.util.UserContext;
43import org.greenstone.gsdl3.util.XMLConverter;
44import org.greenstone.gsdl3.util.XMLTransformer;
45import org.w3c.dom.Document;
46import org.w3c.dom.Element;
47import org.w3c.dom.Node;
48import org.w3c.dom.NodeList;
49
50/**
51 * Represents a collection in Greenstone. A collection is an extension of a
52 * ServiceCluster - it has local data that the services use.
53 *
54 * @author Katherine Don
55 * @see ModuleInterface
56 */
57public class Collection extends ServiceCluster
58{
59
60 static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.Collection.class.getName());
61
62 /** is this collection being tidied and therefore can support realistic book view? */
63 protected boolean useBook = false;
64 /**
65 * is this collection public or private - public collections will
66 * appear on the home page, whereas private collections won't
67 */
68 protected boolean is_public = true;
69 /** collection type : mg, mgpp or lucene */
70 protected String col_type = "";
71 /** database type : gdbm, jdbm or sqlite */
72 protected String db_type = "";
73 /** time when this collection was built Used by RSS */
74 protected long lastmodified = 0;
75 /** earliestDatestamp of this collection. Used by OAI/RSS */
76 protected long earliestDatestamp = 0;
77
78 /** Stores the default accessibility of guest users */
79 protected boolean _publicAccess = true;
80 /** Stores the scope of any security rules (either collection or document) */
81 protected boolean _securityScopeCollection = true;
82
83 protected HashMap<String, ArrayList<Element>> _documentSets = new HashMap<String, ArrayList<Element>>();
84 protected ArrayList<HashMap<String, ArrayList<String>>> _securityExceptions = new ArrayList<HashMap<String, ArrayList<String>>>();
85
86 protected XMLTransformer transformer = null;
87 /**
88 * A class loader that knows about the collection resources directory can
89 * put properties files, dtds etc in here
90 */
91 //CustomClassLoader class_loader = null;
92
93 /** same as setClusterName */
94 public void setCollectionName(String name)
95 {
96 setClusterName(name);
97 }
98
99 public Collection()
100 {
101 super();
102 this.description = this.desc_doc.createElement(GSXML.COLLECTION_ELEM);
103 }
104
105 /**
106 * Configures the collection.
107 *
108 * gsdlHome and collectionName must be set before configure is called.
109 *
110 * the file buildcfg.xml is located in gsdlHome/collect/collectionName
111 * collection metadata is obtained, and services loaded.
112 *
113 * @return true/false on success/fail
114 */
115 public boolean configure()
116 {
117 if (this.site_home == null || this.cluster_name == null)
118 {
119 logger.error("Collection: site_home and collection_name must be set before configure called!");
120 return false;
121 }
122 // set up the class loader
123 this.class_loader = new CustomClassLoader(this.getClass().getClassLoader(), GSFile.collectionResourceDir(this.site_home, this.cluster_name));
124
125 macro_resolver.addMacro("_httpcollection_", this.site_http_address + "/collect/" + this.cluster_name);
126
127 Element coll_config_xml = loadCollConfigFile();
128 if (coll_config_xml == null) {
129 logger.error("Collection: couldn't configure collection: " + this.cluster_name + ", " + "Couldn't load collection config file");
130
131 return false;
132 }
133 Element build_config_xml = loadBuildConfigFile();
134
135 if (build_config_xml == null)
136 {
137 logger.error("Collection: couldn't configure collection: " + this.cluster_name + ", " + "Couldn't load build config file");
138
139 return false;
140 }
141
142 GSXSLT.modifyCollectionConfigForDebug(coll_config_xml);
143 // get the collection type attribute
144 Element search = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.SEARCH_ELEM);
145 if (search != null)
146 {
147 col_type = search.getAttribute(GSXML.TYPE_ATT);
148 }
149
150 Element browse = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.INFODB_ELEM);
151 if (browse != null)
152 {
153 db_type = browse.getAttribute(GSXML.TYPE_ATT);
154 }
155 else
156 {
157 db_type = "gdbm"; //Default database type
158 }
159
160 this.description.setAttribute(GSXML.TYPE_ATT, col_type);
161 this.description.setAttribute(GSXML.DB_TYPE_ATT, db_type);
162
163 _globalFormat = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.FORMAT_ELEM);
164 // process the metadata and display items and default library params
165 super.configureLocalData(coll_config_xml);
166 super.configureLocalData(build_config_xml);
167 // get extra collection specific stuff
168 findAndLoadInfo(coll_config_xml, build_config_xml);
169
170 loadSecurityInformation(coll_config_xml);
171
172 // now do the services
173 configureServiceRacks(coll_config_xml, build_config_xml);
174
175 return true;
176
177 }
178
179 public boolean useBook()
180 {
181 return useBook;
182 }
183
184 public boolean isPublic()
185 {
186 return is_public;
187 }
188
189 // Used by OAI Receptionist and RSSRetrieve
190 public long getLastmodified()
191 {
192 return lastmodified;
193 }
194
195 // used by the OAIReceptionist and RSSRetrieve
196 public long getEarliestDatestamp()
197 {
198 return earliestDatestamp;
199 }
200
201 /**
202 * load in the collection config file into a DOM Element
203 */
204 protected Element loadCollConfigFile()
205 {
206
207 File coll_config_file = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name));
208
209 if (!coll_config_file.exists())
210 {
211 return null;
212 }
213 // get the xml
214 Document coll_config_doc = this.converter.getDOM(coll_config_file, CONFIG_ENCODING);
215 Element coll_config_elem = null;
216 if (coll_config_doc != null)
217 {
218 coll_config_elem = coll_config_doc.getDocumentElement();
219 }
220 return coll_config_elem;
221
222 }
223
224 /**
225 * load in the collection build config file into a DOM Element
226 */
227 protected Element loadBuildConfigFile()
228 {
229 File build_config_file = new File(GSFile.collectionBuildConfigFile(this.site_home, this.cluster_name));
230 if (!build_config_file.exists())
231 {
232 logger.error("Collection: couldn't configure collection: " + this.cluster_name + ", " + build_config_file + " does not exist");
233 return null;
234 }
235 Document build_config_doc = this.converter.getDOM(build_config_file, CONFIG_ENCODING);
236 Element build_config_elem = null;
237 if (build_config_doc != null)
238 {
239 build_config_elem = build_config_doc.getDocumentElement();
240 }
241
242 lastmodified = build_config_file.lastModified();
243
244 return build_config_elem;
245 }
246
247 /**
248 * find the metadata and display elems from the two config files and add it
249 * to the appropriate lists
250 */
251 protected boolean findAndLoadInfo(Element coll_config_xml, Element build_config_xml)
252 {
253 addMetadata("httpPath", this.site_http_address + "/collect/" + this.cluster_name);
254
255
256 //check whether the html are tidy or not
257 Element import_list = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.IMPORT_ELEM);
258 if (import_list != null)
259 {
260 Element plugin_list = (Element) GSXML.getChildByTagName(import_list, GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER);
261 //addPlugins(plugin_list);
262 if (plugin_list != null)
263 {
264 Element plugin_elem = (Element) GSXML.getNamedElement(plugin_list, GSXML.PLUGIN_ELEM, GSXML.NAME_ATT, "HTMLPlugin");
265 if (plugin_elem != null)
266 {
267 //get the option
268 Element option_elem = (Element) GSXML.getNamedElement(plugin_elem, GSXML.PARAM_OPTION_ELEM, GSXML.NAME_ATT, "-use_realistic_book");
269 if (option_elem != null)
270 {
271 useBook = true;
272 }
273 }
274 }
275 }
276 String tidy = (useBook == true ? "tidy" : "untidy");
277 addMetadata("tidyoption", tidy);
278
279
280 if (this.metadata_list != null)
281 {
282 // check whether we are public or not
283 Element meta_elem = (Element) GSXML.getNamedElement(this.metadata_list, GSXML.METADATA_ELEM, GSXML.NAME_ATT, "public");
284 if (meta_elem != null)
285 {
286 String value = GSXML.getValue(meta_elem).toLowerCase().trim();
287 if (value.equals("false"))
288 {
289 is_public = false;
290 }
291 }
292 // earliest datestamp is the time the collection was created.
293 meta_elem = (Element) GSXML.getNamedElement(this.metadata_list, GSXML.METADATA_ELEM, GSXML.NAME_ATT, OAIXML.EARLIEST_DATESTAMP);
294 if (meta_elem != null) {
295 String earliestDatestampStr = GSXML.getValue(meta_elem);
296 if (!earliestDatestampStr.equals("")) {
297 earliestDatestamp = Long.parseLong(earliestDatestampStr) * 1000; // stored in seconds, convert to milliseconds
298 }
299 }
300
301 }
302 return true;
303 }
304
305 protected void loadSecurityInformation(Element coll_config_xml)
306 {
307 Element securityBlock = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.SECURITY_ELEM);
308
309 if (securityBlock == null)
310 {
311 return;
312 }
313
314 String disabled = securityBlock.getAttribute(GSXML.DISABLED_ATT);
315 if (!disabled.equals("")) {
316 // security block has been disabled.
317 logger.warn("Security block has been disabled. Not implementing any security for collection "+this.cluster_name);
318 return;
319 }
320 String scope = securityBlock.getAttribute(GSXML.SCOPE_ATT);
321 String defaultAccess = securityBlock.getAttribute(GSXML.DEFAULT_ACCESS_ATT);
322
323 if (defaultAccess.toLowerCase().equals("public"))
324 {
325 _publicAccess = true;
326 }
327 else if (defaultAccess.toLowerCase().equals("private"))
328 {
329 _publicAccess = false;
330 }
331 else
332 {
333 logger.warn("Default access for collection " + this.cluster_name + " is neither public or private, assuming public");
334 }
335
336 if (scope.toLowerCase().equals("collection"))
337 {
338 _securityScopeCollection = true;
339 }
340 else if (scope.toLowerCase().equals("documents") || scope.toLowerCase().equals("document"))
341 {
342 _securityScopeCollection = false;
343 }
344 else
345 {
346 logger.warn("Security scope is neither collection or document, assuming collection");
347 }
348
349 NodeList exceptions = GSXML.getChildrenByTagName(securityBlock, GSXML.EXCEPTION_ELEM);
350
351 if (exceptions.getLength() > 0)
352 {
353 if (!_securityScopeCollection)
354 {
355 NodeList documentSetElems = GSXML.getChildrenByTagName(securityBlock, GSXML.DOCUMENT_SET_ELEM);
356 for (int i = 0; i < documentSetElems.getLength(); i++)
357 {
358 Element documentSet = (Element) documentSetElems.item(i);
359 String setName = documentSet.getAttribute(GSXML.NAME_ATT);
360 NodeList matchStatements = GSXML.getChildrenByTagName(documentSet, GSXML.MATCH_ELEM);
361 ArrayList<Element> matchStatementList = new ArrayList<Element>();
362 for (int j = 0; j < matchStatements.getLength(); j++)
363 {
364 matchStatementList.add((Element) matchStatements.item(j));
365 }
366 _documentSets.put(setName, matchStatementList);
367 }
368 }
369
370 for (int i = 0; i < exceptions.getLength(); i++)
371 {
372 HashMap<String, ArrayList<String>> securityException = new HashMap<String, ArrayList<String>>();
373 ArrayList<String> exceptionGroups = new ArrayList<String>();
374 ArrayList<String> exceptionSets = new ArrayList<String>();
375
376 Element exception = (Element) exceptions.item(i);
377 NodeList groups = GSXML.getChildrenByTagName(exception, GSXML.GROUP_ELEM);
378 for (int j = 0; j < groups.getLength(); j++)
379 {
380 Element group = (Element) groups.item(j);
381 String groupName = group.getAttribute(GSXML.NAME_ATT);
382 exceptionGroups.add(groupName);
383 }
384 NodeList docSets = GSXML.getChildrenByTagName(exception, GSXML.DOCUMENT_SET_ELEM);
385 for (int j = 0; j < docSets.getLength(); j++)
386 {
387 Element docSet = (Element) docSets.item(j);
388 String docSetName = docSet.getAttribute(GSXML.NAME_ATT);
389 exceptionSets.add(docSetName);
390 }
391 if (_securityScopeCollection) {
392 // we don't add in any exceptions that have document sets
393 if (!exceptionSets.isEmpty()) {
394 continue;
395 }
396 }
397 securityException.put("groups", exceptionGroups);
398 securityException.put("sets", exceptionSets);
399 _securityExceptions.add(securityException);
400 }
401 }
402 }
403
404 protected boolean configureServiceRacks(Element coll_config_xml, Element build_config_xml)
405 {
406 clearServices();
407 Element service_list = (Element) GSXML.getChildByTagName(build_config_xml, GSXML.SERVICE_CLASS_ELEM + GSXML.LIST_MODIFIER);
408 if (service_list != null)
409 {
410 configureServiceRackList(service_list, coll_config_xml);
411 }
412 // collection Config may also contain manually added service racks
413 service_list = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.SERVICE_CLASS_ELEM + GSXML.LIST_MODIFIER);
414 if (service_list != null)
415 {
416 configureServiceRackList(service_list, build_config_xml);
417 }
418 return true;
419 }
420
421 /**
422 * do a configure on only part of the collection
423 */
424 protected boolean configureSubset(String subset)
425 {
426
427 // need the coll config files
428 Element coll_config_elem = loadCollConfigFile();
429 Element build_config_elem = loadBuildConfigFile();
430 if (coll_config_elem == null || build_config_elem == null)
431 {
432 // wont be able to do any of the requests
433 return false;
434 }
435
436 if (subset.equals(GSXML.SERVICE_ELEM + GSXML.LIST_MODIFIER))
437 {
438 return configureServiceRacks(coll_config_elem, build_config_elem);
439 }
440
441 if (subset.equals(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER) || subset.equals(GSXML.DISPLAY_TEXT_ELEM + GSXML.LIST_MODIFIER) || subset.equals(GSXML.LIBRARY_PARAM_ELEM+GSXML.LIST_MODIFIER))
442 {
443 configureLocalData(coll_config_elem);
444 configureLocalData(build_config_elem);
445 return findAndLoadInfo(coll_config_elem, build_config_elem);
446
447 }
448
449 logger.error("Collection: cant process system request, configure " + subset);
450 return false;
451 }
452
453 /**
454 * handles requests made to the ServiceCluster itself
455 *
456 * @param req
457 * - the request Element- <request>
458 * @return the result Element - should be <response>
459 */
460 protected Element processMessage(Document result_doc, Element request)
461 {
462 String type = request.getAttribute(GSXML.TYPE_ATT);
463 if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING))
464 {
465 return processFormatStringRequest(result_doc, request);
466 }
467 else if (type.equals(GSXML.REQUEST_TYPE_SECURITY))
468 {
469 return processSecurityRequest(result_doc, request);
470 }
471 else if (type.equals(GSXML.REQUEST_TYPE_FORMAT))
472 {
473
474 Element response = result_doc.createElement(GSXML.RESPONSE_ELEM);
475 response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
476 response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT);
477 if (_globalFormat != null)
478 {
479 response.appendChild(result_doc.importNode(_globalFormat, true));
480 }
481 return response;
482 }
483 // unknown type
484 return super.processMessage(result_doc, request);
485
486 }
487
488 protected Element processSecurityRequest(Document result_doc, Element request)
489 {
490 Element response = result_doc.createElement(GSXML.RESPONSE_ELEM);
491 response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
492 response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SECURITY);
493
494 String oid = request.getAttribute("oid");
495 if (oid.contains("."))
496 {
497 oid = oid.substring(0, oid.indexOf("."));
498 }
499
500 ArrayList<String> groups = getPermittedGroups(oid);
501
502 Element groupList = result_doc.createElement(GSXML.GROUP_ELEM + GSXML.LIST_MODIFIER);
503 response.appendChild(groupList);
504
505 for (String groupName : groups)
506 {
507 Element group = result_doc.createElement(GSXML.GROUP_ELEM);
508 groupList.appendChild(group);
509 group.setAttribute(GSXML.NAME_ATT, groupName);
510 }
511 return response;
512 }
513
514 protected ArrayList<String> getPermittedGroups(String oid)
515 {
516 ArrayList<String> groups = new ArrayList<String>();
517
518 if (_securityScopeCollection)
519 {
520 if (_publicAccess)
521 {
522 groups.add("");
523 }
524 else
525 {
526 for (HashMap<String, ArrayList<String>> exception : _securityExceptions)
527 {
528 for (String group : exception.get("groups"))
529 {
530 groups.add(group);
531 }
532 }
533 }
534 }
535 else
536 {
537 if (oid != null && !oid.equals(""))
538 {
539 boolean inSet = false;
540 for (HashMap<String, ArrayList<String>> exception : _securityExceptions) {
541
542 ArrayList<String> exceptionSets = exception.get("sets");
543 if (exceptionSets.size() == 0) {
544 inSet = true;
545 for (String group : exception.get("groups"))
546 {
547 groups.add(group);
548 }
549 }
550 else {
551 for (String setName : exception.get("sets"))
552 {
553 if (documentIsInSet(oid, setName))
554 {
555 inSet = true;
556 for (String group : exception.get("groups"))
557 {
558 groups.add(group);
559 }
560 break;
561 }
562 }
563 }
564 }
565
566
567
568 if (!inSet && _publicAccess)
569 {// our doc was not part of any exception, so it must be public
570 groups.add("");
571 }
572 }
573 else // if we are not doing a request with an oid, then free to access
574 {
575 groups.add("");
576 }
577 }
578
579 return groups;
580 }
581
582 protected boolean documentIsInSet(String oid, String setName)
583 {
584 ArrayList<Element> matchStatements = _documentSets.get(setName);
585 if (matchStatements == null || matchStatements.size() == 0)
586 {
587 return false;
588 }
589
590 for (Element currentMatchStatement : matchStatements)
591 {
592 String fieldName = currentMatchStatement.getAttribute(GSXML.FIELD_ATT);
593 if (fieldName == null || fieldName.equals(""))
594 {
595 fieldName = "oid";
596 }
597
598 String type = currentMatchStatement.getAttribute(GSXML.TYPE_ATT);
599 if (type == null || type.equals(""))
600 {
601 type = "match";
602 }
603
604 String fieldValue = "";
605 if (!fieldName.equals("oid"))
606 {
607 fieldValue = getFieldValue(oid, fieldName);
608 if (fieldValue == null)
609 {
610 return false;
611 }
612 }
613 else
614 {
615 fieldValue = oid;
616 }
617
618 String matchValue = GSXML.getNodeText(currentMatchStatement);
619 if (type.equals("match"))
620 {
621 if (matchValue.equals(fieldValue))
622 {
623 return true;
624 }
625 }
626 else if (type.equals("regex"))
627 {
628 if (fieldValue.matches(matchValue))
629 {
630 return true;
631 }
632 }
633 else
634 {
635 logger.warn("Unknown type of match specified in security block of collection " + this.cluster_name + ".");
636 }
637 }
638
639 return false;
640 }
641
642 protected String getFieldValue(String oid, String fieldName)
643 {
644 Document msg_doc = XMLConverter.newDOM();
645 Element metadataMessage = msg_doc.createElement(GSXML.MESSAGE_ELEM);
646 Element metadataRequest = GSXML.createBasicRequest(msg_doc, GSXML.REQUEST_TYPE_PROCESS, this.cluster_name + "/DocumentMetadataRetrieve", new UserContext());
647 metadataMessage.appendChild(metadataRequest);
648
649 Element paramList = msg_doc.createElement(GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
650 metadataRequest.appendChild(paramList);
651
652 Element param = msg_doc.createElement(GSXML.PARAM_ELEM);
653 paramList.appendChild(param);
654
655 param.setAttribute(GSXML.NAME_ATT, "metadata");
656 param.setAttribute(GSXML.VALUE_ATT, fieldName);
657
658 Element docList = msg_doc.createElement(GSXML.DOC_NODE_ELEM + GSXML.LIST_MODIFIER);
659 metadataRequest.appendChild(docList);
660
661 Element doc = msg_doc.createElement(GSXML.DOC_NODE_ELEM);
662 docList.appendChild(doc);
663
664 doc.setAttribute(GSXML.NODE_ID_ATT, oid);
665
666 Element response = (Element) this.router.process(metadataMessage);
667 NodeList metadataElems = response.getElementsByTagName(GSXML.METADATA_ELEM);
668
669 if (metadataElems.getLength() > 0)
670 {
671 Element metadata = (Element) metadataElems.item(0);
672 return GSXML.getNodeText(metadata);
673 }
674
675 return null;
676 }
677
678 protected Element processFormatStringRequest(Document result_doc, Element request)
679 {
680 Element response = result_doc.createElement(GSXML.RESPONSE_ELEM);
681 response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT_STRING);
682 response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
683
684 String subaction = request.getAttribute("subaction");
685 String service = request.getAttribute("service");
686
687 String classifier = null;
688 if (service.equals("ClassifierBrowse"))
689 {
690 classifier = request.getAttribute("classifier");
691 }
692
693 // check for version file
694 String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.separator;
695
696 String version_filename = "";
697 if (service.equals("ClassifierBrowse"))
698 version_filename = directory + "browse_" + classifier + "_format_statement_version.txt";
699 else
700 version_filename = directory + "query_format_statement_version.txt";
701
702 File version_file = new File(version_filename);
703
704 if (subaction.equals("update"))
705 {
706 Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
707 //String format_string = GSXML.getNodeText(format_element);
708 Element format_statement = (Element) format_element.getFirstChild();
709
710 String version_number = "1";
711 BufferedWriter writer;
712
713 try
714 {
715
716 if (version_file.exists())
717 {
718 // Read version
719 BufferedReader reader = new BufferedReader(new FileReader(version_filename));
720 version_number = reader.readLine();
721 int aInt = Integer.parseInt(version_number) + 1;
722 version_number = Integer.toString(aInt);
723 reader.close();
724 }
725 else
726 {
727 // Create
728 version_file.createNewFile();
729 writer = new BufferedWriter(new FileWriter(version_filename));
730 writer.write(version_number);
731 writer.close();
732 }
733
734 // Write version file
735 String format_statement_filename = "";
736
737 if (service.equals("ClassifierBrowse"))
738 format_statement_filename = directory + "browse_" + classifier + "_format_statement_v" + version_number + ".txt";
739 else
740 format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt";
741
742 // Write format statement
743 String format_string = this.converter.getString(format_statement); //GSXML.xmlNodeToString(format_statement);
744 writer = new BufferedWriter(new FileWriter(format_statement_filename));
745 writer.write(format_string);
746 writer.close();
747
748 // Update version number
749 writer = new BufferedWriter(new FileWriter(version_filename));
750 writer.write(version_number);
751 writer.close();
752
753 }
754 catch (IOException e)
755 {
756 logger.error("IO Exception " + e);
757 }
758 }
759
760 if (subaction.equals("saveDocument"))
761 {
762 Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
763 //String format_string = GSXML.getNodeText(format_element);
764 // Get display tag
765 Element display_format = (Element) format_element.getFirstChild();
766
767 String collection_config = directory + "collectionConfig.xml";
768 Document config = this.converter.getDOM(new File(collection_config), "UTF-8");
769
770 Node current_node = GSXML.getChildByTagName(config, "CollectionConfig");
771
772 // Get display child
773 if (GSXML.getChildByTagName(current_node, "display") == null)
774 {
775 // well then create a format tag
776 Element display_tag = config.createElement("display");
777 current_node = (Node) current_node.appendChild(display_tag);
778 }
779 else
780 {
781 current_node = GSXML.getChildByTagName(current_node, "display");
782 }
783
784 if (GSXML.getChildByTagName(current_node, "format") == null)
785 {
786 // well then create a format tag
787 Element format_tag = config.createElement("format");
788 current_node.appendChild(format_tag);
789 }
790
791 current_node.replaceChild(config.importNode(display_format, true), GSXML.getChildByTagName(current_node, "format"));
792
793 String new_config = this.converter.getString(config);
794
795 new_config = StringUtils.replace(new_config, "&lt;", "<");
796 new_config = StringUtils.replace(new_config, "&gt;", ">");
797 new_config = StringUtils.replace(new_config, "&quot;", "\"");
798
799 try
800 {
801 // Write to file (not original! for now)
802 BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new"));
803 writer.write(new_config);
804 writer.close();
805 }
806 catch (IOException e)
807 {
808 logger.error("IO Exception " + e);
809 }
810 }
811
812 if (subaction.equals("save"))
813 {
814 Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
815 Element format_statement = (Element) format_element.getFirstChild();
816
817 try
818 {
819 // open collectionConfig.xml and read in to w3 Document
820 String collection_config = directory + "collectionConfig.xml";
821 Document config = this.converter.getDOM(new File(collection_config), "UTF-8");
822
823 //String tag_name = "";
824 int k;
825 int index;
826 Element elem;
827 Node current_node = GSXML.getChildByTagName(config, "CollectionConfig");
828 NodeList current_node_list;
829
830 if (service.equals("ClassifierBrowse"))
831 {
832 //tag_name = "browse";
833 // if CLX then need to look in <classifier> X then <format>
834 // default is <browse><format>
835
836 current_node = GSXML.getChildByTagName(current_node, "browse");
837
838 // find CLX
839 if (classifier != null)
840 {
841 current_node_list = GSXML.getChildrenByTagName(current_node, "classifier");
842 index = Integer.parseInt(classifier.substring(2)) - 1;
843
844 // index should be given by X-1
845 current_node = current_node_list.item(index);
846 // what if classifier does not have a format tag?
847 if (GSXML.getChildByTagName(current_node, "format") == null)
848 {
849 // well then create a format tag
850 Element format_tag = config.createElement("format");
851 current_node.appendChild(format_tag);
852 }
853 }
854 else
855 {
856 // To support all classifiers, set classifier to null? There is the chance here that the format tag does not exist
857 if (GSXML.getChildByTagName(current_node, "format") == null)
858 {
859 // well then create a format tag
860 Element format_tag = config.createElement("format");
861 current_node.appendChild(format_tag);
862 }
863 }
864 }
865 else if (service.equals("AllClassifierBrowse"))
866 {
867 current_node = GSXML.getChildByTagName(current_node, "browse");
868 if (GSXML.getChildByTagName(current_node, "format") == null)
869 {
870 // well then create a format tag
871 Element format_tag = config.createElement("format");
872 current_node.appendChild(format_tag);
873 }
874 }
875 else
876 {
877 // look in <format> with no attributes
878 current_node_list = GSXML.getChildrenByTagName(current_node, "search");
879 for (k = 0; k < current_node_list.getLength(); k++)
880 {
881 current_node = current_node_list.item(k);
882 // if current_node has no attributes then break
883 elem = (Element) current_node;
884 if (elem.hasAttribute("name") == false)
885 break;
886 }
887 }
888
889 current_node.replaceChild(config.importNode(format_statement, true), GSXML.getChildByTagName(current_node, "format"));
890
891 // Now convert config document to string for writing to file
892 String new_config = this.converter.getString(config);
893
894 new_config = StringUtils.replace(new_config, "&lt;", "<");
895 new_config = StringUtils.replace(new_config, "&gt;", ">");
896 new_config = StringUtils.replace(new_config, "&quot;", "\"");
897
898 // Write to file (not original! for now)
899 BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new"));
900 writer.write(new_config);
901 writer.close();
902
903 }
904 catch (Exception ex)
905 {
906 logger.error("There was an exception " + ex);
907
908 StringWriter sw = new StringWriter();
909 PrintWriter pw = new PrintWriter(sw, true);
910 ex.printStackTrace(pw);
911 pw.flush();
912 sw.flush();
913 logger.error(sw.toString());
914 }
915
916 }
917
918 return response;
919 }
920
921
922}
Note: See TracBrowser for help on using the repository browser.