source: main/trunk/gli/src/org/greenstone/gatherer/cdm/CollectionConfigXMLReadWrite.java@ 29221

Last change on this file since 29221 was 29221, checked in by ak19, 10 years ago

Added code to allow GLI to preserve any solr-specific <sort> and <facet> subelements of <search> if these were manually-added to a GS3 collectionConfig.xml
File size: 111.2 KB
Line 
1/**
2 *#########################################################################
3 *
4 * A component of the Gatherer application, part of the Greenstone digital
5 * library suite from the New Zealand Digital Library Project at the
6 * University of Waikato, New Zealand.
7 *
8 * Methods to read collectionConfig.xml files into internal XML form, and write
9 * them back out again.
10 *
11 * Copyright (C) 1999 New Zealand Digital Library Project
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 *########################################################################
27 */
28package org.greenstone.gatherer.cdm;
29
30import java.io.File;
31import java.util.ArrayList;
32import java.util.Arrays;
33import java.util.HashMap;
34import java.util.HashSet;
35import java.util.Iterator;
36import java.util.LinkedHashSet;
37import java.util.Map;
38import java.util.Set;
39import java.util.StringTokenizer;
40
41import org.greenstone.gatherer.DebugStream;
42import org.greenstone.gatherer.metadata.MetadataElement;
43import org.greenstone.gatherer.metadata.MetadataTools;
44import org.greenstone.gatherer.util.StaticStrings;
45import org.greenstone.gatherer.util.Utility;
46import org.greenstone.gatherer.util.XMLTools;
47import org.w3c.dom.Document;
48import org.w3c.dom.Element;
49import org.w3c.dom.Node;
50import org.w3c.dom.NodeList;
51
52public class CollectionConfigXMLReadWrite
53{
54
55 static final private String PLUGOUT_ELEMENT = "plugout";//used by building flax collections
56
57 // a list of all known top level elements
58 static final private String known_element_names_array[] = { StaticStrings.METADATALIST_STR, StaticStrings.DISPLAYITEMLIST_STR, StaticStrings.FORMAT_STR, StaticStrings.SEARCH_STR, StaticStrings.INFODB_STR, StaticStrings.BROWSE_STR, StaticStrings.IMPORT_STR, StaticStrings.DISPLAY_STR, StaticStrings.REPLACELISTREF_STR, StaticStrings.REPLACELIST_STR, StaticStrings.SERVICE_RACK_LIST_ELEMENT };
59 static final private Set known_element_names = new HashSet(Arrays.asList(known_element_names_array));
60
61 /**
62 * *************************************************************************
63 * ******************************* The code in this file is used for
64 * greenstone 3 collection configuration, i.e., read ColletionConfig.xml
65 * into the internal DOM tree, and convert the internal DOM tree back to
66 * CollectionConfig.xml.
67 *
68 * Methods named 'doXXXX' are for convert collectionConfig.xml into the
69 * internal configuration xml structure; Methods named 'convertXXXX' are for
70 * convert the internal configuration xml structure back to
71 * collectionConfig.xml.
72 ************************************************************************************************************ */
73
74 /**
75 * Arguments: metadataListNode->the 'displayItemList' element in
76 * collectionConfig.xml name_value->the value of the 'name' attribute of
77 * 'index' element; att_value->the value of the 'name' attribute of
78 * 'displayItem' element return: an ArrayList of the contructed
79 * 'CollectionMetadata' elements
80 */
81 static private ArrayList doDisplayItemList(Document to, Node displayListNode, String att_value, String name_value)
82 {
83 Element toElement = to.getDocumentElement();
84 ArrayList display_item_list = new ArrayList();
85 ArrayList item_list = XMLTools.getNamedElementList((Element) displayListNode, StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, att_value);
86 if (item_list == null)
87 {
88 return null;
89 }
90
91 for (int i = 0; i < item_list.size(); i++)
92 {
93 Element item = (Element) item_list.get(i);
94 String text = XMLTools.getNodeText(item);
95 text = text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
96
97 //If there is nothing to display, don't bother creating the element
98 if (text == "")
99 {
100 continue;
101 }
102 //get the value in 'lang=value'
103 String lang = item.getAttribute(StaticStrings.LANG_STR);
104
105 Element e = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
106 e.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
107 e.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_value);
108 e.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, lang);
109 XMLTools.setNodeText(e, text);
110 display_item_list.add(e);
111 }
112 return display_item_list;
113 }
114
115 static private ArrayList doMetadataList(Document to, Node metadataListNode, String ele_name, String att_value)
116 {
117 Element toElement = to.getDocumentElement();
118 ArrayList metadata_list = new ArrayList();
119
120 ArrayList item_list = XMLTools.getNamedElementList((Element) metadataListNode, StaticStrings.METADATA_STR, StaticStrings.NAME_ATTRIBUTE, att_value);
121 if (item_list == null)
122 {
123 return null;
124 }
125
126 for (int i = 0; i < item_list.size(); i++)
127 {
128 Element item = (Element) item_list.get(i);
129 String text = XMLTools.getNodeText(item);
130
131 //If there is nothing to display, don't bother creating the element
132 if (text == "")
133 {
134 continue;
135 }
136 //get the value in 'lang=value'
137 String lang = item.getAttribute(StaticStrings.LANG_STR);
138
139 Element element = to.createElement(ele_name);
140 element.setAttribute(StaticStrings.NAME_ATTRIBUTE, att_value);
141 element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, lang);
142 element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
143 element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
144 XMLTools.setNodeText(element, text);
145
146 metadata_list.add(element);
147 }
148 return metadata_list;
149 }
150
151 // 'to' is the internal structure
152 static private void doMGIndexes(Document to, Node searchNode)
153 {
154 Element toElement = to.getDocumentElement();
155 Element indexes_element = to.createElement(StaticStrings.INDEXES_ELEMENT);//<Indexes>
156 indexes_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
157 indexes_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
158
159 NodeList index_children = ((Element) searchNode).getElementsByTagName(StaticStrings.INDEX_LOW_STR);//index
160 int num_nodes = index_children.getLength();
161
162 for (int i = 0; i < num_nodes; i++)
163 {
164 Element e = (Element) index_children.item(i);
165 String index_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
166 String index_str_display = index_str;//used for creating collectionmetadata for this index
167 Element index_element = to.createElement(StaticStrings.INDEX_ELEMENT);//<Index>
168
169 if (index_str.indexOf(StaticStrings.COLON_CHARACTER) == -1)
170 {
171 // It doesn't contain ':' character
172 System.err.println("Something is wrong! the index should be level:source tuplets.");
173 // assume document level
174 index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, StaticStrings.DOCUMENT_STR);
175 }
176 else
177 {
178 // Handling 'index' element
179 index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
180
181 index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
182 }
183 //Each index may have a list of comma-separated strings.
184 //split them into 'content' elements in the internal structure
185 StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER);
186 //index_str = "";
187 while (content_tokenizer.hasMoreTokens())
188 {
189 // Replace index_str to be qualified name, eg. dc.Subject and keywords insread of dc.Subject.
190
191 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
192 String content_str = content_tokenizer.nextToken();
193 // Since the contents of indexes have to be certain keywords, or metadata elements,
194 //if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
195 if (content_str.indexOf(StaticStrings.NS_SEP) == -1 && !(content_str.equals(StaticStrings.TEXT_STR)))
196 {
197 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
198
199 }
200
201 content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_str);
202 index_element.appendChild(content_element);
203 content_element = null;
204 } // while ends
205
206 indexes_element.appendChild(index_element);
207
208 // Handling 'displayItem' elements and Constructing 'collectionmetadata' elements
209 // Use the fully qualified index names
210 ArrayList collectionmetadata_list = doDisplayItemList(to, e, StaticStrings.NAME_ATTRIBUTE, index_str_display);
211 appendArrayList(toElement, collectionmetadata_list);
212 } //for loop ends
213 appendProperly(toElement, indexes_element);
214
215 //***//
216 // create another set of <indexes> which will be used when user switches to MGPP/LUCENE
217 // i.e. we build a default index set for a start
218
219 String[] index_strs = { StaticStrings.TEXT_STR, StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.TITLE_ELEMENT, StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.SOURCE_ELEMENT };
220
221 Element mgpp_indexes = to.createElement(StaticStrings.INDEXES_ELEMENT);//<Indexes>
222 mgpp_indexes.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
223 mgpp_indexes.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
224 for (int i = 0; i < index_strs.length; i++)
225 {
226 Element index_element = to.createElement(StaticStrings.INDEX_ELEMENT);//<Index>
227 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
228 content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
229 index_element.appendChild(content_element);
230 mgpp_indexes.appendChild(index_element);
231
232 // Contructing 'collectionmetadata' elements for 'mgpp' indexes
233 Element collectionmetadata = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
234 collectionmetadata.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
235 collectionmetadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
236 collectionmetadata.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
237 if (index_strs[i].indexOf(StaticStrings.NS_SEP) != -1)
238 {
239 index_strs[i] = index_strs[i].substring(index_strs[i].indexOf(StaticStrings.NS_SEP) + 1);
240 }
241 XMLTools.setNodeText(collectionmetadata, index_strs[i]);
242
243 appendProperly(toElement, collectionmetadata);
244
245 }
246 appendProperly(toElement, mgpp_indexes);
247 }
248
249 //This is actually doing indexes for both mgpp and lucene
250 static private void doMGPPIndexes(Document to, Node searchNode)
251 {
252 Element toElement = to.getDocumentElement();
253 Element indexes_element = to.createElement(StaticStrings.INDEXES_ELEMENT);//<Indexes>
254 indexes_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
255 indexes_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
256
257 NodeList index_children = ((Element) searchNode).getElementsByTagName(StaticStrings.INDEX_LOW_STR);//index
258 int num_nodes = index_children.getLength();
259
260 for (int i = 0; i < num_nodes; i++)
261 {
262
263 Element index_element = to.createElement(StaticStrings.INDEX_ELEMENT);//<Index>
264 Element e = (Element) index_children.item(i);
265 String index_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
266 String index_str_display = index_str;//for creating collectionmetadata for this index
267
268
269 String options_str = "";
270 NodeList option_children = e.getElementsByTagName(StaticStrings.OPTION_STR);
271 if(option_children != null) {
272 for (int j = 0; j < option_children.getLength(); j++) {
273 Element el = (Element) option_children.item(j);
274
275 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
276 options_str = options_str + ((name_str.equals("")) ? "" : (" " + name_str));
277
278 String value_str = el.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
279 options_str = options_str + ((name_str.equals("")) ? "" : (" " + value_str));
280
281 if (name_str.equals("") && !value_str.equals(""))
282 {
283 continue; //invalid condition
284 }
285
286 Element option_element = null;
287 option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
288 option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
289
290 if (!name_str.equals(""))
291 {
292 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
293 }
294 if (value_str != null && !value_str.equals(""))
295 {
296 XMLTools.setNodeText(option_element, value_str);
297 }
298 index_element.appendChild(option_element);
299 }
300 }
301
302 // Handling 'index' element
303 // Double check to make sure it's not colon separated style index.
304 if (index_str.indexOf(StaticStrings.COLON_CHARACTER) != -1)
305 {
306 System.err.println("Something is wrong! the index should NOT be level:source tuplets style.");
307 index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
308
309 }
310 //Each index may have a list of comma-separated strings.
311 //split them into 'content' elements in the internal structure
312 StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER);
313 while (content_tokenizer.hasMoreTokens())
314 {
315 // Replace index_str to be qualified name, eg. dc.Subject and keywords insread of dc.Subject.
316
317 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
318 String content_str = content_tokenizer.nextToken();
319 // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
320 if (content_str.indexOf(StaticStrings.NS_SEP) == -1 && !(content_str.equals(StaticStrings.TEXT_STR) || content_str.equals(StaticStrings.ALLFIELDS_STR)))
321 {
322 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
323 }
324 content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_str);
325 index_element.appendChild(content_element);
326 content_element = null;
327 } //while ends
328
329 indexes_element.appendChild(index_element);
330
331 index_element = null;
332
333 // Handling 'displayItem' element of this 'index' element
334 // 'e' is the parent element 'index' of 'displayItem' element
335 ArrayList collectionmetadata_list = doDisplayItemList(to, e, StaticStrings.NAME_ATTRIBUTE, index_str_display);
336 appendArrayList(toElement, collectionmetadata_list);
337
338 } // for loop ends
339 toElement.appendChild(indexes_element);
340
341 // create another set of <indexes> which will be used when user switches to MG
342 // i.e. we build a default index set for a start
343 Element mg_indexes = to.createElement(StaticStrings.INDEXES_ELEMENT);//<Indexes>
344 mg_indexes.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
345 mg_indexes.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
346
347 //put the namespace '.ex' as prefix to the indexes
348 String[] index_strs = { StaticStrings.TEXT_STR, StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.TITLE_ELEMENT, StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.SOURCE_ELEMENT };
349 for (int i = 0; i < index_strs.length; i++)
350 {
351 Element index_element = to.createElement(StaticStrings.INDEX_ELEMENT);//<Index>
352 index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, StaticStrings.DOCUMENT_STR);
353 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
354 content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
355 index_element.appendChild(content_element);
356
357 mg_indexes.appendChild(index_element);
358
359 // Contructing 'collectionmetadata' elements for 'mg' indexes
360 Element collectionmetadata = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
361 collectionmetadata.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
362 String temp = StaticStrings.DOCUMENT_STR.concat(StaticStrings.COLON_CHARACTER).concat(index_strs[i]);
363 collectionmetadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, temp);
364 collectionmetadata.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
365 if (index_strs[i].indexOf(StaticStrings.NS_SEP) != -1)
366 {
367 index_strs[i] = index_strs[i].substring(index_strs[i].indexOf(StaticStrings.NS_SEP) + 1);
368 }
369 XMLTools.setNodeText(collectionmetadata, index_strs[i]);
370
371 appendProperly(toElement, collectionmetadata);
372
373 }
374 toElement.appendChild(mg_indexes);
375
376 }
377
378 //This processes <sort> and <facet> subelements of <search> for a solr collection
379 // Note that GLI at present does not allow the user to set or modify the solr-specific elements
380 // <sort> and <facet>. This function, and its inverse convertSolrFacetsAndSorts, is only here to preserve such
381 // elements if they already exist in the collectionConfig.xml. At present they need to be manually added there.
382 static private void doSolrFacetsAndSorts(Document to, Node searchNode)
383 {
384 Element toElement = to.getDocumentElement();
385 Element solr_element = to.createElement(StaticStrings.SOLR_ELEMENT);//<Solr>
386 solr_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
387 solr_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
388
389
390 NodeList sort_children = ((Element) searchNode).getElementsByTagName(StaticStrings.SORT_LOW_STR);//<sort>
391 int num_nodes = sort_children.getLength();
392
393 for (int i = 0; i < num_nodes; i++)
394 {
395
396 Element sort_element = to.createElement(StaticStrings.SORT_ELEMENT);//<Sort>
397 Element e = (Element) sort_children.item(i);
398 String sort_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
399 String sort_str_display = sort_str;//for creating collectionmetadata for this sort element
400
401 // Handling 'sort' element
402 sort_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, sort_str);
403
404 Element displayItem = (Element) XMLTools.getChildByTagName(e, StaticStrings.DISPLAYITEM_STR); // gets the first <displayItem> child of <sort>
405
406 if(displayItem != null) {
407 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
408
409 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
410
411 String value_str = XMLTools.getNodeText(displayItem);
412
413 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_ELEMENT); // <DisplayItem> not <displayItem>!
414 displayItem_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
415
416 if (lang_str != null && !lang_str.equals(""))
417 {
418 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
419 }
420 if (name_str != null && !name_str.equals(""))
421 {
422 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
423 }
424 if (value_str != null && !value_str.equals(""))
425 {
426 //XMLTools.setNodeText(displayItem_element, value_str);
427 displayItem_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
428 }
429 sort_element.appendChild(displayItem_element);
430
431 }
432
433 solr_element.appendChild(sort_element);
434
435 sort_element = null;
436
437 // Handling 'displayItem' element of this 'sort' element
438 // 'e' is the parent 'sort' element of 'displayItem' element
439 ///ArrayList collectionmetadata_list = doDisplayItemList(to, e, StaticStrings.NAME_ATTRIBUTE, sort_str_display);
440 ///appendArrayList(toElement, collectionmetadata_list);
441
442 } // for loop on sort elements ends
443
444
445 NodeList facet_children = ((Element) searchNode).getElementsByTagName(StaticStrings.FACET_LOW_STR);//facet
446 num_nodes = facet_children.getLength();
447
448 for (int i = 0; i < num_nodes; i++)
449 {
450
451 Element facet_element = to.createElement(StaticStrings.FACET_ELEMENT);//<Facet>
452 Element e = (Element) facet_children.item(i);
453 String facet_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
454 String facet_str_display = facet_str;//for creating collectionmetadata for this facet
455
456 // Handling 'facet' element
457 facet_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, facet_str);
458
459 Element displayItem = (Element) XMLTools.getChildByTagName(e, StaticStrings.DISPLAYITEM_STR); // gets the first <displayItem> child of <sort>
460
461 if(displayItem != null) {
462 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
463
464 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
465
466 String value_str = XMLTools.getNodeText(displayItem);
467
468 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_ELEMENT); // <DisplayItem> not <displayItem>!
469 displayItem_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
470
471 if (lang_str != null && !lang_str.equals(""))
472 {
473 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
474 }
475 if (name_str != null && !name_str.equals(""))
476 {
477 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
478 }
479 if (value_str != null && !value_str.equals(""))
480 {
481 //XMLTools.setNodeText(displayItem_element, value_str);
482 displayItem_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
483 }
484 facet_element.appendChild(displayItem_element);
485
486 }
487 solr_element.appendChild(facet_element);
488
489 facet_element = null;
490
491 // Handling 'displayItem' element of this 'facet' element
492 // 'e' is the parent 'facet' element of 'displayItem' element
493 ///ArrayList collectionmetadata_list = doDisplayItemList(to, e, StaticStrings.NAME_ATTRIBUTE, facet_str_display);
494 ///appendArrayList(toElement, collectionmetadata_list);
495
496 } // for loop on facet elements ends
497
498 // finished processing sort and facet elements
499 toElement.appendChild(solr_element);
500
501 }
502
503 static private void doGlobalFormat(Document to, Element from)
504 {
505 // look for a top level format element
506 Element fe = (Element) XMLTools.getChildByTagName(from, StaticStrings.FORMAT_STR);
507 to.getDocumentElement().appendChild(doFormat(to, fe, StaticStrings.GLOBAL_STR));
508 }
509
510 static private void doDisplayFormat(Document to, Element from)
511 {
512 //display element in the xml file
513 Element de = (Element) XMLTools.getChildByTagName(from, StaticStrings.DISPLAY_STR);
514 if (de == null)
515 {
516 return;
517 }
518 //format element in the display element
519 Element fe = (Element) XMLTools.getChildByTagName(de, StaticStrings.FORMAT_STR);
520
521 to.getDocumentElement().appendChild(doFormat(to, fe, StaticStrings.DISPLAY_STR));
522 }
523
524 //construct 'DefaultIndex' element in the internal structure from collectionConfig.xml
525 static private void doDefaultIndex(Document to, Node searchNode)
526 {
527 Element toElement = to.getDocumentElement();
528 Element default_index_element = to.createElement(StaticStrings.INDEX_DEFAULT_ELEMENT);
529 default_index_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
530
531 Element e = (Element) XMLTools.getChildByTagName(searchNode, StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);//defaultIndex
532 if (e == null)
533 {
534 return;
535 }
536 String index_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
537
538 boolean old_index = false;
539 if (index_str.indexOf(StaticStrings.COLON_CHARACTER) != -1)
540 {
541 //The index is 'level:source tuplets' which is for mg. Take out 'level'
542 old_index = true;
543 default_index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
544 index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
545 }
546 else
547 {
548 default_index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, "");
549 }
550
551 //Each index may have a list of comma-separated strings.
552 //split them into 'content' elements in the internal structure
553 StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER);
554 while (content_tokenizer.hasMoreTokens())
555 {
556 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
557 String content_str = content_tokenizer.nextToken();
558 // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
559 if (content_str.indexOf(StaticStrings.NS_SEP) == -1)
560 {
561 if (content_str.equals(StaticStrings.TEXT_STR) || (!old_index && content_str.equals(StaticStrings.ALLFIELDS_STR)))
562 {
563 // in this case, do nothing
564 }
565 else
566 {
567 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
568 }
569 }
570
571 content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_str);
572 default_index_element.appendChild(content_element);
573 content_element = null;
574 }
575 appendProperly(toElement, default_index_element);
576 }
577
578 // For mg, this method is still called, but make it 'assigned=false'
579 static private void doDefaultLevel(Document to, Node searchNode)
580 {
581 Element toElement = to.getDocumentElement();
582 Element default_index_option = to.createElement(StaticStrings.INDEXOPTION_DEFAULT_ELEMENT);
583 default_index_option.setAttribute(StaticStrings.NAME_STR, StaticStrings.LEVEL_DEFAULT_STR);
584
585 Element e = (Element) XMLTools.getChildByTagName(searchNode, StaticStrings.LEVEL_DEFAULT_ELEMENT);
586 if (e != null)
587 {
588 default_index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
589 String level = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
590 default_index_option.setAttribute(StaticStrings.VALUE_ATTRIBUTE, level);
591 }
592 else
593 {
594 //In the case of mg, there's no level! build a default one using 'assigned=false value=document'
595 default_index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
596 default_index_option.setAttribute(StaticStrings.VALUE_ATTRIBUTE, StaticStrings.DOCUMENT_STR);
597 }
598 appendProperly(toElement, default_index_option);
599 }
600
601 // Transform plugins (pluginListNode) of collectionConfig.xml into the internal structure (i.e. Document to)
602 static private void doPlugin(Document to, Node pluginListNode)
603 {
604 Element toElement = to.getDocumentElement();
605 NodeList plugin_children = ((Element) pluginListNode).getElementsByTagName(StaticStrings.PLUGIN_STR);
606 int plugin_nodes = plugin_children.getLength();
607
608 if (plugin_nodes < 1)
609 {
610 return;
611 }
612
613 for (int i = 0; i < plugin_nodes; i++)
614 {
615 Element e = (Element) plugin_children.item(i);
616 String str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
617 str = Utility.ensureNewPluginName(str);
618 Element plugin_element = to.createElement(StaticStrings.PLUGIN_ELEMENT);
619 plugin_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, str);
620
621 NodeList option_children = e.getElementsByTagName(StaticStrings.OPTION_STR);
622
623 for (int j = 0; j < option_children.getLength(); j++)
624 {
625 Element el = (Element) option_children.item(j);
626 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
627 if (name_str.startsWith(StaticStrings.MINUS_CHARACTER))
628 {
629 name_str = name_str.substring(1);
630 }
631 String value_str = el.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
632 Element option_element = null;
633
634 if (name_str.equals("") && !value_str.equals(""))
635 {
636 continue;
637 }
638
639 option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
640 option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
641 if (name_str.equals(StaticStrings.RECPLUG_STR) && value_str.equals(StaticStrings.USE_METADATA_FILES_ARGUMENT))
642 {
643 continue; // ignore this option
644 }
645
646 if (value_str != null)
647 {
648 // Remove any speech marks appended in strings containing whitespace
649 if (value_str.startsWith(StaticStrings.SPEECH_CHARACTER) && value_str.endsWith(StaticStrings.SPEECH_CHARACTER))
650 {
651 value_str = value_str.substring(1, value_str.length() - 1);
652 }
653 if (name_str.equals(StaticStrings.METADATA_STR))
654 {
655 // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
656 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
657 value_str = "";
658 for (int k = 0; k <= values.length - 1; k++)
659 {
660 if (values[k].indexOf(StaticStrings.NS_SEP) == -1)
661 {
662 values[k] = StaticStrings.EXTRACTED_NAMESPACE + values[k];
663 }
664
665 if (k < values.length - 1)
666 {
667 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
668
669 }
670 else
671 {
672 value_str = value_str + values[k];
673 }
674 }
675 }
676 }
677 if (!name_str.equals(""))
678 {
679 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
680 }
681 if (!value_str.equals(""))
682 {
683 XMLTools.setNodeText(option_element, value_str);
684 }
685 plugin_element.appendChild(option_element);
686
687 }
688
689 appendProperly(toElement, plugin_element);
690 }
691
692 }
693
694 //Handle classifiers
695 static private void doClassifier(Document to, Node browseNode)
696 {
697 Element toElement = to.getDocumentElement();
698 NodeList classifier_children = ((Element) browseNode).getElementsByTagName(StaticStrings.CLASSIFIER_STR);
699 int num_nodes = classifier_children.getLength();
700
701 if (num_nodes < 1)
702 {
703 return;
704 }
705
706 for (int i = 0; i < num_nodes; i++)
707 {
708 Element e = (Element) classifier_children.item(i);
709 String str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
710 Element classify_element = to.createElement(StaticStrings.CLASSIFY_ELEMENT);
711 classify_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, str);
712
713 String options_str = "";
714 NodeList option_children = e.getElementsByTagName(StaticStrings.OPTION_STR);
715 for (int j = 0; j < option_children.getLength(); j++)
716 {
717 Element el = (Element) option_children.item(j);
718 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
719 options_str = options_str + ((name_str.equals("")) ? "" : (" " + name_str));
720 if (name_str.startsWith(StaticStrings.MINUS_CHARACTER))
721 {
722 name_str = name_str.substring(1);
723 }
724 String value_str = el.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
725 options_str = options_str + ((name_str.equals("")) ? "" : (" " + value_str));
726 Element option_element = null;
727
728 if (name_str.equals("") && !value_str.equals(""))
729 {
730 continue; //invalid condition
731 }
732
733 option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
734 option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
735
736 if (!name_str.equals(""))
737 {
738 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
739 }
740
741 if (!value_str.equals("") && name_str.equals(StaticStrings.METADATA_STR))
742 {
743 // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
744 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
745 value_str = "";
746 for (int k = 0; k <= values.length - 1; k++)
747 {
748 if (values[k].indexOf(StaticStrings.NS_SEP) == -1)
749 {
750 values[k] = StaticStrings.EXTRACTED_NAMESPACE + values[k];
751 }
752 else
753 {
754 MetadataElement metadata_element = MetadataTools.getMetadataElementWithName(values[k]);
755 if (metadata_element != null)
756 {
757 values[k] = metadata_element.getDisplayName();
758 }
759 }
760 if (k < values.length - 1)
761 {
762 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
763 }
764 else
765 {
766 value_str = value_str + values[k];
767 }
768 }
769 }
770
771 if (value_str != null && !value_str.equals(""))
772 {
773 XMLTools.setNodeText(option_element, value_str);
774 }
775 classify_element.appendChild(option_element);
776 }
777 //format element for this classifier
778 Element format = (Element) XMLTools.getChildByTagName(e, StaticStrings.FORMAT_STR);
779 if (format != null)
780 {
781 classify_element.appendChild(doFormat(to, format, null));
782 }
783 appendProperly(toElement, classify_element);
784 }
785
786 // default format statement for all classifiers
787 Element default_classifier_format = (Element) XMLTools.getChildByTagName(browseNode, StaticStrings.FORMAT_STR);
788
789 to.getDocumentElement().appendChild(doFormat(to, default_classifier_format, StaticStrings.BROWSE_STR));
790 }
791
792 static private Element doFormat(Document to, Element format, String name_str)
793 {
794 Element format_element = to.createElement(StaticStrings.FORMAT_STR);
795 if (name_str != null)
796 {
797 format_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
798 }
799
800 // Don't write out an empty format statement of <format/> (i.e. format has no child nodes)
801 // as this will end up embedded in another format statement as <format><format/><format />
802 // This doubling up of format stmts will then prevent GLI from opening the collection again.
803 if (format != null && format.hasChildNodes())
804 { // not an empty format statement
805 String gsf_text = XMLTools.xmlNodeToString(format);
806
807 //We don't want the <format> elements in the string
808 int startFormatIndex = gsf_text.indexOf(StaticStrings.FORMAT_START_TAG) + StaticStrings.FORMAT_START_TAG.length();
809 int endFormatIndex = gsf_text.lastIndexOf(StaticStrings.FORMAT_END_TAG);
810 gsf_text = gsf_text.substring(startFormatIndex, endFormatIndex);
811
812 XMLTools.setNodeText(format_element, gsf_text);
813 }
814 return format_element;
815 }
816
817 // Handling 'subcollection' elements in 'search' element of 'collectionConfig.xml'
818 static private void doSubcollection(Document to, Node searchNode)
819 {
820 Element toElement = to.getDocumentElement();
821 NodeList sub_children = ((Element) searchNode).getElementsByTagName(StaticStrings.SUBCOLLECTION_STR);
822 int sub_nodes = sub_children.getLength();
823
824 // There is no subcollection
825 if (sub_nodes < 1)
826 {
827 return;
828 }
829
830 for (int i = 0; i < sub_nodes; i++)
831 {
832 Element sub_child = (Element) sub_children.item(i);
833 String name_str = sub_child.getAttribute(StaticStrings.NAME_ATTRIBUTE);
834 String filter_str = sub_child.getAttribute(StaticStrings.FILTER_ATTRIBUTE);
835
836 // filter_str is in the form '<! (if set)><metadata>/<metadata value>/<flag (if any)>'
837
838 int pos = filter_str.indexOf(StaticStrings.SEPARATOR_CHARACTER);
839 String meta_str = "";
840 String meta_value_str = "";
841 String clude_str = "";
842 String flag_str = "";
843 if (pos == -1)
844 {
845
846 meta_str = meta_value_str = filter_str;
847 clude_str = StaticStrings.INCLUDE_STR;
848 }
849 else
850 {
851 clude_str = StaticStrings.INCLUDE_STR;
852 if (filter_str.startsWith(StaticStrings.EXCLAMATION_CHARACTER))
853 {
854 clude_str = StaticStrings.EXCLUDE_STR;
855 // Peel off "!"
856 filter_str = filter_str.substring(StaticStrings.EXCLAMATION_CHARACTER.length());
857 }
858
859 String[] strs = filter_str.split(StaticStrings.SEPARATOR_CHARACTER);
860 if (strs[0] != null && strs[0] != "")
861 {
862 meta_str = strs[0];
863 }
864 if (!meta_str.equals(StaticStrings.FILENAME_STR) && meta_str.indexOf(StaticStrings.NS_SEP) == -1)
865 {
866 meta_str = StaticStrings.EXTRACTED_NAMESPACE + meta_str;
867 }
868
869 if (strs[1] != null && strs[1] != "")
870 {
871 meta_value_str = strs[1];
872 }
873 if (strs.length > 2)
874 {
875 //This means there has been set a flag
876 if (strs[2] != null && strs[2] != "")
877 {
878 flag_str = strs[2];
879 }
880 }
881 }
882 Element subcollection_element = to.createElement(StaticStrings.SUBCOLLECTION_ELEMENT);
883 subcollection_element.setAttribute(StaticStrings.NAME_STR, name_str);
884 subcollection_element.setAttribute(StaticStrings.CONTENT_ATTRIBUTE, meta_str);
885 subcollection_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, clude_str);
886 if (flag_str != "")
887 {
888 subcollection_element.setAttribute(StaticStrings.OPTIONS_ATTRIBUTE, flag_str);
889 }
890 XMLTools.setNodeText(subcollection_element, meta_value_str);
891
892 toElement.appendChild(subcollection_element);
893 }
894 }
895
896 //Handle levels (document, section). In the internal structure, the element is called 'IndexOption'
897 static private void doLevel(Document to, Node searchNode)
898 {
899 Element toElement = to.getDocumentElement();
900 NodeList level_children = ((Element) searchNode).getElementsByTagName(StaticStrings.LEVEL_ATTRIBUTE);
901 int level_nodes = level_children.getLength();
902
903 // it's mg, there's no level. So we construct a default 'indexOption' in the internal structure
904 if (level_nodes < 1)
905 {
906 Element index_option = to.createElement(StaticStrings.INDEXOPTIONS_ELEMENT);
907 index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
908 index_option.setAttribute(StaticStrings.NAME_STR, StaticStrings.LEVELS_STR);
909
910 Element option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
911 option_element.setAttribute(StaticStrings.NAME_STR, StaticStrings.DOCUMENT_STR);
912 index_option.appendChild(option_element);
913
914 appendProperly(toElement, index_option);
915
916 return;
917 }
918
919 Element index_option = to.createElement(StaticStrings.INDEXOPTIONS_ELEMENT);
920 index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
921 index_option.setAttribute(StaticStrings.NAME_STR, StaticStrings.LEVELS_STR);
922
923 for (int i = 0; i < level_nodes; i++)
924 {
925 Element level_element = (Element) level_children.item(i);
926 String level_str = level_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
927 Element option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
928 option_element.setAttribute(StaticStrings.NAME_STR, level_str);
929 index_option.appendChild(option_element);
930
931 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'level' element
932 ArrayList displayItem_list = XMLTools.getNamedElementList(level_element, StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
933 if (displayItem_list == null)
934 {
935 return;
936 }
937 for (int j = 0; j < displayItem_list.size(); j++)
938 {
939 Element item = (Element) displayItem_list.get(j);
940 String text = XMLTools.getNodeText(item);
941 String lang = item.getAttribute(StaticStrings.LANG_ATTRIBUTE);
942
943 //If there is nothing to display, don't bother creating the element
944 if (text == "")
945 {
946 continue;
947 }
948 Element collectionmetadata = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
949 collectionmetadata.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
950 collectionmetadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, level_str);
951 collectionmetadata.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, lang);
952 XMLTools.setNodeText(collectionmetadata, text);
953
954 appendProperly(toElement, collectionmetadata);
955 }
956 }
957 appendProperly(toElement, index_option);
958 }
959
960 //Handle 'indexSubcollection' element of collectionConfig.xml, which is called 'SubcollectionIndexes' in the internal structure. These contain the subcollection indexes (i.e. the filter or filter combinations), and displayed words for the filter names.
961 static private void doIndexSubcollection(Document to, Node searchNode)
962 {
963 Element toElement = to.getDocumentElement();
964 NodeList index_sub_children = ((Element) searchNode).getElementsByTagName(StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
965 int num_nodes = index_sub_children.getLength();
966
967 // there is no subcollection index
968 if (num_nodes < 1)
969 {
970 return;
971 }
972
973 Element subcollection_indexes = to.createElement(StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
974
975 for (int i = 0; i < num_nodes; i++)
976 {
977 Element index_element = to.createElement(StaticStrings.INDEX_ELEMENT);
978 Element index_sub_child = (Element) index_sub_children.item(i);
979 String name_str = index_sub_child.getAttribute(StaticStrings.NAME_ATTRIBUTE);
980
981 // name_str is in the form of comma separated strings, each of which is a subcollection filter name
982 String[] filters = name_str.split(StaticStrings.COMMA_CHARACTER);
983 for (int j = 0; j < filters.length; j++)
984 {
985
986 Element content_element = to.createElement(StaticStrings.CONTENT_ELEMENT);
987 content_element.setAttribute(StaticStrings.NAME_STR, filters[j]);
988 index_element.appendChild(content_element);
989 }
990 subcollection_indexes.appendChild(index_element);
991
992 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'indexSubcollection' element
993 ArrayList displayItem_list = XMLTools.getNamedElementList(index_sub_child, StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
994 if (displayItem_list == null)
995 {
996 // there is no display item for this element
997 continue;
998 }
999 for (int j = 0; j < displayItem_list.size(); j++)
1000 {
1001 Element item = (Element) displayItem_list.get(j);
1002 String text = XMLTools.getNodeText(item);
1003 String lang = item.getAttribute(StaticStrings.LANG_ATTRIBUTE);
1004
1005 //If there is nothing to display, don't bother creating the element
1006 if (text == "")
1007 {
1008 continue;
1009 }
1010 Element collectionmetadata = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
1011 collectionmetadata.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1012 collectionmetadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1013 collectionmetadata.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, lang);
1014 XMLTools.setNodeText(collectionmetadata, text);
1015
1016 appendProperly(toElement, collectionmetadata);
1017 }
1018 }
1019 appendProperly(toElement, subcollection_indexes);
1020 }
1021
1022 //Handle 'indexLanguage' element of collectionConfig.xml, which is called 'Languages' in the internal structure. These contain the language indexes, and displayed words for those language index names.
1023 static private void doIndexLanguage(Document to, Node searchNode)
1024 {
1025 Element toElement = to.getDocumentElement();
1026 NodeList index_sub_children = ((Element) searchNode).getElementsByTagName(StaticStrings.LANGUAGE_INDEX_ELEMENT);
1027 int num_nodes = index_sub_children.getLength();
1028
1029 // there is no subcollection index
1030 if (num_nodes < 1)
1031 {
1032 return;
1033 }
1034
1035 Element language_indexes = to.createElement(StaticStrings.LANGUAGES_ELEMENT);
1036
1037 for (int i = 0; i < num_nodes; i++)
1038 {
1039 Element language_element = to.createElement(StaticStrings.LANGUAGE_ELEMENT);
1040 Element index_sub_child = (Element) index_sub_children.item(i);
1041 String name_str = index_sub_child.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1042 language_element.setAttribute(StaticStrings.NAME_STR, name_str);
1043 language_indexes.appendChild(language_element);
1044
1045 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'indexLanguage' element
1046 ArrayList displayItem_list = XMLTools.getNamedElementList(index_sub_child, StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
1047 if (displayItem_list == null)
1048 {
1049 // there is no display item for this element
1050 continue;
1051 }
1052 for (int j = 0; j < displayItem_list.size(); j++)
1053 {
1054 Element item = (Element) displayItem_list.get(j);
1055 String text = XMLTools.getNodeText(item);
1056 String lang = item.getAttribute(StaticStrings.LANG_ATTRIBUTE);
1057
1058 //If there is nothing to display, don't bother creating the element
1059 if (text == "")
1060 {
1061 continue;
1062 }
1063 Element collectionmetadata = to.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
1064 collectionmetadata.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1065 collectionmetadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1066 collectionmetadata.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, lang);
1067 XMLTools.setNodeText(collectionmetadata, text);
1068
1069 appendProperly(toElement, collectionmetadata);
1070 }
1071 }
1072 toElement.appendChild(language_indexes);
1073 }
1074
1075 // Handling search types
1076 static private void doSearchType(Document to, Node searchNode)
1077 {
1078 NodeList type_children = ((Element) searchNode).getElementsByTagName(StaticStrings.SEARCHTYPE_ELEMENT);
1079 int num_types = type_children.getLength();
1080 String searchtype_str = "";
1081 if (num_types < 1)
1082 {
1083 // not defined yet, add in default
1084 searchtype_str = "plain,simpleform,advancedform";
1085 }
1086 else
1087 {
1088 for (int i = 0; i < num_types; i++)
1089 {
1090 Node e = type_children.item(i);
1091 String t = ((Element) e).getAttribute(StaticStrings.NAME_ATTRIBUTE);
1092 if (i > 0)
1093 {
1094 searchtype_str += ",";
1095 }
1096 searchtype_str += t;
1097 }
1098 }
1099 searchtype_str = searchtype_str.trim();
1100
1101 // pretend its a format statement
1102 Element search_type_element = to.createElement(StaticStrings.FORMAT_STR);
1103 search_type_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);
1104 XMLTools.setNodeText(search_type_element, searchtype_str);
1105 appendProperly(to.getDocumentElement(), search_type_element);
1106
1107 }
1108
1109 // Handling search format statement
1110 static private void doSearchFormat(Document to, Node searchNode)
1111 {
1112 // THere is currently just one format element for search. HOwever, need to check for old config files which used to have <format name="searchTypes">
1113 NodeList format_children = ((Element) searchNode).getElementsByTagName(StaticStrings.FORMAT_STR);
1114 int format_nodes = format_children.getLength();
1115 if (format_nodes < 1)
1116 {
1117 return;
1118 }
1119 Element format = null;
1120 for (int i = 0; i < format_nodes; i++)
1121 {
1122 Node e = format_children.item(i);
1123 if (e.hasAttributes() == false)
1124 {
1125 //The format element for format statement has no attribute
1126 format = (Element) e;
1127 }
1128 }
1129 //format statement for search
1130 if (format != null)
1131 {
1132 (to.getDocumentElement()).appendChild(doFormat(to, format, StaticStrings.SEARCH_STR));
1133 }
1134 }
1135
1136 // Handling defaultIndexLanguage and languageMetadata in collectionConfig.xml ('elementNameFrom'); in the internal structure, they are called 'DefaultLanguage' and 'LanguageMetadata' ('elementNameTo') respectively.
1137 // Converting from collectionConfig.xml to the internal xml structure.
1138 static private void doLanguageMetadata(Document to, Node searchNode)
1139 {
1140 Element toElement = to.getDocumentElement();
1141 String elementNameFrom = StaticStrings.LANGUAGE_METADATA_ELEMENT_STR;
1142 String elementNameTo = StaticStrings.LANGUAGE_METADATA_ELEMENT;
1143 Node from_element = XMLTools.getChildByTagName(searchNode, elementNameFrom);
1144 if (from_element == null)
1145 {
1146 return; // such an element not found
1147 }
1148
1149 Element to_element = to.createElement(elementNameTo);
1150
1151 String name_str = ((Element) from_element).getAttribute(StaticStrings.NAME_ATTRIBUTE);
1152 if (name_str.indexOf(StaticStrings.NS_SEP) == -1)
1153 {
1154 name_str = StaticStrings.EXTRACTED_NAMESPACE + name_str;
1155 }
1156 to_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1157 to_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1158
1159 toElement.appendChild(to_element);
1160 }
1161
1162 static private void doReplaceListRef(Document to, Element from)
1163 {
1164 Element toElement = to.getDocumentElement();
1165
1166 NodeList replace_elements = from.getElementsByTagName(StaticStrings.REPLACELISTREF_STR);
1167 XMLTools.duplicateElementList(to, toElement, replace_elements, true);
1168 }
1169
1170 // int num_elems = replace_elements.getLength();
1171 // if (num_elems < 1)
1172 // {
1173 // return;
1174 // }
1175 // for (int i = 0; i < num_elems; i++)
1176 // {
1177 // Element to_element = XMLTools.duplicateElement(to, (Element) replace_elements.item(i), true);
1178 // toElement.appendChild(to_element);
1179 // }
1180 // }
1181
1182 static private void convertReplaceListRef(Document from, Document to)
1183 {
1184 Element toElement = to.getDocumentElement();
1185
1186 NodeList replace_elements = from.getDocumentElement().getElementsByTagName(StaticStrings.REPLACELISTREF_STR);
1187 XMLTools.duplicateElementList(to, toElement, replace_elements, true);
1188 }
1189
1190 // int num_elems = replace_elements.getLength();
1191 // if (num_elems < 1)
1192 // {
1193 // return;
1194 // }
1195 // for (int i = 0; i < num_elems; i++)
1196 // {
1197 // Element to_element = XMLTools.duplicateElement(to, (Element) replace_elements.item(i), true);
1198 // toElement.appendChild(to_element);
1199 // }
1200 // }
1201
1202 /*
1203 * replacelist currently not editable in GLI, just copy it in and back out
1204 * again
1205 */
1206 static private void doReplaceList(Document to, Element from)
1207 {
1208 Element toElement = to.getDocumentElement();
1209
1210 Node rl_element = XMLTools.getChildByTagName(from, StaticStrings.REPLACELIST_STR);
1211 if (rl_element == null)
1212 {
1213 return; // such an element not found
1214 }
1215
1216 Element to_element = XMLTools.duplicateElement(to, (Element) rl_element, true);
1217 toElement.appendChild(to_element);
1218 }
1219
1220 static private void convertReplaceList(Document from, Document to)
1221 {
1222 Element toElement = to.getDocumentElement();
1223
1224 Node rl_element = XMLTools.getChildByTagName(from.getDocumentElement(), StaticStrings.REPLACELIST_STR);
1225 if (rl_element == null)
1226 {
1227 return; // such an element not found
1228 }
1229
1230 Element to_element = XMLTools.duplicateElement(to, (Element) rl_element, true);
1231 toElement.appendChild(to_element);
1232 }
1233
1234 /**
1235 * serviceRackList is currently not editable in GLI - just copy it in from
1236 * config file and write it out again.
1237 */
1238 static private void doServiceRackList(Document to, Element from)
1239 {
1240 Element toElement = to.getDocumentElement();
1241
1242 Node srl_element = XMLTools.getChildByTagName(from, StaticStrings.SERVICE_RACK_LIST_ELEMENT);
1243 if (srl_element == null)
1244 {
1245 return; // such an element not found
1246 }
1247
1248 Element to_element = XMLTools.duplicateElement(to, (Element) srl_element, true);
1249 toElement.appendChild(to_element);
1250 }
1251
1252 static private void convertServiceRackList(Document from, Document to)
1253 {
1254 Element toElement = to.getDocumentElement();
1255
1256 Node srl_element = XMLTools.getChildByTagName(from.getDocumentElement(), StaticStrings.SERVICE_RACK_LIST_ELEMENT);
1257 if (srl_element == null)
1258 {
1259 return; // such an element not found
1260 }
1261
1262 Element to_element = XMLTools.duplicateElement(to, (Element) srl_element, true);
1263 toElement.appendChild(to_element);
1264 }
1265
1266 static private void doDefaultIndexLanguage(Document to, Node searchNode)
1267 {
1268 Element toElement = to.getDocumentElement();
1269 String elementNameFrom = StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT;
1270 String elementNameTo = StaticStrings.LANGUAGE_DEFAULT_ELEMENT;
1271 Node from_element = XMLTools.getChildByTagName(searchNode, elementNameFrom);
1272 if (from_element == null)
1273 {
1274 return; // such an element not found
1275 }
1276
1277 Element to_element = to.createElement(elementNameTo);
1278
1279 String name_str = ((Element) from_element).getAttribute(StaticStrings.NAME_ATTRIBUTE);
1280 to_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1281 to_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1282
1283 toElement.appendChild(to_element);
1284 }
1285
1286 //Handle 'indexOption' (i.e. casefold, stem etc). In the internal structure, the element is called 'IndexOption'
1287 static private void doIndexOption(Document to, Node searchNode)
1288 {
1289 Element toElement = to.getDocumentElement();
1290 //Node index_option_node = XMLTools.getChildByTagName(searchNode, StaticStrings.INDEXOPTION_STR);
1291 //if (index_option_node == null)
1292 //{
1293 // return;
1294 //}
1295 //NodeList option_children = ((Element) index_option_node).getElementsByTagName(StaticStrings.OPTION_STR);
1296 NodeList option_children = ((Element) searchNode).getElementsByTagName(StaticStrings.INDEXOPTION_STR);
1297 int num_options = option_children.getLength();
1298
1299 // for lucene, there is no 'indexOption'. We build a default 'indexOption' and 'assigned=false' in case the user switches to mg or mgpp
1300 if (num_options < 1)
1301 {
1302 Element index_option = to.createElement(StaticStrings.INDEXOPTIONS_ELEMENT);
1303 index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
1304 index_option.setAttribute(StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
1305 String[] option_str = { StaticStrings.CASEFOLD_OPTION_STR, StaticStrings.STEM_OPTION_STR };
1306 for (int i = 0; i < option_str.length; i++)
1307 {
1308 Element option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
1309 option_element.setAttribute(StaticStrings.NAME_STR, option_str[i]);
1310 index_option.appendChild(option_element);
1311 }
1312 appendProperly(toElement, index_option);
1313 return;
1314 }
1315
1316 Element index_option = to.createElement(StaticStrings.INDEXOPTIONS_ELEMENT);
1317 index_option.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1318 index_option.setAttribute(StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
1319
1320 for (int i = 0; i < num_options; i++)
1321 {
1322 String option_str = ((Element) option_children.item(i)).getAttribute(StaticStrings.NAME_ATTRIBUTE);
1323 Element option_element = to.createElement(StaticStrings.OPTION_ELEMENT);
1324 option_element.setAttribute(StaticStrings.NAME_STR, option_str);
1325 index_option.appendChild(option_element);
1326 }
1327 appendProperly(toElement, index_option);
1328 }
1329
1330 static private Element doBuildType(Document to, String att_value)
1331 {
1332
1333 //construct 'BuildType' element
1334 Element element = to.createElement(StaticStrings.BUILDTYPE_ELEMENT);
1335 element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
1336 element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
1337 element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1338 element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
1339
1340 XMLTools.setNodeText(element, att_value);
1341
1342 return element;
1343 }
1344
1345 static private Element doDatabaseType(Document to, String att_value)
1346 {
1347
1348 //construct 'DatabaseType' element
1349 Element element = to.createElement(StaticStrings.DATABASETYPE_ELEMENT);
1350 element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.DATABASETYPE_STR);
1351 element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
1352 element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1353 element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
1354
1355 XMLTools.setNodeText(element, att_value);
1356
1357 return element;
1358 }
1359
1360 // Convert 'description', 'smallicon' etc.
1361 static private void convertDisplayItemList(Document from, Document to)
1362 {
1363 Element displayItemList = to.createElement(StaticStrings.DISPLAYITEMLIST_STR);
1364 Element destination = to.getDocumentElement();
1365
1366 // certain special collectionmeta elements should have different names
1367 // as displayItems in the collectionConfig.xml than they do in memory
1368 Map attributeMap = new HashMap(4);
1369 attributeMap.put(StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR, StaticStrings.DESCRIPTION_STR);
1370 attributeMap.put(StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR, StaticStrings.NAME_STR);
1371 attributeMap.put(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR, StaticStrings.SMALLICON_STR);
1372 attributeMap.put(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR, StaticStrings.ICON_STR);
1373
1374 NodeList e_list = from.getDocumentElement().getElementsByTagName(StaticStrings.COLLECTIONMETADATA_ELEMENT);
1375 // if such elements don't exist, don't bother
1376 if (e_list != null)
1377 {
1378
1379 for (int j = 0; j < e_list.getLength(); j++)
1380 {
1381 Element e = (Element) e_list.item(j);
1382 if (e.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1383 {
1384 continue;
1385 }
1386 String text = XMLTools.getNodeText(e);
1387 String lang = e.getAttribute(StaticStrings.LANGUAGE_ATTRIBUTE);
1388 String name_value = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1389
1390 String name_mapping = (String) attributeMap.get(name_value);
1391 if (name_mapping != null)
1392 {
1393 name_value = name_mapping;
1394 }
1395
1396 Element displayItem = constructElement(StaticStrings.DISPLAYITEM_STR, name_value, StaticStrings.LANG_STR, lang, text, to);
1397 displayItemList.appendChild(displayItem);
1398 }
1399
1400 }
1401 destination.appendChild(displayItemList);
1402 }
1403
1404 // This method creates a DisplayItem element of the type of 'to' by using the ingredients from the element 'e'
1405 static private Element constructDisplayItem(Element e, Document to)
1406 {
1407 String lang_string = e.getAttribute(StaticStrings.LANGUAGE_ATTRIBUTE);
1408 String text = XMLTools.getNodeText(e);
1409 Element displayItem = to.createElement(StaticStrings.DISPLAYITEM_STR);
1410 displayItem.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_ATTRIBUTE);
1411 displayItem.setAttribute(StaticStrings.LANG_STR, lang_string);
1412 XMLTools.setNodeText(displayItem, text);
1413 return displayItem;
1414 }
1415
1416 static private void convertMetadataList(Document from, Document to)
1417 {
1418 Element metadataList = to.createElement(StaticStrings.METADATALIST_STR);
1419 Element destination = to.getDocumentElement();
1420
1421 String[] ele_names = { StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT };
1422 String[] att_names = { StaticStrings.COLLECTIONMETADATA_CREATOR_STR, StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR, StaticStrings.COLLECTIONMETADATA_PUBLIC_STR };
1423 for (int i = 0; i < ele_names.length; i++)
1424 {
1425 Element e = XMLTools.getNamedElement(from.getDocumentElement(), ele_names[i], StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1426 if (e == null)
1427 {
1428 continue;
1429 }
1430 String text = XMLTools.getNodeText(e);
1431 Element metadata = to.createElement(StaticStrings.METADATA_STR);
1432 metadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1433 metadata.setAttribute(StaticStrings.LANG_STR, StaticStrings.ENGLISH_LANGUAGE_STR);
1434 XMLTools.setNodeText(metadata, text);
1435 metadataList.appendChild(metadata);
1436 }
1437
1438 destination.appendChild(metadataList);
1439 }
1440
1441 // This method creates an element with the name 'element_name' of the type of 'to' by using the other three strings
1442 static private Element constructElement(String element_name, String name_value, String lang_att, String lang_value, String text, Document to)
1443 {
1444 Element e = to.createElement(element_name);
1445 e.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1446 e.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_value);
1447 e.setAttribute(lang_att, lang_value);
1448 XMLTools.setNodeText(e, text);
1449
1450 return e;
1451 }
1452
1453 // Convert classify in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1454 static private void convertClassifier(Document from, Document to)
1455 {
1456 Element browse_element = to.createElement(StaticStrings.BROWSE_STR);
1457 NodeList children = from.getDocumentElement().getElementsByTagName(StaticStrings.CLASSIFY_ELEMENT);
1458
1459 int num_children = (children == null) ? 0 : children.getLength();
1460
1461 if (num_children == 0)
1462 {
1463 return;
1464 }
1465
1466 for (int i = 0; i < num_children; i++)
1467 {
1468
1469 Element child = (Element) children.item(i);
1470 if (child.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1471 {
1472 continue;
1473 }
1474 String str = child.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1475 Element classifier_element = to.createElement(StaticStrings.CLASSIFIER_STR);
1476 classifier_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, str);
1477
1478 NodeList option_children = child.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
1479 for (int j = 0; j < option_children.getLength(); j++)
1480 {
1481 Element el = (Element) option_children.item(j);
1482 if (el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1483 {
1484 continue;
1485 }
1486 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1487 String value_str = XMLTools.getNodeText(el);
1488
1489 if (name_str == null && value_str == null)
1490 {
1491 continue;
1492 }
1493 Element option_element = to.createElement(StaticStrings.OPTION_STR);
1494 if (name_str != null && name_str.equals(StaticStrings.METADATA_STR))
1495 {
1496
1497 // The metadata argument is the fully qualified name of a metadata element, so if it contains a namespace, remove the extracted metadata namespace as the build process doesn't know about it.
1498 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
1499 value_str = "";
1500 for (int k = 0; k <= values.length - 1; k++)
1501 {
1502 if (values[k].startsWith(StaticStrings.EXTRACTED_NAMESPACE) && values[k].indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1503 {
1504 values[k] = values[k].substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1505 }
1506 else
1507 {
1508 MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName(values[k]);
1509 if (metadata_element != null)
1510 {
1511 values[k] = metadata_element.getFullName();
1512 }
1513 }
1514 if (k < values.length - 1)
1515 {
1516 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1517 }
1518 else
1519 {
1520 value_str = value_str + values[k];
1521 }
1522 }
1523 }
1524
1525 if (!name_str.equals(""))
1526 {
1527 if (!name_str.startsWith(StaticStrings.MINUS_CHARACTER))
1528 {
1529 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1530 }
1531 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1532 }
1533
1534 if (!value_str.equals(""))
1535 {
1536 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
1537 }
1538
1539 classifier_element.appendChild(option_element);
1540 }
1541
1542 //format element for this classifier
1543 Element e = (Element) XMLTools.getChildByTagName(child, StaticStrings.FORMAT_STR);
1544
1545 if (e != null)
1546 {
1547 classifier_element.appendChild(convertFormat(to, e));
1548 }
1549 browse_element.appendChild(classifier_element);
1550 }
1551
1552 //convert default classifier format
1553 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.BROWSE_STR);
1554 browse_element.appendChild(convertFormat(to, e));
1555
1556 to.getDocumentElement().appendChild(browse_element);
1557 }
1558
1559 static private Element convertFormat(Document to, Element e)
1560 {
1561 String format_str = XMLTools.getNodeText(e);
1562 Element format = to.createElement(StaticStrings.FORMAT_STR);
1563 //XMLTools.copyAllChildren (format, e);
1564 XMLTools.setNodeText(format, format_str);
1565 return format;
1566 }
1567
1568 //convert format statement for search
1569 static private void convertSearchFormat(Document from, Document to)
1570 {
1571 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1572 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCH_STR);
1573
1574 search.appendChild(convertFormat(to, e));
1575
1576 }
1577
1578 //convert format statement for display of the documents
1579 static private void convertDisplayFormat(Document from, Document to)
1580 {
1581 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.DISPLAY_STR);
1582 if (e == null)
1583 {
1584 return;
1585 }
1586 Element display = to.createElement(StaticStrings.DISPLAY_STR);
1587 display.appendChild(convertFormat(to, e));
1588 to.getDocumentElement().appendChild(display);
1589 }
1590
1591 // convert global format statement
1592 static private void convertGlobalFormat(Document from, Document to)
1593 {
1594 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.GLOBAL_STR);
1595
1596 to.getDocumentElement().appendChild(convertFormat(to, e));
1597
1598 }
1599
1600 // Convert plugins in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1601 static private void convertPlugin(Document from, Document to)
1602 {
1603 Element import_element = to.createElement(StaticStrings.IMPORT_STR);
1604 Element plugin_list_element = to.createElement(StaticStrings.PLUGINLIST_STR);
1605
1606 NodeList children = from.getDocumentElement().getElementsByTagName(StaticStrings.PLUGIN_ELEMENT);
1607 int num_children = (children == null) ? 0 : children.getLength();
1608 if (num_children == 0)
1609 {
1610 return;
1611 }
1612
1613 for (int i = 0; i < num_children; i++)
1614 {
1615
1616 Element child = (Element) children.item(i);
1617 if (child.getAttribute(StaticStrings.SEPARATOR_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
1618 {
1619 continue;
1620 }
1621 if (child.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1622 {
1623 continue;
1624 }
1625
1626 String str = child.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1627 Element plugin_element = to.createElement(StaticStrings.PLUGIN_STR);
1628 plugin_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, str);
1629
1630 NodeList option_children = child.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
1631 for (int j = 0; j < option_children.getLength(); j++)
1632 {
1633 Element el = (Element) option_children.item(j);
1634 if (!el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
1635 {
1636 continue;
1637 }
1638 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1639 String value_str = XMLTools.getNodeText(el);
1640
1641 if (name_str == null && value_str == null)
1642 {
1643 continue;
1644 }
1645 Element option_element = to.createElement(StaticStrings.OPTION_STR);
1646 if (name_str != null && name_str.equals(StaticStrings.METADATA_STR))
1647 {
1648
1649 // The metadata argument is the fully qualified name of a metadata element, so if it contains a namespace, remove the extracted metadata namespace as the build process doesn't know about it, but ONLY if it is not embedded metadata (e.g. ex.dc.*)
1650 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
1651 value_str = "";
1652 for (int k = 0; k <= values.length - 1; k++)
1653 {
1654 if (values[k].startsWith(StaticStrings.EXTRACTED_NAMESPACE) && values[k].indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1655 {
1656 values[k] = values[k].substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1657 }
1658
1659 if (k < values.length - 1)
1660 {
1661 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1662 }
1663 else
1664 {
1665 value_str = value_str + values[k];
1666 }
1667 }
1668 }
1669
1670 if (!name_str.equals(""))
1671 {
1672 if (!name_str.startsWith(StaticStrings.MINUS_CHARACTER))
1673 {
1674 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1675 }
1676 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1677 }
1678
1679 if (!value_str.equals(""))
1680 {
1681 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
1682 }
1683
1684 plugin_element.appendChild(option_element);
1685 }//for loop ends
1686
1687 plugin_list_element.appendChild(plugin_element);
1688 }//for loop ends
1689
1690 import_element.appendChild(plugin_list_element);
1691
1692 //do the plugout element (used by building flax collections)
1693 Node plugout = XMLTools.getChildByTagNameIndexed(from.getDocumentElement(), PLUGOUT_ELEMENT, 0);
1694 if (plugout != null)
1695 {
1696 Element to_element = XMLTools.duplicateElement(to, (Element) plugout, true);
1697 import_element.appendChild(to_element);
1698 }
1699
1700 to.getDocumentElement().appendChild(import_element);
1701 }
1702
1703 //Handle 'searchType' of collectionConfig.xml. In the internal structure, its also called 'searchType', eg. plain, form
1704 static private void convertSearchType(Document from, Document to)
1705 {
1706 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);//searchType
1707
1708 if (e == null)
1709 {
1710 return;
1711 }
1712 String searchtype_str = XMLTools.getNodeText(e).trim();
1713 //Get the 'search' element from 'to'
1714 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1715
1716 String[] types = searchtype_str.split(",");
1717 for (int i = 0; i < types.length; i++)
1718 {
1719 Element search_type_element = to.createElement(StaticStrings.SEARCHTYPE_ELEMENT);
1720 search_type_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, types[i]);
1721 search.appendChild(search_type_element);
1722 }
1723 }
1724
1725 static private void convertBuildType(Document from, Document to)
1726 {
1727 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.BUILDTYPE_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
1728 if (e == null)
1729 {
1730 return;
1731 }
1732 String indexer = XMLTools.getNodeText(e);
1733 Element search = to.createElement(StaticStrings.SEARCH_STR);
1734 search.setAttribute(StaticStrings.TYPE_ATTRIBUTE, indexer);
1735 to.getDocumentElement().appendChild(search);
1736 }
1737
1738 static private void convertDatabaseType(Document from, Document to)
1739 {
1740 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.DATABASETYPE_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.DATABASETYPE_STR);
1741 if (e == null)
1742 {
1743 return;
1744 }
1745 String db = XMLTools.getNodeText(e);
1746 Element dbtype = to.createElement(StaticStrings.INFODB_STR);
1747 dbtype.setAttribute(StaticStrings.TYPE_ATTRIBUTE, db);
1748 to.getDocumentElement().appendChild(dbtype);
1749 }
1750
1751 static private void convertDefaultIndex(Document from, Document to, Element search)
1752 {
1753 Element source = from.getDocumentElement();
1754
1755 Element default_index_element = (Element) XMLTools.getChildByTagName(source, StaticStrings.INDEX_DEFAULT_ELEMENT);
1756 if (default_index_element == null)
1757 {
1758 return;
1759 }
1760
1761 String indexer = search.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1762 String level_str = default_index_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE);
1763 // Debugging purposes
1764 if (level_str.equals("") && indexer.equals(StaticStrings.MG_STR))
1765 {
1766 System.out.println("Bug: DefaultIndex should have its level attribute not empty.");
1767 }
1768
1769 NodeList content_elements = default_index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
1770 int content_elements_length = content_elements.getLength();
1771
1772 // Don't output anything if no indexes are set
1773 if (content_elements_length == 0)
1774 {
1775 return;//
1776 }
1777
1778 String index_str = "";
1779
1780 if (indexer.equals(StaticStrings.MG_STR))
1781 {
1782 //combine level with indexes
1783 index_str = level_str + StaticStrings.COLON_CHARACTER;
1784 }
1785 else
1786 { //for mgpp/lucene, just take index
1787 //do nothing
1788 }
1789
1790 for (int k = 0; k < content_elements_length; k++)
1791 {
1792 Element content_element = (Element) content_elements.item(k);
1793 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1794 {
1795 continue;
1796 }
1797 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1798
1799 if (name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_str.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1800 {
1801 name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1802 }
1803
1804 index_str = index_str + name_str;
1805
1806 // Make it comma separated string
1807 if (k < content_elements_length - 1)
1808 {
1809 index_str = index_str + StaticStrings.COMMA_CHARACTER;
1810 }
1811 content_element = null;
1812 }//for loop ends
1813
1814 Element default_index = to.createElement(StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);
1815 default_index.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_str);
1816 search.appendChild(default_index);
1817
1818 }
1819
1820 static private void convertSubcollection(Document from, Document to)
1821 {
1822 Element source = from.getDocumentElement();
1823 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1824 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1825
1826 // Get the Subcollection element from the internal structure
1827 NodeList subcollection_elements = source.getElementsByTagName(StaticStrings.SUBCOLLECTION_ELEMENT);
1828 if (subcollection_elements == null)
1829 {
1830 return;
1831 }
1832 int subcollection_elements_length = subcollection_elements.getLength();
1833
1834 if (subcollection_elements_length == 0)
1835 { // no
1836 return;
1837 }
1838
1839 for (int j = 0; j < subcollection_elements_length; j++)
1840 {
1841
1842 Element e = (Element) subcollection_elements.item(j);
1843 if (e.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1844 {
1845 continue;
1846 }
1847 String content = e.getAttribute(StaticStrings.CONTENT_ATTRIBUTE);
1848 String name = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1849 String options = e.getAttribute(StaticStrings.OPTIONS_ATTRIBUTE);
1850 String type = e.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1851 String text = XMLTools.getNodeText(e);
1852
1853 String filter = "";
1854 if (type.equals(StaticStrings.EXCLUDE_STR))
1855 {
1856 filter = StaticStrings.EXCLAMATION_CHARACTER;
1857 }
1858
1859 if (content.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && content.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1860 {
1861 content = content.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1862 }
1863 filter = filter + content + StaticStrings.SEPARATOR_CHARACTER + text;
1864 if (options != null && options != "")
1865 {
1866 filter = filter + StaticStrings.SEPARATOR_CHARACTER + options;
1867 }
1868 Element subcollection = to.createElement(StaticStrings.SUBCOLLECTION_STR);
1869 subcollection.setAttribute(StaticStrings.FILTER_ATTRIBUTE, filter);
1870 subcollection.setAttribute(StaticStrings.NAME_ATTRIBUTE, name);
1871
1872 search.appendChild(subcollection);
1873 }
1874 }
1875
1876 static private void convertSubcollectionIndexes(Document from, Document to)
1877 {
1878 Element source = from.getDocumentElement();
1879 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1880 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1881
1882 // Get the SubcollectionIndexes element from the internal structure
1883 Element subcollection_indexes = (Element) XMLTools.getChildByTagName(source, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
1884 if (subcollection_indexes == null)
1885 {
1886 return;
1887 }
1888 NodeList index_elements = subcollection_indexes.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
1889 int index_elements_length = index_elements.getLength();
1890
1891 if (index_elements_length == 0)
1892 { // no indexes
1893 return;
1894 }
1895
1896 for (int j = 0; j < index_elements_length; j++)
1897 {
1898 Element index_element = (Element) index_elements.item(j);
1899 if (index_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1900 {
1901 continue;
1902 }
1903
1904 Element index = to.createElement(StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
1905
1906 String index_value = "";
1907
1908 NodeList content_elements = index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
1909 int content_elements_length = content_elements.getLength();
1910
1911 for (int k = 0; k < content_elements_length; k++)
1912 {
1913 Element content_element = (Element) content_elements.item(k);
1914 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1915 {
1916 continue;
1917 }
1918 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1919 index_value += name_str;
1920 // Make it comma separated string
1921 if (k < content_elements_length - 1)
1922 {
1923 index_value += StaticStrings.COMMA_CHARACTER;
1924 }
1925 content_element = null;
1926 }//for loop ends
1927
1928 index.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_value);
1929
1930 // Now constructing 'displayItem' element for this 'indexSubcollection' element
1931 // from the collectionmetadata element
1932 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, index_value);
1933
1934 if (collectionmetadata_list != null)
1935 {
1936
1937 for (int k = 0; k < collectionmetadata_list.size(); k++)
1938 {
1939 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
1940 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1941 {
1942 continue;
1943 }
1944 Element displayItem = constructDisplayItem(collectionmetadata, to);
1945 index.appendChild(displayItem);
1946 }
1947 }
1948
1949 search.appendChild(index);
1950
1951 } //for loop ends
1952 }
1953
1954 static private void convertLanguages(Document from, Document to)
1955 {
1956 Element source = from.getDocumentElement();
1957 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1958 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1959
1960 // Get the Languages element from the internal structure
1961 Element languages = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGES_ELEMENT);
1962 if (languages == null)
1963 {
1964 return;
1965 }
1966 NodeList language_elements = languages.getElementsByTagName(StaticStrings.LANGUAGE_ELEMENT);
1967 int language_elements_length = language_elements.getLength();
1968
1969 if (language_elements_length == 0)
1970 {
1971 return;
1972 }
1973
1974 for (int j = 0; j < language_elements_length; j++)
1975 {
1976 Element element = (Element) language_elements.item(j);
1977 if (element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1978 {
1979 continue;
1980 }
1981
1982 // Create indexLanguage element
1983 Element index_language = to.createElement(StaticStrings.LANGUAGE_INDEX_ELEMENT);
1984
1985 String name_str = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1986 index_language.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1987
1988 // Now constructing 'displayItem' element for this 'indexLanguage' element
1989 // from the collectionmetadata element
1990 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, name_str);
1991
1992 if (collectionmetadata_list != null)
1993 {
1994
1995 for (int k = 0; k < collectionmetadata_list.size(); k++)
1996 {
1997 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
1998 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1999 {
2000 continue;
2001 }
2002 Element displayItem = constructDisplayItem(collectionmetadata, to);
2003 index_language.appendChild(displayItem);
2004 }
2005 }
2006
2007 search.appendChild(index_language);
2008
2009 } //for loop ends
2010
2011 // Convert DefaultLanguage
2012 // Get the DefaultLanguage element from the internal structure
2013 Element default_language = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGE_DEFAULT_ELEMENT);
2014 if (default_language != null)
2015 {
2016 String lang_name = default_language.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2017 Element default_index_language = to.createElement(StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT);
2018 default_index_language.setAttribute(StaticStrings.NAME_ATTRIBUTE, lang_name);
2019 search.appendChild(default_index_language);
2020 }
2021 // Convert LanguageMetadata
2022 // Get the LanguageMetadata element from the internal structure
2023 Element language_metadata = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGE_METADATA_ELEMENT);
2024 if (language_metadata != null)
2025 {
2026 String meta_name = language_metadata.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2027 Element language_meta = to.createElement(StaticStrings.LANGUAGE_METADATA_ELEMENT_STR);
2028 if (meta_name.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && meta_name.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2029 {
2030 meta_name = meta_name.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2031 }
2032 language_meta.setAttribute(StaticStrings.NAME_ATTRIBUTE, meta_name);
2033 search.appendChild(language_meta);
2034 }
2035 }
2036
2037 //convert indexes and their displayItems, which go in 'search' element in collectionConfig.xml
2038 //parameter 'to' is the document to be saved as collectionConfig.xml
2039 //parameter 'from' is the internal xml structure
2040 static private void convertIndex(Document from, Document to)
2041 {
2042 Element source = from.getDocumentElement();
2043 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
2044 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
2045
2046 //THere are two sets of indexes elements, find the one which is assigned 'true'
2047 Element indexes = XMLTools.getNamedElement(source, StaticStrings.INDEXES_ELEMENT, StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
2048 if (indexes == null)
2049 {
2050 return;
2051 }
2052 NodeList index_elements = indexes.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
2053 int index_elements_length = index_elements.getLength();
2054
2055 if (index_elements_length == 0)
2056 { // no indexes
2057 return;
2058 }
2059
2060 //find out it's mg or mgpp/lucene
2061 String mg = search.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
2062 boolean mg_indexer = false;
2063 if (mg.equals(StaticStrings.MG_STR))
2064 {
2065 mg_indexer = true;//it's mg, then the level is set as attribute of
2066 }
2067 if (mg_indexer == false)
2068 {
2069 // It's mgpp. Construct 'level' and 'defaultLevel' elements separately.
2070 convertLevels(from, to, search);
2071 }
2072
2073 for (int j = 0; j < index_elements_length; j++)
2074 {
2075 Element index_element = (Element) index_elements.item(j);
2076 if (index_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2077 {
2078 continue;
2079 }
2080
2081 Element index_ele = to.createElement(StaticStrings.INDEX_LOW_STR);//index
2082
2083 // Used for creating displayItem for this element 'index_ele' further below
2084 // full_index_names contain 'ex.'
2085 String full_index_name = "";
2086 String level_str = "";
2087
2088 StringBuffer index_value = new StringBuffer();
2089 if (mg_indexer == true)
2090 {
2091 // For mg indexer, there is a 'level' attribute in the index element of the internal structure
2092 // But mgpp/lucene don't
2093 level_str = index_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE);
2094 if (level_str.length() > 0)
2095 {
2096 index_value.append(level_str).append(StaticStrings.COLON_CHARACTER);
2097 //index_value = index_value.StaticStrings.COLON_CHARACTER;
2098 }
2099 }
2100
2101 NodeList content_elements = index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
2102 int content_elements_length = content_elements.getLength();
2103
2104 for (int k = 0; k < content_elements_length; k++)
2105 {
2106 Element content_element = (Element) content_elements.item(k);
2107 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2108 {
2109 continue;
2110 }
2111 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2112
2113 full_index_name = full_index_name + name_str;
2114 if (k < content_elements_length - 1)
2115 {
2116 full_index_name = full_index_name + StaticStrings.COMMA_CHARACTER;
2117 }
2118
2119 if (name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_str.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2120 {
2121 name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2122 }
2123
2124 index_value.append(name_str);
2125 name_str = null;
2126 // Make it comma separated string
2127 if (k < content_elements_length - 1)
2128 {
2129 index_value.append(StaticStrings.COMMA_CHARACTER);
2130 }
2131 content_element = null;
2132 }//for loop ends
2133
2134 String temp_str = index_value.toString();
2135 index_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, temp_str);
2136
2137 // Now constructing 'displayItem' element for this 'index_ele' element
2138 // The index names in the collectionmetadata elements in the internal structure are not the names that
2139 // are used in the content elements (i.e. ex.Source or dc.Subject and keywords), but the names that are
2140 // in the configuration files (i.e. Source or dc.Subject)
2141 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, temp_str);
2142
2143 if (collectionmetadata_list == null)
2144 {
2145 //try the full name, i.e. with 'ex.'
2146 if (mg_indexer == true)
2147 {
2148 // but first append level info if we are mg
2149 full_index_name = level_str + StaticStrings.COLON_CHARACTER + full_index_name;
2150 }
2151 collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, full_index_name);
2152 }
2153
2154 if (collectionmetadata_list != null)
2155 {
2156
2157 for (int k = 0; k < collectionmetadata_list.size(); k++)
2158 {
2159 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
2160 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2161 {
2162 continue;
2163 }
2164 Element displayItem = constructDisplayItem(collectionmetadata, to);
2165
2166 index_ele.appendChild(displayItem);
2167 }
2168 }
2169
2170 // deal with any <option name='' value=''> children of this index
2171 // e.g. <option name='solrfieldtype' value='text_es'>
2172 NodeList option_children = index_element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2173 for (int k = 0; k < option_children.getLength(); k++)
2174 {
2175 Element el = (Element) option_children.item(k);
2176 if (el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2177 {
2178 continue;
2179 }
2180 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2181 String value_str = XMLTools.getNodeText(el);
2182
2183 if (name_str == null && value_str == null)
2184 {
2185 continue;
2186 }
2187 Element option_element = to.createElement(StaticStrings.OPTION_STR);
2188 if (!name_str.equals("")) {
2189 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2190 }
2191 if (!value_str.equals("")) { // or no value attribute without name attribute?
2192 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
2193 }
2194 index_ele.appendChild(option_element);
2195 }
2196
2197 search.appendChild(index_ele);
2198
2199 } //for loop ends
2200
2201 //Convert default index
2202 convertDefaultIndex(from, to, search);
2203 convertIndexOptions(from, to, search);
2204 }
2205
2206 //convert <facet> and <sort> elements and their displayItem subelements,
2207 //which go in 'search' element in collectionConfig.xml
2208 //parameter 'to' is the document to be saved as collectionConfig.xml
2209 //parameter 'from' is the internal xml structure
2210 // Note that GLI at present does not allow the user to set or modify the solr-specific elements
2211 // <sort> and <facet>. This function, and its inverse convertSolrFacetsAndSorts, is only here to preserve such
2212 // elements if they already exist in the collectionConfig.xml. At present they need to be manually added there.
2213 static private void convertSolrFacetsAndSorts(Document from, Document to)
2214 {
2215 Element source = from.getDocumentElement();
2216 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
2217 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
2218
2219 //There are two sets of <Solr> elements, find the one which is assigned 'true'
2220 Element solr = XMLTools.getNamedElement(source, StaticStrings.SOLR_ELEMENT, StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
2221 if (solr == null)
2222 {
2223 return;
2224 }
2225 NodeList sort_elements = solr.getElementsByTagName(StaticStrings.SORT_ELEMENT); //<Sort>
2226 int sort_elements_length = sort_elements.getLength();
2227 NodeList facet_elements = solr.getElementsByTagName(StaticStrings.FACET_ELEMENT); //<Facet>
2228 int facet_elements_length = facet_elements.getLength();
2229
2230 for (int j = 0; j < sort_elements_length; j++)
2231 {
2232 Element sort_element = (Element) sort_elements.item(j);
2233 if (sort_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2234 {
2235 continue;
2236 }
2237
2238 Element sort_ele = to.createElement(StaticStrings.SORT_LOW_STR);//<sort>
2239 String name_attr = sort_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2240
2241 /*if (name_attr.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_attr.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2242 {
2243 name_attr = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2244 }
2245 */
2246 sort_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_attr);
2247
2248 // Now constructing 'displayItem' element for this 'sort_ele' element
2249 Element displayItem = (Element) XMLTools.getChildByTagName(sort_element, StaticStrings.DISPLAYITEM_ELEMENT); // gets the first <DisplayItem> (not <displayItem>!) child of <Sort>
2250
2251 if(displayItem != null) {
2252 if (displayItem.hasAttribute(StaticStrings.ASSIGNED_ATTRIBUTE) && displayItem.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
2253 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_STR);//<displayItem>
2254
2255 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
2256 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2257 String value_str = displayItem.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2258
2259 if (lang_str != null && !lang_str.equals(""))
2260 {
2261 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
2262 }
2263 if (name_str != null && !name_str.equals(""))
2264 {
2265 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2266 }
2267 if (value_str != null && !value_str.equals(""))
2268 {
2269 XMLTools.setNodeText(displayItem_element, value_str);
2270 }
2271 sort_ele.appendChild(displayItem_element);
2272 }
2273 }
2274
2275 search.appendChild(sort_ele);
2276
2277 } //for loop on sort_elements ends
2278
2279 for (int j = 0; j < facet_elements_length; j++)
2280 {
2281 Element facet_element = (Element) facet_elements.item(j);
2282 if (facet_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2283 {
2284 continue;
2285 }
2286
2287 Element facet_ele = to.createElement(StaticStrings.FACET_LOW_STR);//<facet>
2288 String name_attr = facet_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2289
2290 facet_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_attr);
2291
2292 // Now constructing 'displayItem' element for this 'facet_ele' element
2293 Element displayItem = (Element) XMLTools.getChildByTagName(facet_element, StaticStrings.DISPLAYITEM_ELEMENT); // gets the first <DisplayItem> (not <displayItem>!) child of <Facet>
2294
2295 if(displayItem != null) {
2296 if (displayItem.hasAttribute(StaticStrings.ASSIGNED_ATTRIBUTE) && displayItem.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
2297 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_STR);//<displayItem>
2298
2299 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
2300 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2301 String value_str = displayItem.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2302
2303 if (lang_str != null && !lang_str.equals(""))
2304 {
2305 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
2306 }
2307 if (name_str != null && !name_str.equals(""))
2308 {
2309 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2310 }
2311 if (value_str != null && !value_str.equals(""))
2312 {
2313 XMLTools.setNodeText(displayItem_element, value_str);
2314 }
2315 facet_ele.appendChild(displayItem_element);
2316 }
2317 }
2318
2319 search.appendChild(facet_ele);
2320
2321 } //for loop on facet_elements ends
2322
2323 }
2324
2325 // Convert levels for mgpp/lucene. This method is called by converIndex() when mgpp indexer is detected.
2326 static private void convertLevels(Document from, Document to, Element search)
2327 {
2328 Element source = from.getDocumentElement();
2329 Element index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTIONS_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVELS_STR);
2330 if (index_option == null)
2331 {
2332 return;
2333 }
2334 //Debugging purposes
2335 if (index_option.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2336 {
2337 DebugStream.println("For mgpp, there should be an IndexOption element for levels which is assigned 'true': possible bug.");
2338 }
2339
2340 NodeList option_elements = index_option.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2341 int num_elements = option_elements.getLength();
2342
2343 // Don't output anything if no indexes are set
2344 if (num_elements == 0)
2345 {
2346 return;//
2347 }
2348
2349 for (int k = 0; k < num_elements; k++)
2350 {
2351 Element e = (Element) option_elements.item(k);
2352 String name_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2353 Element level_element = to.createElement(StaticStrings.LEVEL_ELEMENT);
2354 level_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2355
2356 //Now construct displayItem for this level element from collectionmetadata
2357 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, name_str);
2358
2359 if (collectionmetadata_list != null)
2360 {
2361
2362 for (int j = 0; j < collectionmetadata_list.size(); j++)
2363 {
2364 Element collectionmetadata = (Element) collectionmetadata_list.get(j);
2365
2366 Element displayItem = constructDisplayItem(collectionmetadata, to);
2367 level_element.appendChild(displayItem);
2368 }
2369 }
2370 search.appendChild(level_element);
2371 }
2372
2373 //Convert default level
2374 Element default_index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTION_DEFAULT_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVEL_DEFAULT_STR);
2375 if (default_index_option == null)
2376 {
2377 return;
2378 }
2379 Element default_level = to.createElement(StaticStrings.LEVEL_DEFAULT_ELEMENT);
2380 String default_level_str = default_index_option.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2381 default_level.setAttribute(StaticStrings.NAME_ATTRIBUTE, default_level_str);
2382 search.appendChild(default_level);
2383
2384 }
2385
2386 // Convert indexoptions for mg/mgpp/lucene. This method is called by convertIndex().
2387 static private void convertIndexOptions(Document from, Document to, Element search)
2388 {
2389 Element source = from.getDocumentElement();
2390 Element index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTIONS_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.INDEXOPTIONS_STR);
2391 if (index_option == null)
2392 {
2393 return;
2394 }
2395 //Debugging purposes
2396 if (index_option.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2397 {
2398 DebugStream.println("There should be an IndexOption element which is assigned 'true': possible bug.");
2399 }
2400 //Element indexOptionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
2401 NodeList option_elements = index_option.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2402 int num_elements = option_elements.getLength();
2403 // Don't output anything if no index
2404 if (num_elements == 0)
2405 {
2406 return;//
2407 }
2408 //search.appendChild(indexOptionEl);
2409
2410 for (int k = 0; k < num_elements; k++)
2411 {
2412 Element e = (Element) option_elements.item(k);
2413 String name_att = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2414 Element optionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
2415 optionEl.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_att);
2416 // default value?? on/off
2417 //indexOptionEl.appendChild(optionEl);
2418 search.appendChild(optionEl);
2419 }
2420
2421 }
2422
2423 // handle top level elements which GLI knows nothing about
2424 // we store them internally in a Unknown element for easy access when
2425 // we write them out.
2426 static private void doUnknownElements(Document to, Element from)
2427 {
2428 Element toElement = to.getDocumentElement();
2429 Element unknownElement = to.createElement(StaticStrings.UNKNOWN_ELEMENT);
2430 toElement.appendChild(unknownElement);
2431
2432 Node child = from.getFirstChild();
2433 while (child != null)
2434 {
2435 if (child.getNodeType() == Node.ELEMENT_NODE && !known_element_names.contains(child.getNodeName()))
2436 {
2437 unknownElement.appendChild(XMLTools.duplicateElement(to, (Element) child, true));
2438 }
2439 child = child.getNextSibling();
2440 }
2441
2442 }
2443
2444 // just copy all children of Unknown element into output doc.
2445 static private void convertUnknownElements(Document from, Document to)
2446 {
2447
2448 Element toElement = to.getDocumentElement();
2449 Node unknown_element = XMLTools.getChildByTagName(from.getDocumentElement(), StaticStrings.UNKNOWN_ELEMENT);
2450
2451 Node child = unknown_element.getFirstChild();
2452 while (child != null)
2453 {
2454 Element to_element = XMLTools.duplicateElement(to, (Element) child, true);
2455 toElement.appendChild(to_element);
2456
2457 child = child.getNextSibling();
2458 }
2459
2460 }
2461
2462 // Append the element son to the element mother in the appropriate position.
2463 static public void appendProperly(Element mother, Element son)
2464 {
2465 if (son == null)
2466 return;
2467
2468 Node reference_node = findInsertionPoint(mother, son);
2469 if (reference_node != null)
2470 {
2471 mother.insertBefore(son, reference_node);
2472 }
2473 else
2474 {
2475 mother.appendChild(son);
2476 }
2477 }
2478
2479 /**
2480 * Find the best insertion position for the given DOM Element
2481 * 'target_element' in the DOM Element 'document_element'. This should try
2482 * to match command tag, and if found should then try to group by name or
2483 * type (eg CollectionMeta), or append to end is no such grouping exists (eg
2484 * Plugins). Failing a command match it will check against the command order
2485 * for the best insertion location.
2486 *
2487 * @param target_element
2488 * the command Element to be inserted
2489 * @return the Element which the given command should be inserted before, or
2490 * null to append to end of list
2491 */
2492 static public Node findInsertionPoint(Element document_element, Element target_element)
2493 {
2494 ///ystem.err.println("Find insertion point: " + target_element.getNodeName());
2495 String target_element_name = target_element.getNodeName();
2496
2497 // Try to find commands with the same tag.
2498 NodeList matching_elements = document_element.getElementsByTagName(target_element_name);
2499 // If we found matching elements, then we have our most likely insertion location, so check within for groupings
2500 if (matching_elements.getLength() != 0)
2501 {
2502 ///ystem.err.println("Found matching elements.");
2503 // Only CollectionMeta are grouped.
2504 if (target_element_name.equals(StaticStrings.COLLECTIONMETADATA_ELEMENT))
2505 {
2506 ///ystem.err.println("Dealing with collection metadata");
2507 // Special case: CollectionMeta can be added at either the start or end of a collection configuration file. However the start position is reserved for special metadata, so if no non-special metadata can be found we must append to the end.
2508 // So if the command to be added is special add it immediately after any other special command
2509 if (target_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2510 {
2511 int index = 0;
2512 Element matched_element = (Element) matching_elements.item(index);
2513 Element sibling_element = (Element) matched_element.getNextSibling();
2514 while (sibling_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2515 {
2516 index++;
2517 matched_element = (Element) matching_elements.item(index);
2518 sibling_element = (Element) matched_element.getNextSibling();
2519 }
2520 if (sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2521 {
2522 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2523 document_element.insertBefore(newline_element, sibling_element);
2524 }
2525 return sibling_element;
2526 }
2527 // Otherwise try to find a matching 'name' and add after the last one in that group.
2528 else
2529 {
2530 int index = 0;
2531 target_element_name = target_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2532 boolean found = false;
2533 // Skip all of the special metadata
2534 Element matched_element = (Element) matching_elements.item(index);
2535 while (matched_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2536 {
2537 index++;
2538 matched_element = (Element) matching_elements.item(index);
2539 }
2540 // Begin search
2541 while (!found && matched_element != null)
2542 {
2543 if (matched_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name))
2544 {
2545 found = true;
2546 }
2547 else
2548 {
2549 index++;
2550 matched_element = (Element) matching_elements.item(index);
2551 }
2552 }
2553 // If we found a match, we need to continue checking until we find the last name match.
2554 if (found)
2555 {
2556 index++;
2557 Element previous_sibling = matched_element;
2558 Element sibling_element = (Element) matching_elements.item(index);
2559 while (sibling_element != null && sibling_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name))
2560 {
2561 previous_sibling = sibling_element;
2562 index++;
2563 sibling_element = (Element) matching_elements.item(index);
2564 }
2565 // Previous sibling now holds the command immediately before where we want to add, so find its next sibling and add to that. In this one case we can ignore new lines!
2566 return previous_sibling.getNextSibling();
2567 }
2568 // If not found we just add after last metadata element
2569 else
2570 {
2571 Element last_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2572 return last_element.getNextSibling();
2573 }
2574 }
2575
2576 }
2577 else
2578 {
2579 ///ystem.err.println("Not dealing with collection meta.");
2580 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2581 // One final quick test. If the matched element is immediately followed by a NewLine command, then we insert another NewLine after the matched command, then return the NewLine instead (thus the about to be inserted command will be placed between the two NewLines)
2582 Node sibling_element = matched_element.getNextSibling();
2583 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2584 {
2585 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2586 document_element.insertBefore(newline_element, sibling_element);
2587 }
2588 return sibling_element; // Note that this may be null
2589 }
2590 }
2591 ///ystem.err.println("No matching elements found.");
2592 // Locate where this command is in the ordering
2593 int command_index = -1;
2594 for (int i = 0; command_index == -1 && i < CollectionConfiguration.COMMAND_ORDER.length; i++)
2595 {
2596 if (CollectionConfiguration.COMMAND_ORDER[i].equals(target_element_name))
2597 {
2598 command_index = i;
2599 }
2600 }
2601 ///ystem.err.println("Command index is: " + command_index);
2602 // Now move forward, checking for existing elements in each of the preceeding command orders.
2603 int preceeding_index = command_index - 1;
2604 ///ystem.err.println("Searching before the target command.");
2605 while (preceeding_index >= 0)
2606 {
2607 matching_elements = document_element.getElementsByTagName(CollectionConfiguration.COMMAND_ORDER[preceeding_index]);
2608 // If we've found a match
2609 if (matching_elements.getLength() > 0)
2610 {
2611 // We add after the last element
2612 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2613 // One final quick test. If the matched element is immediately followed by a NewLine command, then we insert another NewLine after the matched command, then return the NewLine instead (thus the about to be inserted command will be placed between the two NewLines)
2614 Node sibling_element = matched_element.getNextSibling();
2615 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2616 {
2617 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2618 document_element.insertBefore(newline_element, sibling_element);
2619 }
2620 return sibling_element; // Note that this may be null
2621 }
2622 preceeding_index--;
2623 }
2624 // If all that fails, we now move backwards through the commands
2625 int susceeding_index = command_index + 1;
2626 ///ystem.err.println("Searching after the target command.");
2627 while (susceeding_index < CollectionConfiguration.COMMAND_ORDER.length)
2628 {
2629 matching_elements = document_element.getElementsByTagName(CollectionConfiguration.COMMAND_ORDER[susceeding_index]);
2630 // If we've found a match
2631 if (matching_elements.getLength() > 0)
2632 {
2633 // We add before the first element
2634 Element matched_element = (Element) matching_elements.item(0);
2635 // One final quick test. If the matched element is immediately preceeded by a NewLine command, then we insert another NewLine before the matched command, then return this new NewLine instead (thus the about to be inserted command will be placed between the two NewLines)
2636 Node sibling_element = matched_element.getPreviousSibling();
2637 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2638 {
2639 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2640 document_element.insertBefore(newline_element, sibling_element);
2641 }
2642 return sibling_element; // Note that this may be null
2643 }
2644 susceeding_index++;
2645 }
2646 // Well. Apparently there are no other commands in this collection configuration. So append away...
2647 return null;
2648 }
2649
2650 // From collectionConfig.xml to internal structure:add 'ex.' namespace (if none).
2651 // From internal structure to collectionConfig.xml:always peel off 'ex.' namespace (if any), except for format statement
2652 //This method parses 'xml_file_doc' into 'dOc'
2653 static public void parse(File xml_file, Document dOc)
2654 {
2655
2656 Document xml_file_doc = XMLTools.parseXMLFile(xml_file);
2657 Element fromElement = xml_file_doc.getDocumentElement();
2658 Element toElement = dOc.getDocumentElement();
2659
2660 // It's deliberately set that 'creator', 'maintainer', and 'public' are only in English (as they are just names).
2661 // So the following ArrayList have only one element.
2662 Node metadataListNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.METADATALIST_STR, 0);
2663 if (metadataListNode != null)
2664 {
2665 ArrayList creator = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_CREATOR_STR);
2666 ArrayList maintainer = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR);
2667 ArrayList is_public = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_STR);
2668
2669 appendArrayList(toElement, creator);
2670 appendArrayList(toElement, maintainer);
2671 appendArrayList(toElement, is_public);
2672 }
2673
2674 Node databaseNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.INFODB_STR, 0);
2675 String databasetype_value = "gdbm";
2676 if (databaseNode != null)
2677 {
2678 databasetype_value = ((Element) databaseNode).getAttribute(StaticStrings.TYPE_ATTRIBUTE);//might be gdbm|jdbm|sqlite OR not yet set (in which case it should default to gdbm)
2679 }
2680
2681 Element databasetype = doDatabaseType(dOc, databasetype_value);
2682 appendProperly(toElement, databasetype);
2683
2684 Node searchNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.SEARCH_STR, 0);
2685 String buildtype_value = ((Element) searchNode).getAttribute(StaticStrings.TYPE_ATTRIBUTE);//might be mg|mgpp|lucene
2686 Element buildtype = doBuildType(dOc, buildtype_value);
2687 appendProperly(toElement, buildtype);
2688
2689 Node importNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.IMPORT_STR, 0);
2690 if (importNode == null)
2691 {
2692 System.out.println("There is no content in the 'import' block.");
2693 }
2694 if (importNode != null)
2695 {
2696 //do plugin list nodes
2697 Node pluginListNode = XMLTools.getChildByTagNameIndexed((Element) importNode, StaticStrings.PLUGINLIST_STR, 0);
2698 if (pluginListNode == null)
2699 {
2700 System.out.println("There is no pluginlist set.");
2701 }
2702 if (pluginListNode != null)
2703 {
2704
2705 doPlugin(dOc, pluginListNode);
2706 }
2707
2708 //do the plugout element (used by building flax collections)
2709 Node plugout = XMLTools.getChildByTagNameIndexed((Element) importNode, PLUGOUT_ELEMENT, 0);
2710 if (plugout != null)
2711 {
2712 Element to_element = XMLTools.duplicateElement(dOc, (Element) plugout, true);
2713 toElement.appendChild(to_element);
2714 }
2715 }
2716
2717 Node browseNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.BROWSE_STR, 0);
2718 if (browseNode != null)
2719 {
2720 if (browseNode == null)
2721 {
2722 System.out.println("There is no classifier.");
2723 }
2724 doClassifier(dOc, browseNode);
2725 }
2726
2727 Node displayItemListNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.DISPLAYITEMLIST_STR, 0);
2728 if (displayItemListNode != null)
2729 {
2730 ArrayList description = doDisplayItemList(dOc, displayItemListNode, StaticStrings.DESCRIPTION_STR, StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR);
2731 ArrayList smallicon = doDisplayItemList(dOc, displayItemListNode, StaticStrings.SMALLICON_STR, StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR);
2732 ArrayList icon = doDisplayItemList(dOc, displayItemListNode, StaticStrings.ICON_STR, StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR);
2733 ArrayList name = doDisplayItemList(dOc, displayItemListNode, StaticStrings.NAME_STR, StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR);
2734
2735 appendArrayList(toElement, description);
2736 appendArrayList(toElement, smallicon);
2737 appendArrayList(toElement, icon);
2738 appendArrayList(toElement, name);
2739 }
2740
2741 if (buildtype_value.equalsIgnoreCase("mg"))
2742 {
2743 doMGIndexes(dOc, searchNode);
2744 }
2745 else
2746 {
2747 doMGPPIndexes(dOc, searchNode);
2748 }
2749
2750 if(buildtype_value.equalsIgnoreCase("solr")) {
2751 doSolrFacetsAndSorts(dOc, searchNode); // <facet><displayItem /></facet> and <sort><displayItem /></sort>
2752 }
2753
2754 doDefaultIndex(dOc, searchNode);
2755 doDefaultLevel(dOc, searchNode);
2756 doLevel(dOc, searchNode);
2757 doIndexOption(dOc, searchNode);
2758 doSubcollection(dOc, searchNode);
2759 doIndexSubcollection(dOc, searchNode);
2760 doIndexLanguage(dOc, searchNode);
2761 doDefaultIndexLanguage(dOc, searchNode);
2762 doLanguageMetadata(dOc, searchNode);
2763 doSearchType(dOc, searchNode);
2764 doSearchFormat(dOc, searchNode);
2765 doGlobalFormat(dOc, fromElement);
2766 doDisplayFormat(dOc, fromElement);
2767 doReplaceListRef(dOc, fromElement);
2768 doReplaceList(dOc, fromElement);
2769 doServiceRackList(dOc, fromElement);
2770 doUnknownElements(dOc, fromElement);
2771 // the official displayItems in the displayItemList element have already been handled above
2772 // and created as collectionmetadata elements in the dOc object
2773 // Now we add in all the *other* (remaining) displayItems as collectionmeta elements
2774 NodeList collectionMetadataList = dOc.getDocumentElement().getElementsByTagName(StaticStrings.COLLECTIONMETADATA_ELEMENT);
2775 Set setOfUniqueColMetaNames = new HashSet();
2776 for (int i = 0; i < collectionMetadataList.getLength(); i++)
2777 {
2778 Element colMeta = (Element) collectionMetadataList.item(i);
2779 String name = colMeta.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2780 setOfUniqueColMetaNames.add(name);
2781 }
2782
2783 if (displayItemListNode != null)
2784 {
2785 NodeList nl = ((Element) displayItemListNode).getElementsByTagName(StaticStrings.DISPLAYITEM_STR);
2786
2787 // make a list of all unique attribute names that are specifically not
2788 // description, smallicon, icon and name, since these are already processed above
2789 Set setOfUniqueDisplayItemNames = new LinkedHashSet();
2790 for (int i = 0; i < nl.getLength(); i++)
2791 {
2792 Element displayItem = (Element) nl.item(i);
2793 String name = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2794
2795 if (name.equals(""))
2796 continue; // no name attribute
2797 if (setOfUniqueColMetaNames.contains(name))
2798 continue;
2799
2800 if (name.equals(StaticStrings.DESCRIPTION_STR))
2801 continue;
2802 if (name.equals(StaticStrings.SMALLICON_STR))
2803 continue;
2804 if (name.equals(StaticStrings.ICON_STR))
2805 continue;
2806 if (name.equals(StaticStrings.NAME_STR))
2807 continue;
2808 // don't add displayItems that are handled by the indexers, etc. E.g. document:ex.Title
2809 if (name.indexOf(":") != -1)
2810 continue;
2811
2812 // otherwise
2813 setOfUniqueDisplayItemNames.add(name); // Set will ensure no duplicate names
2814 }
2815
2816 Iterator i = setOfUniqueDisplayItemNames.iterator();
2817 while (i.hasNext())
2818 {
2819 String displayItemName = (String) i.next();
2820
2821 ArrayList custom_displayItem = doDisplayItemList(dOc, displayItemListNode, displayItemName, displayItemName);
2822 appendArrayList(toElement, custom_displayItem);
2823 }
2824 }
2825
2826 }
2827
2828 static public String generateStringVersion(Document doc)
2829 {
2830 return XMLTools.xmlNodeToString(doc);
2831 }
2832
2833 static public void save(File collect_config_xml_file, Document doc)
2834 {
2835 Document collection_config_xml_document = convertInternalToCollectionConfig(doc);
2836 String[] nonEscapingTagNames = { StaticStrings.FORMAT_STR, StaticStrings.DISPLAYITEM_STR };
2837 XMLTools.writeXMLFile(collect_config_xml_file, collection_config_xml_document, nonEscapingTagNames);
2838 }
2839
2840 //Convert the internal XML DOM tree (dOc) into that of collectionConfig.xml (skeleton)
2841 static private Document convertInternalToCollectionConfig(Document dOc)
2842 {
2843 //first parse an empty skeleton of xml config file
2844 //The aim is to convert the internal structure into this skeleton
2845 // This skeleton just has the CollectionConfig element and nothing else
2846 Document skeleton = XMLTools.parseXMLFile("xml/CollectionConfig.xml", true);
2847 //Element internal = dOc.getDocumentElement();
2848 convertMetadataList(dOc, skeleton);
2849 convertDisplayItemList(dOc, skeleton);
2850 convertGlobalFormat(dOc, skeleton);
2851 convertBuildType(dOc, skeleton);
2852 convertDatabaseType(dOc, skeleton);
2853 convertIndex(dOc, skeleton);
2854 convertSolrFacetsAndSorts(dOc, skeleton);
2855 convertPlugin(dOc, skeleton);//also do the plugout element
2856 convertClassifier(dOc, skeleton);
2857 convertSubcollectionIndexes(dOc, skeleton);
2858 convertLanguages(dOc, skeleton);
2859 convertSubcollection(dOc, skeleton);
2860 convertSearchType(dOc, skeleton);
2861 convertSearchFormat(dOc, skeleton);
2862 convertDisplayFormat(dOc, skeleton);
2863 convertReplaceListRef(dOc, skeleton);
2864 convertReplaceList(dOc, skeleton);
2865 convertServiceRackList(dOc, skeleton);
2866 convertUnknownElements(dOc, skeleton); // try to catch everything GLI doesn't know about
2867
2868 return skeleton;
2869 }
2870
2871 // Append the elements, which are of Element type, in 'list' to Element 'to'
2872 static private void appendArrayList(Element to, ArrayList list)
2873 {
2874 if (list == null)
2875 return;
2876
2877 for (int i = 0; i < list.size(); i++)
2878 {
2879 appendProperly(to, (Element) list.get(i));
2880 }
2881 }
2882
2883}
Note: See TracBrowser for help on using the repository browser.