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

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

if indexOptions are not assigned=true, then return. Don't want to output any
File size: 112.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.SECURITY_STR, StaticStrings.METADATALIST_STR, StaticStrings.DISPLAYITEMLIST_STR, StaticStrings.FORMAT_STR, StaticStrings.SEARCH_STR, StaticStrings.INFODB_STR, StaticStrings.BROWSE_STR, StaticStrings.IMPORT_STR, StaticStrings.IMPORT_OPTION_STR, StaticStrings.BUILD_OPTION_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 doPlugins(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 convertSecurity(Document from, Document to)
1417 {
1418 Node security = XMLTools.getChildByTagNameIndexed(from.getDocumentElement(), StaticStrings.SECURITY_STR, 0);
1419 if (security != null)
1420 {
1421 Element to_element = XMLTools.duplicateElement(to, (Element) security, true);
1422 to.getDocumentElement().appendChild(to_element);
1423
1424 }
1425 }
1426 static private void convertMetadataList(Document from, Document to)
1427 {
1428 Element metadataList = to.createElement(StaticStrings.METADATALIST_STR);
1429 Element destination = to.getDocumentElement();
1430
1431 String[] ele_names = { StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT };
1432 String[] att_names = { StaticStrings.COLLECTIONMETADATA_CREATOR_STR, StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR, StaticStrings.COLLECTIONMETADATA_PUBLIC_STR };
1433 for (int i = 0; i < ele_names.length; i++)
1434 {
1435 Element e = XMLTools.getNamedElement(from.getDocumentElement(), ele_names[i], StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1436 if (e == null)
1437 {
1438 continue;
1439 }
1440 String text = XMLTools.getNodeText(e);
1441 Element metadata = to.createElement(StaticStrings.METADATA_STR);
1442 metadata.setAttribute(StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1443 metadata.setAttribute(StaticStrings.LANG_STR, StaticStrings.ENGLISH_LANGUAGE_STR);
1444 XMLTools.setNodeText(metadata, text);
1445 metadataList.appendChild(metadata);
1446 }
1447
1448 destination.appendChild(metadataList);
1449 }
1450
1451 // This method creates an element with the name 'element_name' of the type of 'to' by using the other three strings
1452 static private Element constructElement(String element_name, String name_value, String lang_att, String lang_value, String text, Document to)
1453 {
1454 Element e = to.createElement(element_name);
1455 e.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1456 e.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_value);
1457 e.setAttribute(lang_att, lang_value);
1458 XMLTools.setNodeText(e, text);
1459
1460 return e;
1461 }
1462
1463 // Convert classify in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1464 static private void convertClassifier(Document from, Document to)
1465 {
1466 Element browse_element = to.createElement(StaticStrings.BROWSE_STR);
1467 NodeList children = from.getDocumentElement().getElementsByTagName(StaticStrings.CLASSIFY_ELEMENT);
1468
1469 int num_children = (children == null) ? 0 : children.getLength();
1470
1471 if (num_children == 0)
1472 {
1473 return;
1474 }
1475
1476 for (int i = 0; i < num_children; i++)
1477 {
1478
1479 Element child = (Element) children.item(i);
1480 if (child.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1481 {
1482 continue;
1483 }
1484 String str = child.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1485 Element classifier_element = to.createElement(StaticStrings.CLASSIFIER_STR);
1486 classifier_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, str);
1487
1488 NodeList option_children = child.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
1489 for (int j = 0; j < option_children.getLength(); j++)
1490 {
1491 Element el = (Element) option_children.item(j);
1492 if (el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1493 {
1494 continue;
1495 }
1496 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1497 String value_str = XMLTools.getNodeText(el);
1498
1499 if (name_str == null && value_str == null)
1500 {
1501 continue;
1502 }
1503 Element option_element = to.createElement(StaticStrings.OPTION_STR);
1504 if (name_str != null && name_str.equals(StaticStrings.METADATA_STR))
1505 {
1506
1507 // 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.
1508 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
1509 value_str = "";
1510 for (int k = 0; k <= values.length - 1; k++)
1511 {
1512 if (values[k].startsWith(StaticStrings.EXTRACTED_NAMESPACE) && values[k].indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1513 {
1514 values[k] = values[k].substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1515 }
1516 else
1517 {
1518 MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName(values[k]);
1519 if (metadata_element != null)
1520 {
1521 values[k] = metadata_element.getFullName();
1522 }
1523 }
1524 if (k < values.length - 1)
1525 {
1526 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1527 }
1528 else
1529 {
1530 value_str = value_str + values[k];
1531 }
1532 }
1533 }
1534
1535 if (!name_str.equals(""))
1536 {
1537 if (!name_str.startsWith(StaticStrings.MINUS_CHARACTER))
1538 {
1539 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1540 }
1541 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1542 }
1543
1544 if (!value_str.equals(""))
1545 {
1546 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
1547 }
1548
1549 classifier_element.appendChild(option_element);
1550 }
1551
1552 //format element for this classifier
1553 Element e = (Element) XMLTools.getChildByTagName(child, StaticStrings.FORMAT_STR);
1554
1555 if (e != null)
1556 {
1557 classifier_element.appendChild(convertFormat(to, e));
1558 }
1559 browse_element.appendChild(classifier_element);
1560 }
1561
1562 //convert default classifier format
1563 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.BROWSE_STR);
1564 browse_element.appendChild(convertFormat(to, e));
1565
1566 to.getDocumentElement().appendChild(browse_element);
1567 }
1568
1569 static private Element convertFormat(Document to, Element e)
1570 {
1571 String format_str = XMLTools.getNodeText(e);
1572 Element format = to.createElement(StaticStrings.FORMAT_STR);
1573 //XMLTools.copyAllChildren (format, e);
1574 XMLTools.setNodeText(format, format_str);
1575 return format;
1576 }
1577
1578 //convert format statement for search
1579 static private void convertSearchFormat(Document from, Document to)
1580 {
1581 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1582 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCH_STR);
1583
1584 search.appendChild(convertFormat(to, e));
1585
1586 }
1587
1588 //convert format statement for display of the documents
1589 static private void convertDisplayFormat(Document from, Document to)
1590 {
1591 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.DISPLAY_STR);
1592 if (e == null)
1593 {
1594 return;
1595 }
1596 Element display = to.createElement(StaticStrings.DISPLAY_STR);
1597 display.appendChild(convertFormat(to, e));
1598 to.getDocumentElement().appendChild(display);
1599 }
1600
1601 // convert global format statement
1602 static private void convertGlobalFormat(Document from, Document to)
1603 {
1604 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.GLOBAL_STR);
1605
1606 to.getDocumentElement().appendChild(convertFormat(to, e));
1607
1608 }
1609
1610 // Convert plugins in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1611 static private void convertPlugins(Document from, Document to)
1612 {
1613 Element import_element = to.createElement(StaticStrings.IMPORT_STR);
1614 Element plugin_list_element = to.createElement(StaticStrings.PLUGINLIST_STR);
1615
1616 NodeList children = from.getDocumentElement().getElementsByTagName(StaticStrings.PLUGIN_ELEMENT);
1617 int num_children = (children == null) ? 0 : children.getLength();
1618 if (num_children == 0)
1619 {
1620 return;
1621 }
1622
1623 for (int i = 0; i < num_children; i++)
1624 {
1625
1626 Element child = (Element) children.item(i);
1627 if (child.getAttribute(StaticStrings.SEPARATOR_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
1628 {
1629 continue;
1630 }
1631 if (child.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1632 {
1633 continue;
1634 }
1635
1636 String str = child.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1637 Element plugin_element = to.createElement(StaticStrings.PLUGIN_STR);
1638 plugin_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, str);
1639
1640 NodeList option_children = child.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
1641 for (int j = 0; j < option_children.getLength(); j++)
1642 {
1643 Element el = (Element) option_children.item(j);
1644 if (!el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
1645 {
1646 continue;
1647 }
1648 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1649 String value_str = XMLTools.getNodeText(el);
1650
1651 if (name_str == null && value_str == null)
1652 {
1653 continue;
1654 }
1655 Element option_element = to.createElement(StaticStrings.OPTION_STR);
1656 if (name_str != null && name_str.equals(StaticStrings.METADATA_STR))
1657 {
1658
1659 // 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.*)
1660 String[] values = value_str.split(StaticStrings.COMMA_CHARACTER);
1661 value_str = "";
1662 for (int k = 0; k <= values.length - 1; k++)
1663 {
1664 if (values[k].startsWith(StaticStrings.EXTRACTED_NAMESPACE) && values[k].indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1665 {
1666 values[k] = values[k].substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1667 }
1668
1669 if (k < values.length - 1)
1670 {
1671 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1672 }
1673 else
1674 {
1675 value_str = value_str + values[k];
1676 }
1677 }
1678 }
1679
1680 if (!name_str.equals(""))
1681 {
1682 if (!name_str.startsWith(StaticStrings.MINUS_CHARACTER))
1683 {
1684 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1685 }
1686 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1687 }
1688
1689 if (!value_str.equals(""))
1690 {
1691 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
1692 }
1693
1694 plugin_element.appendChild(option_element);
1695 }//for loop ends
1696
1697 plugin_list_element.appendChild(plugin_element);
1698 }//for loop ends
1699
1700 import_element.appendChild(plugin_list_element);
1701
1702 //do the plugout element (used by building flax collections)
1703 Node plugout = XMLTools.getChildByTagNameIndexed(from.getDocumentElement(), PLUGOUT_ELEMENT, 0);
1704 if (plugout != null)
1705 {
1706 Element to_element = XMLTools.duplicateElement(to, (Element) plugout, true);
1707 import_element.appendChild(to_element);
1708 }
1709
1710 to.getDocumentElement().appendChild(import_element);
1711 }
1712
1713 //Handle 'searchType' of collectionConfig.xml. In the internal structure, its also called 'searchType', eg. plain, form
1714 static private void convertSearchType(Document from, Document to)
1715 {
1716 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.FORMAT_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);//searchType
1717
1718 if (e == null)
1719 {
1720 return;
1721 }
1722 String searchtype_str = XMLTools.getNodeText(e).trim();
1723 //Get the 'search' element from 'to'
1724 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1725
1726 String[] types = searchtype_str.split(",");
1727 for (int i = 0; i < types.length; i++)
1728 {
1729 Element search_type_element = to.createElement(StaticStrings.SEARCHTYPE_ELEMENT);
1730 search_type_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, types[i]);
1731 search.appendChild(search_type_element);
1732 }
1733 }
1734
1735 static private void convertBuildType(Document from, Document to)
1736 {
1737 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.BUILDTYPE_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
1738 if (e == null)
1739 {
1740 return;
1741 }
1742 String indexer = XMLTools.getNodeText(e);
1743 Element search = to.createElement(StaticStrings.SEARCH_STR);
1744 search.setAttribute(StaticStrings.TYPE_ATTRIBUTE, indexer);
1745 to.getDocumentElement().appendChild(search);
1746 }
1747
1748 static private void convertDatabaseType(Document from, Document to)
1749 {
1750 Element e = XMLTools.getNamedElement(from.getDocumentElement(), StaticStrings.DATABASETYPE_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.DATABASETYPE_STR);
1751 if (e == null)
1752 {
1753 return;
1754 }
1755 String db = XMLTools.getNodeText(e);
1756 Element dbtype = to.createElement(StaticStrings.INFODB_STR);
1757 dbtype.setAttribute(StaticStrings.TYPE_ATTRIBUTE, db);
1758 to.getDocumentElement().appendChild(dbtype);
1759 }
1760
1761 static private void convertDefaultIndex(Document from, Document to, Element search)
1762 {
1763 Element source = from.getDocumentElement();
1764
1765 Element default_index_element = (Element) XMLTools.getChildByTagName(source, StaticStrings.INDEX_DEFAULT_ELEMENT);
1766 if (default_index_element == null)
1767 {
1768 return;
1769 }
1770
1771 String indexer = search.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1772 String level_str = default_index_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE);
1773 // Debugging purposes
1774 if (level_str.equals("") && indexer.equals(StaticStrings.MG_STR))
1775 {
1776 System.out.println("Bug: DefaultIndex should have its level attribute not empty.");
1777 }
1778
1779 NodeList content_elements = default_index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
1780 int content_elements_length = content_elements.getLength();
1781
1782 // Don't output anything if no indexes are set
1783 if (content_elements_length == 0)
1784 {
1785 return;//
1786 }
1787
1788 String index_str = "";
1789
1790 if (indexer.equals(StaticStrings.MG_STR))
1791 {
1792 //combine level with indexes
1793 index_str = level_str + StaticStrings.COLON_CHARACTER;
1794 }
1795 else
1796 { //for mgpp/lucene, just take index
1797 //do nothing
1798 }
1799
1800 for (int k = 0; k < content_elements_length; k++)
1801 {
1802 Element content_element = (Element) content_elements.item(k);
1803 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1804 {
1805 continue;
1806 }
1807 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1808
1809 if (name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_str.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1810 {
1811 name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1812 }
1813
1814 index_str = index_str + name_str;
1815
1816 // Make it comma separated string
1817 if (k < content_elements_length - 1)
1818 {
1819 index_str = index_str + StaticStrings.COMMA_CHARACTER;
1820 }
1821 content_element = null;
1822 }//for loop ends
1823
1824 Element default_index = to.createElement(StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);
1825 default_index.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_str);
1826 search.appendChild(default_index);
1827
1828 }
1829
1830 static private void convertSubcollection(Document from, Document to)
1831 {
1832 Element source = from.getDocumentElement();
1833 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1834 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1835
1836 // Get the Subcollection element from the internal structure
1837 NodeList subcollection_elements = source.getElementsByTagName(StaticStrings.SUBCOLLECTION_ELEMENT);
1838 if (subcollection_elements == null)
1839 {
1840 return;
1841 }
1842 int subcollection_elements_length = subcollection_elements.getLength();
1843
1844 if (subcollection_elements_length == 0)
1845 { // no
1846 return;
1847 }
1848
1849 for (int j = 0; j < subcollection_elements_length; j++)
1850 {
1851
1852 Element e = (Element) subcollection_elements.item(j);
1853 if (e.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1854 {
1855 continue;
1856 }
1857 String content = e.getAttribute(StaticStrings.CONTENT_ATTRIBUTE);
1858 String name = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1859 String options = e.getAttribute(StaticStrings.OPTIONS_ATTRIBUTE);
1860 String type = e.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
1861 String text = XMLTools.getNodeText(e);
1862
1863 String filter = "";
1864 if (type.equals(StaticStrings.EXCLUDE_STR))
1865 {
1866 filter = StaticStrings.EXCLAMATION_CHARACTER;
1867 }
1868
1869 if (content.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && content.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
1870 {
1871 content = content.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
1872 }
1873 filter = filter + content + StaticStrings.SEPARATOR_CHARACTER + text;
1874 if (options != null && options != "")
1875 {
1876 filter = filter + StaticStrings.SEPARATOR_CHARACTER + options;
1877 }
1878 Element subcollection = to.createElement(StaticStrings.SUBCOLLECTION_STR);
1879 subcollection.setAttribute(StaticStrings.FILTER_ATTRIBUTE, filter);
1880 subcollection.setAttribute(StaticStrings.NAME_ATTRIBUTE, name);
1881
1882 search.appendChild(subcollection);
1883 }
1884 }
1885
1886 static private void convertSubcollectionIndexes(Document from, Document to)
1887 {
1888 Element source = from.getDocumentElement();
1889 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1890 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1891
1892 // Get the SubcollectionIndexes element from the internal structure
1893 Element subcollection_indexes = (Element) XMLTools.getChildByTagName(source, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
1894 if (subcollection_indexes == null)
1895 {
1896 return;
1897 }
1898 NodeList index_elements = subcollection_indexes.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
1899 int index_elements_length = index_elements.getLength();
1900
1901 if (index_elements_length == 0)
1902 { // no indexes
1903 return;
1904 }
1905
1906 for (int j = 0; j < index_elements_length; j++)
1907 {
1908 Element index_element = (Element) index_elements.item(j);
1909 if (index_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1910 {
1911 continue;
1912 }
1913
1914 Element index = to.createElement(StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
1915
1916 String index_value = "";
1917
1918 NodeList content_elements = index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
1919 int content_elements_length = content_elements.getLength();
1920
1921 for (int k = 0; k < content_elements_length; k++)
1922 {
1923 Element content_element = (Element) content_elements.item(k);
1924 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1925 {
1926 continue;
1927 }
1928 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1929 index_value += name_str;
1930 // Make it comma separated string
1931 if (k < content_elements_length - 1)
1932 {
1933 index_value += StaticStrings.COMMA_CHARACTER;
1934 }
1935 content_element = null;
1936 }//for loop ends
1937
1938 index.setAttribute(StaticStrings.NAME_ATTRIBUTE, index_value);
1939
1940 // Now constructing 'displayItem' element for this 'indexSubcollection' element
1941 // from the collectionmetadata element
1942 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, index_value);
1943
1944 if (collectionmetadata_list != null)
1945 {
1946
1947 for (int k = 0; k < collectionmetadata_list.size(); k++)
1948 {
1949 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
1950 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1951 {
1952 continue;
1953 }
1954 Element displayItem = constructDisplayItem(collectionmetadata, to);
1955 index.appendChild(displayItem);
1956 }
1957 }
1958
1959 search.appendChild(index);
1960
1961 } //for loop ends
1962 }
1963
1964 static private void convertLanguages(Document from, Document to)
1965 {
1966 Element source = from.getDocumentElement();
1967 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1968 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
1969
1970 // Get the Languages element from the internal structure
1971 Element languages = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGES_ELEMENT);
1972 if (languages == null)
1973 {
1974 return;
1975 }
1976 NodeList language_elements = languages.getElementsByTagName(StaticStrings.LANGUAGE_ELEMENT);
1977 int language_elements_length = language_elements.getLength();
1978
1979 if (language_elements_length == 0)
1980 {
1981 return;
1982 }
1983
1984 for (int j = 0; j < language_elements_length; j++)
1985 {
1986 Element element = (Element) language_elements.item(j);
1987 if (element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
1988 {
1989 continue;
1990 }
1991
1992 // Create indexLanguage element
1993 Element index_language = to.createElement(StaticStrings.LANGUAGE_INDEX_ELEMENT);
1994
1995 String name_str = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1996 index_language.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
1997
1998 // Now constructing 'displayItem' element for this 'indexLanguage' element
1999 // from the collectionmetadata element
2000 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, name_str);
2001
2002 if (collectionmetadata_list != null)
2003 {
2004
2005 for (int k = 0; k < collectionmetadata_list.size(); k++)
2006 {
2007 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
2008 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2009 {
2010 continue;
2011 }
2012 Element displayItem = constructDisplayItem(collectionmetadata, to);
2013 index_language.appendChild(displayItem);
2014 }
2015 }
2016
2017 search.appendChild(index_language);
2018
2019 } //for loop ends
2020
2021 // Convert DefaultLanguage
2022 // Get the DefaultLanguage element from the internal structure
2023 Element default_language = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGE_DEFAULT_ELEMENT);
2024 if (default_language != null)
2025 {
2026 String lang_name = default_language.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2027 Element default_index_language = to.createElement(StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT);
2028 default_index_language.setAttribute(StaticStrings.NAME_ATTRIBUTE, lang_name);
2029 search.appendChild(default_index_language);
2030 }
2031 // Convert LanguageMetadata
2032 // Get the LanguageMetadata element from the internal structure
2033 Element language_metadata = (Element) XMLTools.getChildByTagName(source, StaticStrings.LANGUAGE_METADATA_ELEMENT);
2034 if (language_metadata != null)
2035 {
2036 String meta_name = language_metadata.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2037 Element language_meta = to.createElement(StaticStrings.LANGUAGE_METADATA_ELEMENT_STR);
2038 if (meta_name.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && meta_name.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2039 {
2040 meta_name = meta_name.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2041 }
2042 language_meta.setAttribute(StaticStrings.NAME_ATTRIBUTE, meta_name);
2043 search.appendChild(language_meta);
2044 }
2045 }
2046
2047 //convert indexes and their displayItems, which go in 'search' element in collectionConfig.xml
2048 //parameter 'to' is the document to be saved as collectionConfig.xml
2049 //parameter 'from' is the internal xml structure
2050 static private void convertIndex(Document from, Document to)
2051 {
2052 Element source = from.getDocumentElement();
2053 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
2054 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
2055
2056 //THere are two sets of indexes elements, find the one which is assigned 'true'
2057 Element indexes = XMLTools.getNamedElement(source, StaticStrings.INDEXES_ELEMENT, StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
2058 if (indexes == null)
2059 {
2060 return;
2061 }
2062 NodeList index_elements = indexes.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
2063 int index_elements_length = index_elements.getLength();
2064
2065 if (index_elements_length == 0)
2066 { // no indexes
2067 return;
2068 }
2069
2070 //find out it's mg or mgpp/lucene
2071 String mg = search.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
2072 boolean mg_indexer = false;
2073 if (mg.equals(StaticStrings.MG_STR))
2074 {
2075 mg_indexer = true;//it's mg, then the level is set as attribute of
2076 }
2077 if (mg_indexer == false)
2078 {
2079 // It's mgpp. Construct 'level' and 'defaultLevel' elements separately.
2080 convertLevels(from, to, search);
2081 }
2082
2083 for (int j = 0; j < index_elements_length; j++)
2084 {
2085 Element index_element = (Element) index_elements.item(j);
2086 if (index_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2087 {
2088 continue;
2089 }
2090
2091 Element index_ele = to.createElement(StaticStrings.INDEX_LOW_STR);//index
2092
2093 // Used for creating displayItem for this element 'index_ele' further below
2094 // full_index_names contain 'ex.'
2095 String full_index_name = "";
2096 String level_str = "";
2097
2098 StringBuffer index_value = new StringBuffer();
2099 if (mg_indexer == true)
2100 {
2101 // For mg indexer, there is a 'level' attribute in the index element of the internal structure
2102 // But mgpp/lucene don't
2103 level_str = index_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE);
2104 if (level_str.length() > 0)
2105 {
2106 index_value.append(level_str).append(StaticStrings.COLON_CHARACTER);
2107 //index_value = index_value.StaticStrings.COLON_CHARACTER;
2108 }
2109 }
2110
2111 NodeList content_elements = index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
2112 int content_elements_length = content_elements.getLength();
2113
2114 for (int k = 0; k < content_elements_length; k++)
2115 {
2116 Element content_element = (Element) content_elements.item(k);
2117 if (content_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2118 {
2119 continue;
2120 }
2121 String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2122
2123 full_index_name = full_index_name + name_str;
2124 if (k < content_elements_length - 1)
2125 {
2126 full_index_name = full_index_name + StaticStrings.COMMA_CHARACTER;
2127 }
2128
2129 if (name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_str.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2130 {
2131 name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2132 }
2133
2134 index_value.append(name_str);
2135 name_str = null;
2136 // Make it comma separated string
2137 if (k < content_elements_length - 1)
2138 {
2139 index_value.append(StaticStrings.COMMA_CHARACTER);
2140 }
2141 content_element = null;
2142 }//for loop ends
2143
2144 String temp_str = index_value.toString();
2145 index_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, temp_str);
2146
2147 // Now constructing 'displayItem' element for this 'index_ele' element
2148 // The index names in the collectionmetadata elements in the internal structure are not the names that
2149 // are used in the content elements (i.e. ex.Source or dc.Subject and keywords), but the names that are
2150 // in the configuration files (i.e. Source or dc.Subject)
2151 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, temp_str);
2152
2153 if (collectionmetadata_list == null)
2154 {
2155 //try the full name, i.e. with 'ex.'
2156 if (mg_indexer == true)
2157 {
2158 // but first append level info if we are mg
2159 full_index_name = level_str + StaticStrings.COLON_CHARACTER + full_index_name;
2160 }
2161 collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, full_index_name);
2162 }
2163
2164 if (collectionmetadata_list != null)
2165 {
2166
2167 for (int k = 0; k < collectionmetadata_list.size(); k++)
2168 {
2169 Element collectionmetadata = (Element) collectionmetadata_list.get(k);
2170 if (collectionmetadata.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2171 {
2172 continue;
2173 }
2174 Element displayItem = constructDisplayItem(collectionmetadata, to);
2175
2176 index_ele.appendChild(displayItem);
2177 }
2178 }
2179
2180 // deal with any <option name='' value=''> children of this index
2181 // e.g. <option name='solrfieldtype' value='text_es'>
2182 NodeList option_children = index_element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2183 for (int k = 0; k < option_children.getLength(); k++)
2184 {
2185 Element el = (Element) option_children.item(k);
2186 if (el.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2187 {
2188 continue;
2189 }
2190 String name_str = el.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2191 String value_str = XMLTools.getNodeText(el);
2192
2193 if (name_str == null && value_str == null)
2194 {
2195 continue;
2196 }
2197 Element option_element = to.createElement(StaticStrings.OPTION_STR);
2198 if (!name_str.equals("")) {
2199 option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2200 }
2201 if (!value_str.equals("")) { // or no value attribute without name attribute?
2202 option_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str);
2203 }
2204 index_ele.appendChild(option_element);
2205 }
2206
2207 search.appendChild(index_ele);
2208
2209 } //for loop ends
2210
2211 //Convert default index
2212 convertDefaultIndex(from, to, search);
2213 convertIndexOptions(from, to, search);
2214 }
2215
2216 //convert <facet> and <sort> elements and their displayItem subelements,
2217 //which go in 'search' element in collectionConfig.xml
2218 //parameter 'to' is the document to be saved as collectionConfig.xml
2219 //parameter 'from' is the internal xml structure
2220 // Note that GLI at present does not allow the user to set or modify the solr-specific elements
2221 // <sort> and <facet>. This function, and its inverse convertSolrFacetsAndSorts, is only here to preserve such
2222 // elements if they already exist in the collectionConfig.xml. At present they need to be manually added there.
2223 static private void convertSolrFacetsAndSorts(Document from, Document to)
2224 {
2225 Element source = from.getDocumentElement();
2226 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
2227 Element search = (Element) XMLTools.getChildByTagName(to.getDocumentElement(), StaticStrings.SEARCH_STR);
2228
2229 //There are two sets of <Solr> elements, find the one which is assigned 'true'
2230 Element solr = XMLTools.getNamedElement(source, StaticStrings.SOLR_ELEMENT, StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
2231 if (solr == null)
2232 {
2233 return;
2234 }
2235 NodeList sort_elements = solr.getElementsByTagName(StaticStrings.SORT_ELEMENT); //<Sort>
2236 int sort_elements_length = sort_elements.getLength();
2237 NodeList facet_elements = solr.getElementsByTagName(StaticStrings.FACET_ELEMENT); //<Facet>
2238 int facet_elements_length = facet_elements.getLength();
2239
2240 for (int j = 0; j < sort_elements_length; j++)
2241 {
2242 Element sort_element = (Element) sort_elements.item(j);
2243 if (sort_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2244 {
2245 continue;
2246 }
2247
2248 Element sort_ele = to.createElement(StaticStrings.SORT_LOW_STR);//<sort>
2249 String name_attr = sort_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2250
2251 /*if (name_attr.startsWith(StaticStrings.EXTRACTED_NAMESPACE) && name_attr.indexOf(StaticStrings.NS_SEP, StaticStrings.EXTRACTED_NAMESPACE.length()) == -1)
2252 {
2253 name_attr = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
2254 }
2255 */
2256 sort_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_attr);
2257
2258 // Now constructing 'displayItem' element for this 'sort_ele' element
2259 Element displayItem = (Element) XMLTools.getChildByTagName(sort_element, StaticStrings.DISPLAYITEM_ELEMENT); // gets the first <DisplayItem> (not <displayItem>!) child of <Sort>
2260
2261 if(displayItem != null) {
2262 if (displayItem.hasAttribute(StaticStrings.ASSIGNED_ATTRIBUTE) && displayItem.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
2263 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_STR);//<displayItem>
2264
2265 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
2266 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2267 String value_str = displayItem.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2268
2269 if (lang_str != null && !lang_str.equals(""))
2270 {
2271 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
2272 }
2273 if (name_str != null && !name_str.equals(""))
2274 {
2275 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2276 }
2277 if (value_str != null && !value_str.equals(""))
2278 {
2279 XMLTools.setNodeText(displayItem_element, value_str);
2280 }
2281 sort_ele.appendChild(displayItem_element);
2282 }
2283 }
2284
2285 search.appendChild(sort_ele);
2286
2287 } //for loop on sort_elements ends
2288
2289 for (int j = 0; j < facet_elements_length; j++)
2290 {
2291 Element facet_element = (Element) facet_elements.item(j);
2292 if (facet_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2293 {
2294 continue;
2295 }
2296
2297 Element facet_ele = to.createElement(StaticStrings.FACET_LOW_STR);//<facet>
2298 String name_attr = facet_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2299
2300 facet_ele.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_attr);
2301
2302 // Now constructing 'displayItem' element for this 'facet_ele' element
2303 Element displayItem = (Element) XMLTools.getChildByTagName(facet_element, StaticStrings.DISPLAYITEM_ELEMENT); // gets the first <DisplayItem> (not <displayItem>!) child of <Facet>
2304
2305 if(displayItem != null) {
2306 if (displayItem.hasAttribute(StaticStrings.ASSIGNED_ATTRIBUTE) && displayItem.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
2307 Element displayItem_element = to.createElement(StaticStrings.DISPLAYITEM_STR);//<displayItem>
2308
2309 String lang_str = displayItem.getAttribute(StaticStrings.LANG_ATTRIBUTE);
2310 String name_str = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2311 String value_str = displayItem.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2312
2313 if (lang_str != null && !lang_str.equals(""))
2314 {
2315 displayItem_element.setAttribute(StaticStrings.LANG_ATTRIBUTE, lang_str);
2316 }
2317 if (name_str != null && !name_str.equals(""))
2318 {
2319 displayItem_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2320 }
2321 if (value_str != null && !value_str.equals(""))
2322 {
2323 XMLTools.setNodeText(displayItem_element, value_str);
2324 }
2325 facet_ele.appendChild(displayItem_element);
2326 }
2327 }
2328
2329 search.appendChild(facet_ele);
2330
2331 } //for loop on facet_elements ends
2332
2333 }
2334
2335 // Convert levels for mgpp/lucene. This method is called by converIndex() when mgpp indexer is detected.
2336 static private void convertLevels(Document from, Document to, Element search)
2337 {
2338 Element source = from.getDocumentElement();
2339 Element index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTIONS_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVELS_STR);
2340 if (index_option == null)
2341 {
2342 return;
2343 }
2344 //Debugging purposes
2345 if (index_option.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2346 {
2347 DebugStream.println("For mgpp, there should be an IndexOption element for levels which is assigned 'true': possible bug.");
2348 }
2349
2350 NodeList option_elements = index_option.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2351 int num_elements = option_elements.getLength();
2352
2353 // Don't output anything if no indexes are set
2354 if (num_elements == 0)
2355 {
2356 return;//
2357 }
2358
2359 for (int k = 0; k < num_elements; k++)
2360 {
2361 Element e = (Element) option_elements.item(k);
2362 String name_str = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2363 Element level_element = to.createElement(StaticStrings.LEVEL_ELEMENT);
2364 level_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
2365
2366 //Now construct displayItem for this level element from collectionmetadata
2367 ArrayList collectionmetadata_list = XMLTools.getNamedElementList(source, StaticStrings.COLLECTIONMETADATA_ELEMENT, StaticStrings.NAME_ATTRIBUTE, name_str);
2368
2369 if (collectionmetadata_list != null)
2370 {
2371
2372 for (int j = 0; j < collectionmetadata_list.size(); j++)
2373 {
2374 Element collectionmetadata = (Element) collectionmetadata_list.get(j);
2375
2376 Element displayItem = constructDisplayItem(collectionmetadata, to);
2377 level_element.appendChild(displayItem);
2378 }
2379 }
2380 search.appendChild(level_element);
2381 }
2382
2383 //Convert default level
2384 Element default_index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTION_DEFAULT_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVEL_DEFAULT_STR);
2385 if (default_index_option == null)
2386 {
2387 return;
2388 }
2389 Element default_level = to.createElement(StaticStrings.LEVEL_DEFAULT_ELEMENT);
2390 String default_level_str = default_index_option.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
2391 default_level.setAttribute(StaticStrings.NAME_ATTRIBUTE, default_level_str);
2392 search.appendChild(default_level);
2393
2394 }
2395
2396 // Convert indexoptions for mg/mgpp/lucene. This method is called by convertIndex().
2397 static private void convertIndexOptions(Document from, Document to, Element search)
2398 {
2399 Element source = from.getDocumentElement();
2400 Element index_option = XMLTools.getNamedElement(source, StaticStrings.INDEXOPTIONS_ELEMENT, StaticStrings.NAME_ATTRIBUTE, StaticStrings.INDEXOPTIONS_STR);
2401 if (index_option == null)
2402 {
2403 return;
2404 }
2405 //Debugging purposes
2406 if (index_option.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR))
2407 {
2408 DebugStream.println("There should be an IndexOption element which is assigned 'true': possible bug.");
2409 return;
2410 }
2411 //Element indexOptionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
2412 NodeList option_elements = index_option.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
2413 int num_elements = option_elements.getLength();
2414 // Don't output anything if no index
2415 if (num_elements == 0)
2416 {
2417 return;//
2418 }
2419 //search.appendChild(indexOptionEl);
2420
2421 for (int k = 0; k < num_elements; k++)
2422 {
2423 Element e = (Element) option_elements.item(k);
2424 String name_att = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2425 Element optionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
2426 optionEl.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_att);
2427 // default value?? on/off
2428 //indexOptionEl.appendChild(optionEl);
2429 search.appendChild(optionEl);
2430 }
2431
2432 }
2433
2434 // handle top level elements which GLI knows nothing about
2435 // we store them internally in a Unknown element for easy access when
2436 // we write them out.
2437 static private void doUnknownElements(Document to, Element from)
2438 {
2439 Element toElement = to.getDocumentElement();
2440 Element unknownElement = to.createElement(StaticStrings.UNKNOWN_ELEMENT);
2441 toElement.appendChild(unknownElement);
2442
2443 Node child = from.getFirstChild();
2444 while (child != null)
2445 {
2446 if (child.getNodeType() == Node.ELEMENT_NODE && !known_element_names.contains(child.getNodeName()))
2447 {
2448 unknownElement.appendChild(XMLTools.duplicateElement(to, (Element) child, true));
2449 }
2450 child = child.getNextSibling();
2451 }
2452
2453 }
2454
2455 // just copy all children of Unknown element into output doc.
2456 static private void convertUnknownElements(Document from, Document to)
2457 {
2458
2459 Element toElement = to.getDocumentElement();
2460 Node unknown_element = XMLTools.getChildByTagName(from.getDocumentElement(), StaticStrings.UNKNOWN_ELEMENT);
2461
2462 Node child = unknown_element.getFirstChild();
2463 while (child != null)
2464 {
2465 Element to_element = XMLTools.duplicateElement(to, (Element) child, true);
2466 toElement.appendChild(to_element);
2467
2468 child = child.getNextSibling();
2469 }
2470
2471 }
2472
2473 // Append the element son to the element mother in the appropriate position.
2474 static public void appendProperly(Element mother, Element son)
2475 {
2476 if (son == null)
2477 return;
2478
2479 Node reference_node = findInsertionPoint(mother, son);
2480 if (reference_node != null)
2481 {
2482 mother.insertBefore(son, reference_node);
2483 }
2484 else
2485 {
2486 mother.appendChild(son);
2487 }
2488 }
2489
2490 /**
2491 * Find the best insertion position for the given DOM Element
2492 * 'target_element' in the DOM Element 'document_element'. This should try
2493 * to match command tag, and if found should then try to group by name or
2494 * type (eg CollectionMeta), or append to end is no such grouping exists (eg
2495 * Plugins). Failing a command match it will check against the command order
2496 * for the best insertion location.
2497 *
2498 * @param target_element
2499 * the command Element to be inserted
2500 * @return the Element which the given command should be inserted before, or
2501 * null to append to end of list
2502 */
2503 static public Node findInsertionPoint(Element document_element, Element target_element)
2504 {
2505 ///ystem.err.println("Find insertion point: " + target_element.getNodeName());
2506 String target_element_name = target_element.getNodeName();
2507
2508 // Try to find commands with the same tag.
2509 NodeList matching_elements = document_element.getElementsByTagName(target_element_name);
2510 // If we found matching elements, then we have our most likely insertion location, so check within for groupings
2511 if (matching_elements.getLength() != 0)
2512 {
2513 ///ystem.err.println("Found matching elements.");
2514 // Only CollectionMeta are grouped.
2515 if (target_element_name.equals(StaticStrings.COLLECTIONMETADATA_ELEMENT))
2516 {
2517 ///ystem.err.println("Dealing with collection metadata");
2518 // 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.
2519 // So if the command to be added is special add it immediately after any other special command
2520 if (target_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2521 {
2522 int index = 0;
2523 Element matched_element = (Element) matching_elements.item(index);
2524 Element sibling_element = (Element) matched_element.getNextSibling();
2525 while (sibling_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2526 {
2527 index++;
2528 matched_element = (Element) matching_elements.item(index);
2529 sibling_element = (Element) matched_element.getNextSibling();
2530 }
2531 if (sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2532 {
2533 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2534 document_element.insertBefore(newline_element, sibling_element);
2535 }
2536 return sibling_element;
2537 }
2538 // Otherwise try to find a matching 'name' and add after the last one in that group.
2539 else
2540 {
2541 int index = 0;
2542 target_element_name = target_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2543 boolean found = false;
2544 // Skip all of the special metadata
2545 Element matched_element = (Element) matching_elements.item(index);
2546 while (matched_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR))
2547 {
2548 index++;
2549 matched_element = (Element) matching_elements.item(index);
2550 }
2551 // Begin search
2552 while (!found && matched_element != null)
2553 {
2554 if (matched_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name))
2555 {
2556 found = true;
2557 }
2558 else
2559 {
2560 index++;
2561 matched_element = (Element) matching_elements.item(index);
2562 }
2563 }
2564 // If we found a match, we need to continue checking until we find the last name match.
2565 if (found)
2566 {
2567 index++;
2568 Element previous_sibling = matched_element;
2569 Element sibling_element = (Element) matching_elements.item(index);
2570 while (sibling_element != null && sibling_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name))
2571 {
2572 previous_sibling = sibling_element;
2573 index++;
2574 sibling_element = (Element) matching_elements.item(index);
2575 }
2576 // 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!
2577 return previous_sibling.getNextSibling();
2578 }
2579 // If not found we just add after last metadata element
2580 else
2581 {
2582 Element last_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2583 return last_element.getNextSibling();
2584 }
2585 }
2586
2587 }
2588 else
2589 {
2590 ///ystem.err.println("Not dealing with collection meta.");
2591 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2592 // 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)
2593 Node sibling_element = matched_element.getNextSibling();
2594 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2595 {
2596 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2597 document_element.insertBefore(newline_element, sibling_element);
2598 }
2599 return sibling_element; // Note that this may be null
2600 }
2601 }
2602 ///ystem.err.println("No matching elements found.");
2603 // Locate where this command is in the ordering
2604 int command_index = -1;
2605 for (int i = 0; command_index == -1 && i < CollectionConfiguration.COMMAND_ORDER.length; i++)
2606 {
2607 if (CollectionConfiguration.COMMAND_ORDER[i].equals(target_element_name))
2608 {
2609 command_index = i;
2610 }
2611 }
2612 ///ystem.err.println("Command index is: " + command_index);
2613 // Now move forward, checking for existing elements in each of the preceeding command orders.
2614 int preceeding_index = command_index - 1;
2615 ///ystem.err.println("Searching before the target command.");
2616 while (preceeding_index >= 0)
2617 {
2618 matching_elements = document_element.getElementsByTagName(CollectionConfiguration.COMMAND_ORDER[preceeding_index]);
2619 // If we've found a match
2620 if (matching_elements.getLength() > 0)
2621 {
2622 // We add after the last element
2623 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
2624 // 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)
2625 Node sibling_element = matched_element.getNextSibling();
2626 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2627 {
2628 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2629 document_element.insertBefore(newline_element, sibling_element);
2630 }
2631 return sibling_element; // Note that this may be null
2632 }
2633 preceeding_index--;
2634 }
2635 // If all that fails, we now move backwards through the commands
2636 int susceeding_index = command_index + 1;
2637 ///ystem.err.println("Searching after the target command.");
2638 while (susceeding_index < CollectionConfiguration.COMMAND_ORDER.length)
2639 {
2640 matching_elements = document_element.getElementsByTagName(CollectionConfiguration.COMMAND_ORDER[susceeding_index]);
2641 // If we've found a match
2642 if (matching_elements.getLength() > 0)
2643 {
2644 // We add before the first element
2645 Element matched_element = (Element) matching_elements.item(0);
2646 // 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)
2647 Node sibling_element = matched_element.getPreviousSibling();
2648 if (sibling_element != null && sibling_element.getNodeName().equals(CollectionConfiguration.NEWLINE_ELEMENT))
2649 {
2650 Element newline_element = document_element.getOwnerDocument().createElement(CollectionConfiguration.NEWLINE_ELEMENT);
2651 document_element.insertBefore(newline_element, sibling_element);
2652 }
2653 return sibling_element; // Note that this may be null
2654 }
2655 susceeding_index++;
2656 }
2657 // Well. Apparently there are no other commands in this collection configuration. So append away...
2658 return null;
2659 }
2660
2661 // From collectionConfig.xml to internal structure:add 'ex.' namespace (if none).
2662 // From internal structure to collectionConfig.xml:always peel off 'ex.' namespace (if any), except for format statement
2663 //This method parses 'xml_file_doc' into 'dOc'
2664 static public void parse(File xml_file, Document dOc)
2665 {
2666
2667 Document xml_file_doc = XMLTools.parseXMLFile(xml_file);
2668 Element fromElement = xml_file_doc.getDocumentElement();
2669 Element toElement = dOc.getDocumentElement();
2670
2671 // security element. For now, we just save as is, as you can't edit this in GLI.
2672 Node securityNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.SECURITY_STR,0);
2673 // just save for now
2674 if (securityNode != null) {
2675 Element to_element = XMLTools.duplicateElement(dOc, (Element) securityNode, true);
2676 toElement.appendChild(to_element);
2677 }
2678 // It's deliberately set that 'creator', 'maintainer', and 'public' are only in English (as they are just names).
2679 // So the following ArrayList have only one element.
2680 Node metadataListNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.METADATALIST_STR, 0);
2681 if (metadataListNode != null)
2682 {
2683 ArrayList creator = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_CREATOR_STR);
2684 ArrayList maintainer = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR);
2685 ArrayList is_public = doMetadataList(dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_STR);
2686
2687 appendArrayList(toElement, creator);
2688 appendArrayList(toElement, maintainer);
2689 appendArrayList(toElement, is_public);
2690 }
2691
2692 Node databaseNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.INFODB_STR, 0);
2693 String databasetype_value = "gdbm";
2694 if (databaseNode != null)
2695 {
2696 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)
2697 }
2698
2699 Element databasetype = doDatabaseType(dOc, databasetype_value);
2700 appendProperly(toElement, databasetype);
2701
2702 Node searchNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.SEARCH_STR, 0);
2703 String buildtype_value = ((Element) searchNode).getAttribute(StaticStrings.TYPE_ATTRIBUTE);//might be mg|mgpp|lucene
2704 Element buildtype = doBuildType(dOc, buildtype_value);
2705 appendProperly(toElement, buildtype);
2706
2707 Node importNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.IMPORT_STR, 0);
2708 if (importNode == null)
2709 {
2710 System.out.println("There is no content in the 'import' block.");
2711 }
2712 if (importNode != null)
2713 {
2714 //do plugin list nodes
2715 Node pluginListNode = XMLTools.getChildByTagNameIndexed((Element) importNode, StaticStrings.PLUGINLIST_STR, 0);
2716 if (pluginListNode == null)
2717 {
2718 System.out.println("There is no pluginlist set.");
2719 }
2720 if (pluginListNode != null)
2721 {
2722
2723 doPlugins(dOc, pluginListNode);
2724 }
2725
2726 //do the plugout element (used by building flax collections)
2727 Node plugout = XMLTools.getChildByTagNameIndexed((Element) importNode, PLUGOUT_ELEMENT, 0);
2728 if (plugout != null)
2729 {
2730 Element to_element = XMLTools.duplicateElement(dOc, (Element) plugout, true);
2731 toElement.appendChild(to_element);
2732 }
2733 }
2734
2735 Node browseNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.BROWSE_STR, 0);
2736 if (browseNode != null)
2737 {
2738 if (browseNode == null)
2739 {
2740 System.out.println("There is no classifier.");
2741 }
2742 doClassifier(dOc, browseNode);
2743 }
2744
2745 Node displayItemListNode = XMLTools.getChildByTagNameIndexed(fromElement, StaticStrings.DISPLAYITEMLIST_STR, 0);
2746 if (displayItemListNode != null)
2747 {
2748 ArrayList description = doDisplayItemList(dOc, displayItemListNode, StaticStrings.DESCRIPTION_STR, StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR);
2749 ArrayList smallicon = doDisplayItemList(dOc, displayItemListNode, StaticStrings.SMALLICON_STR, StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR);
2750 ArrayList icon = doDisplayItemList(dOc, displayItemListNode, StaticStrings.ICON_STR, StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR);
2751 ArrayList name = doDisplayItemList(dOc, displayItemListNode, StaticStrings.NAME_STR, StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR);
2752
2753 appendArrayList(toElement, description);
2754 appendArrayList(toElement, smallicon);
2755 appendArrayList(toElement, icon);
2756 appendArrayList(toElement, name);
2757 }
2758
2759 if (buildtype_value.equalsIgnoreCase("mg"))
2760 {
2761 doMGIndexes(dOc, searchNode);
2762 }
2763 else
2764 {
2765 doMGPPIndexes(dOc, searchNode);
2766 }
2767
2768 if(buildtype_value.equalsIgnoreCase("solr") || buildtype_value.equalsIgnoreCase("lucene")) {
2769 doSolrFacetsAndSorts(dOc, searchNode); // <facet><displayItem /></facet> and <sort><displayItem /></sort>
2770 // lucene will only have sort elements
2771 }
2772
2773 doDefaultIndex(dOc, searchNode);
2774 doDefaultLevel(dOc, searchNode);
2775 doLevel(dOc, searchNode);
2776 doIndexOption(dOc, searchNode);
2777 doSubcollection(dOc, searchNode);
2778 doIndexSubcollection(dOc, searchNode);
2779 doIndexLanguage(dOc, searchNode);
2780 doDefaultIndexLanguage(dOc, searchNode);
2781 doLanguageMetadata(dOc, searchNode);
2782 doSearchType(dOc, searchNode);
2783 doSearchFormat(dOc, searchNode);
2784 doGlobalFormat(dOc, fromElement);
2785 doDisplayFormat(dOc, fromElement);
2786 doReplaceListRef(dOc, fromElement);
2787 doReplaceList(dOc, fromElement);
2788 doServiceRackList(dOc, fromElement);
2789 doUnknownElements(dOc, fromElement);
2790 // the official displayItems in the displayItemList element have already been handled above
2791 // and created as collectionmetadata elements in the dOc object
2792 // Now we add in all the *other* (remaining) displayItems as collectionmeta elements
2793 NodeList collectionMetadataList = dOc.getDocumentElement().getElementsByTagName(StaticStrings.COLLECTIONMETADATA_ELEMENT);
2794 Set setOfUniqueColMetaNames = new HashSet();
2795 for (int i = 0; i < collectionMetadataList.getLength(); i++)
2796 {
2797 Element colMeta = (Element) collectionMetadataList.item(i);
2798 String name = colMeta.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2799 setOfUniqueColMetaNames.add(name);
2800 }
2801
2802 if (displayItemListNode != null)
2803 {
2804 NodeList nl = ((Element) displayItemListNode).getElementsByTagName(StaticStrings.DISPLAYITEM_STR);
2805
2806 // make a list of all unique attribute names that are specifically not
2807 // description, smallicon, icon and name, since these are already processed above
2808 Set setOfUniqueDisplayItemNames = new LinkedHashSet();
2809 for (int i = 0; i < nl.getLength(); i++)
2810 {
2811 Element displayItem = (Element) nl.item(i);
2812 String name = displayItem.getAttribute(StaticStrings.NAME_ATTRIBUTE);
2813
2814 if (name.equals(""))
2815 continue; // no name attribute
2816 if (setOfUniqueColMetaNames.contains(name))
2817 continue;
2818
2819 if (name.equals(StaticStrings.DESCRIPTION_STR))
2820 continue;
2821 if (name.equals(StaticStrings.SMALLICON_STR))
2822 continue;
2823 if (name.equals(StaticStrings.ICON_STR))
2824 continue;
2825 if (name.equals(StaticStrings.NAME_STR))
2826 continue;
2827 // don't add displayItems that are handled by the indexers, etc. E.g. document:ex.Title
2828 if (name.indexOf(":") != -1)
2829 continue;
2830
2831 // otherwise
2832 setOfUniqueDisplayItemNames.add(name); // Set will ensure no duplicate names
2833 }
2834
2835 Iterator i = setOfUniqueDisplayItemNames.iterator();
2836 while (i.hasNext())
2837 {
2838 String displayItemName = (String) i.next();
2839
2840 ArrayList custom_displayItem = doDisplayItemList(dOc, displayItemListNode, displayItemName, displayItemName);
2841 appendArrayList(toElement, custom_displayItem);
2842 }
2843 }
2844
2845 }
2846
2847 static public String generateStringVersion(Document doc)
2848 {
2849 return XMLTools.xmlNodeToString(doc);
2850 }
2851
2852 static public void save(File collect_config_xml_file, Document doc)
2853 {
2854 Document collection_config_xml_document = convertInternalToCollectionConfig(doc);
2855 String[] nonEscapingTagNames = { StaticStrings.FORMAT_STR, StaticStrings.DISPLAYITEM_STR };
2856 XMLTools.writeXMLFile(collect_config_xml_file, collection_config_xml_document, nonEscapingTagNames);
2857 }
2858
2859 //Convert the internal XML DOM tree (dOc) into that of collectionConfig.xml (skeleton)
2860 static private Document convertInternalToCollectionConfig(Document dOc)
2861 {
2862 //first parse an empty skeleton of xml config file
2863 //The aim is to convert the internal structure into this skeleton
2864 // This skeleton just has the CollectionConfig element and nothing else
2865 Document skeleton = XMLTools.parseXMLFile("xml/CollectionConfig.xml", true);
2866 //Element internal = dOc.getDocumentElement();
2867 convertSecurity(dOc, skeleton);
2868 convertMetadataList(dOc, skeleton);
2869 convertDisplayItemList(dOc, skeleton);
2870 convertGlobalFormat(dOc, skeleton);
2871 convertBuildType(dOc, skeleton);
2872 convertDatabaseType(dOc, skeleton);
2873 convertIndex(dOc, skeleton);
2874 convertSolrFacetsAndSorts(dOc, skeleton);
2875 convertPlugins(dOc, skeleton);//also do the plugout element
2876 convertClassifier(dOc, skeleton);
2877 convertSubcollectionIndexes(dOc, skeleton);
2878 convertLanguages(dOc, skeleton);
2879 convertSubcollection(dOc, skeleton);
2880 convertSearchType(dOc, skeleton);
2881 convertSearchFormat(dOc, skeleton);
2882 convertDisplayFormat(dOc, skeleton);
2883 convertReplaceListRef(dOc, skeleton);
2884 convertReplaceList(dOc, skeleton);
2885 convertServiceRackList(dOc, skeleton);
2886 convertUnknownElements(dOc, skeleton); // try to catch everything GLI doesn't know about
2887
2888 return skeleton;
2889 }
2890
2891 // Append the elements, which are of Element type, in 'list' to Element 'to'
2892 static private void appendArrayList(Element to, ArrayList list)
2893 {
2894 if (list == null)
2895 return;
2896
2897 for (int i = 0; i < list.size(); i++)
2898 {
2899 appendProperly(to, (Element) list.get(i));
2900 }
2901 }
2902
2903}
Note: See TracBrowser for help on using the repository browser.