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

Last change on this file since 29310 was 29310, checked in by kjdon, 10 years ago

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