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

Last change on this file since 22381 was 22381, checked in by kjdon, 14 years ago

There can be more than one replaceListRef, so hanlde this case. OAI element no longer used. Instead its inside a serviceRackList, so handle this instead
File size: 93.9 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.HashMap;
33import java.util.StringTokenizer;
34
35import org.greenstone.gatherer.DebugStream;
36import org.greenstone.gatherer.metadata.MetadataElement;
37import org.greenstone.gatherer.metadata.MetadataTools;
38import org.greenstone.gatherer.util.XMLTools;
39import org.greenstone.gatherer.util.StaticStrings;
40import org.greenstone.gatherer.util.Utility;
41
42import org.w3c.dom.*;
43
44public class CollectionConfigXMLReadWrite {
45
46 static final private String PLUGOUT_ELEMENT = "plugout";//used by building flax collections
47
48 /** ********************************************************************************************************
49 The code from this point below are used for greenstone 3 collection configuration, i.e., read ColletionConfig.xml
50 * into the internal DOM tree, and convert the internal DOM tree back to CollectionConfig.xml.
51 *
52 Methods named 'doXXXX' are for convert collectionConfig.xml into the internal configuration xml structure;
53 Methods named 'convertXXXX' are for convert the internal configuration xml structure back to collectionConfig.xml.
54 ************************************************************************************************************ */
55
56 /**Arguments: metadataListNode->the 'displayItemList' element in collectionConfig.xml
57 name_value->the value of the 'name' attribute of 'index' element;
58 att_value->the value of the 'name' attribute of 'displayItem' element
59 return: an ArrayList of the contructed 'CollectionMetadata' elements
60 */
61 static private ArrayList doDisplayItemList (Document to, Node displayListNode, String att_value, String name_value) {
62 Element toElement = to.getDocumentElement ();
63 ArrayList display_item_list = new ArrayList ();
64 ArrayList item_list = XMLTools.getNamedElementList ((Element)displayListNode,
65 StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, att_value);
66 if (item_list == null) {
67 return null;
68 }
69
70 for (int i=0; i<item_list.size (); i++) {
71 Element item = (Element)item_list.get (i);
72 String text = XMLTools.getNodeText (item);
73
74 //If there is nothing to display, don't bother creating the element
75 if (text == "") {
76 continue;
77 }
78 //get the value in 'lang=value'
79 String lang = item.getAttribute (StaticStrings.LANG_STR);
80
81 Element e = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
82 e.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
83 e.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_value);
84 e.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
85 XMLTools.setNodeText (e, text);
86 display_item_list.add (e);
87 }
88 return display_item_list;
89 }
90
91 static private ArrayList doMetadataList (Document to, Node metadataListNode, String ele_name, String att_value) {
92 Element toElement = to.getDocumentElement ();
93 ArrayList metadata_list = new ArrayList ();
94
95 ArrayList item_list = XMLTools.getNamedElementList ((Element)metadataListNode,
96 StaticStrings.METADATA_STR, StaticStrings.NAME_ATTRIBUTE, att_value);
97 if (item_list == null) {
98 return null;
99 }
100
101 for (int i=0; i<item_list.size (); i++) {
102 Element item = (Element)item_list.get (i);
103 String text = XMLTools.getNodeText (item);
104
105 //If there is nothing to display, don't bother creating the element
106 if (text == "") {
107 continue;
108 }
109 //get the value in 'lang=value'
110 String lang = item.getAttribute (StaticStrings.LANG_STR);
111
112 Element element = to.createElement (ele_name);
113 element.setAttribute (StaticStrings.NAME_ATTRIBUTE, att_value);
114 element.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
115 element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
116 element.setAttribute (StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
117 XMLTools.setNodeText (element, text);
118
119 metadata_list.add (element);
120 }
121 return metadata_list;
122 }
123 // 'to' is the internal structure
124 static private void doMGIndexes (Document to, Node searchNode) {
125 Element toElement = to.getDocumentElement ();
126 Element indexes_element = to.createElement (StaticStrings.INDEXES_ELEMENT);//<Indexes>
127 indexes_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
128 indexes_element.setAttribute (StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
129
130 NodeList index_children = ((Element)searchNode).getElementsByTagName (StaticStrings.INDEX_LOW_STR);//index
131 int num_nodes = index_children.getLength ();
132
133 for (int i=0; i<num_nodes; i++) {
134 Element e = (Element)index_children.item (i);
135 String index_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
136 String index_str_display = index_str;//used for creating collectionmetadata for this index
137 Element index_element = to.createElement (StaticStrings.INDEX_ELEMENT);//<Index>
138
139 // For mg, it's the 'Old G2.38 and earlier' that use level:source tuplets, but we double check it anyway
140 boolean old_index = true;
141 if(index_str.indexOf (StaticStrings.COLON_CHARACTER) == -1) {
142 // It doesn't contain ':' character
143 System.err.println ("Something is wrong! the index should be level:source tuplets.");
144 old_index = false;
145 }
146 else {
147 // Handling 'index' element
148 index_element.setAttribute (StaticStrings.LEVEL_ATTRIBUTE,
149 index_str.substring (0, index_str.indexOf (StaticStrings.COLON_CHARACTER)));
150 index_str = index_str.substring (index_str.indexOf (StaticStrings.COLON_CHARACTER) + 1);
151
152 //Each index may have a list of comma-separated strings.
153 //split them into 'content' elements in the internal structure
154 StringTokenizer content_tokenizer = new StringTokenizer (index_str, StaticStrings.COMMA_CHARACTER);
155 //index_str = "";
156 while(content_tokenizer.hasMoreTokens ()) {
157 // Replace index_str to be qualified name, eg. dc.Subject and keywords insread of dc.Subject.
158
159
160 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
161 String content_str = content_tokenizer.nextToken ();
162 // Since the contents of indexes have to be certain keywords, or metadata elements,
163 //if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
164 if(content_str.indexOf (StaticStrings.NS_SEP) == -1) {
165 if(content_str.equals (StaticStrings.TEXT_STR) ||
166 (!old_index && content_str.equals (StaticStrings.ALLFIELDS_STR))) {
167 // in this case, do nothing
168 }
169 else {
170 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
171 }
172 }
173
174 content_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, content_str);
175 index_element.appendChild (content_element);
176 content_element = null;
177 } // while ends
178
179 indexes_element.appendChild (index_element);
180
181 // Handling 'displayItem' elements and Constructing 'collectionmetadata' elements
182 // Use the fully qualified index names
183 ArrayList collectionmetadata_list = doDisplayItemList (to, e, StaticStrings.NAME_ATTRIBUTE, index_str_display);
184 appendArrayList (toElement, collectionmetadata_list);
185 } //else ends
186 } //for loop ends
187 appendProperly (toElement, indexes_element);
188
189 //***//
190 // create another set of <indexes> which will be used when user switches to MGPP/LUCENE
191 // i.e. we build a default index set for a start
192
193 String []index_strs =
194 {StaticStrings.TEXT_STR,
195 StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.TITLE_ELEMENT,
196 StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.SOURCE_ELEMENT};
197
198 Element mgpp_indexes = to.createElement (StaticStrings.INDEXES_ELEMENT);//<Indexes>
199 mgpp_indexes.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
200 mgpp_indexes.setAttribute (StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
201 for (int i=0; i<index_strs.length; i++) {
202 Element index_element = to.createElement (StaticStrings.INDEX_ELEMENT);//<Index>
203 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
204 content_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
205 index_element.appendChild (content_element);
206 mgpp_indexes.appendChild (index_element);
207
208 // Contructing 'collectionmetadata' elements for 'mgpp' indexes
209 Element collectionmetadata = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
210 collectionmetadata.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
211 collectionmetadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
212 collectionmetadata.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
213 if (index_strs[i].indexOf (StaticStrings.NS_SEP) != -1) {
214 index_strs[i] = index_strs[i].substring (index_strs[i].indexOf (StaticStrings.NS_SEP) + 1);
215 }
216 XMLTools.setNodeText (collectionmetadata, index_strs[i]);
217
218 appendProperly (toElement, collectionmetadata);
219
220 }
221 appendProperly (toElement, mgpp_indexes);
222 }
223
224 //This is actually doing indexes for both mgpp and lucene
225 static private void doMGPPIndexes (Document to, Node searchNode) {
226 Element toElement = to.getDocumentElement ();
227 Element indexes_element = to.createElement (StaticStrings.INDEXES_ELEMENT);//<Indexes>
228 indexes_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
229 indexes_element.setAttribute (StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
230
231 NodeList index_children = ((Element)searchNode).getElementsByTagName (StaticStrings.INDEX_LOW_STR);//index
232 int num_nodes = index_children.getLength ();
233
234 for (int i=0; i<num_nodes; i++) {
235
236 Element index_element = to.createElement (StaticStrings.INDEX_ELEMENT);//<Index>
237 Element e = (Element)index_children.item (i);
238 String index_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
239 String index_str_display = index_str;//for creating collectionmetadata for this index
240
241 // Handling 'index' element
242 // Double check to make sure it's not colon separated style index.
243 boolean old_index = false;
244 if(index_str.indexOf (StaticStrings.COLON_CHARACTER) != -1) {
245 System.err.println ("Something is wrong! the index should NOT be level:source tuplets style.");
246 old_index = true;
247 }
248 //Each index may have a list of comma-separated strings.
249 //split them into 'content' elements in the internal structure
250 StringTokenizer content_tokenizer = new StringTokenizer (index_str, StaticStrings.COMMA_CHARACTER);
251 //index_str = "";
252 while(content_tokenizer.hasMoreTokens ()) {
253 // Replace index_str to be qualified name, eg. dc.Subject and keywords insread of dc.Subject.
254
255 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
256 String content_str = content_tokenizer.nextToken ();
257 // 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.
258 if(content_str.indexOf (StaticStrings.NS_SEP) == -1) {
259 if(content_str.equals (StaticStrings.TEXT_STR)) {
260 // in this case, do nothing
261 }
262 else {
263 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
264 }
265 }
266 content_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, content_str);
267 index_element.appendChild (content_element);
268 content_element = null;
269 } //while ends
270
271 indexes_element.appendChild (index_element);
272
273
274 index_element = null;
275
276 // Handling 'displayItem' element of this 'index' element
277 // 'e' is the parent element 'index' of 'displayItem' element
278 ArrayList collectionmetadata_list = doDisplayItemList (to, e, StaticStrings.NAME_ATTRIBUTE, index_str_display);
279 appendArrayList (toElement, collectionmetadata_list);
280
281
282 } // for loop ends
283 toElement.appendChild (indexes_element);
284
285 // create another set of <indexes> which will be used when user switches to MG
286 // i.e. we build a default index set for a start
287 Element mg_indexes = to.createElement (StaticStrings.INDEXES_ELEMENT);//<Indexes>
288 mg_indexes.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
289 mg_indexes.setAttribute (StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
290
291 //put the namespace '.ex' as prefix to the indexes
292 String []index_strs =
293 {StaticStrings.TEXT_STR,
294 StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.TITLE_ELEMENT,
295 StaticStrings.EXTRACTED_NAMESPACE + StaticStrings.SOURCE_ELEMENT};
296 for (int i=0; i<index_strs.length; i++) {
297 Element index_element = to.createElement (StaticStrings.INDEX_ELEMENT);//<Index>
298 index_element.setAttribute (StaticStrings.LEVEL_ATTRIBUTE, StaticStrings.DOCUMENT_STR);
299 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
300 content_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_strs[i]);
301 index_element.appendChild (content_element);
302
303 mg_indexes.appendChild (index_element);
304
305 // Contructing 'collectionmetadata' elements for 'mg' indexes
306 Element collectionmetadata = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
307 collectionmetadata.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
308 String temp = StaticStrings.DOCUMENT_STR.concat (StaticStrings.COLON_CHARACTER).concat (index_strs[i]);
309 collectionmetadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, temp);
310 collectionmetadata.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
311 if (index_strs[i].indexOf (StaticStrings.NS_SEP) != -1) {
312 index_strs[i] = index_strs[i].substring (index_strs[i].indexOf (StaticStrings.NS_SEP) + 1);
313 }
314 XMLTools.setNodeText (collectionmetadata, index_strs[i]);
315
316 appendProperly (toElement, collectionmetadata);
317
318 }
319 toElement.appendChild (mg_indexes);
320
321 }
322
323 static private void doDisplayFormat (Document to, Element from) {
324 //display element in the xml file
325 Element de = (Element)XMLTools.getChildByTagName (from, StaticStrings.DISPLAY_STR);
326 if (de == null) {
327 return;
328 }
329 //format element in the display element
330 Element fe = (Element)XMLTools.getChildByTagName (de, StaticStrings.FORMAT_STR);
331
332 to.getDocumentElement ().appendChild (doFormat(to, fe, StaticStrings.DISPLAY_STR));
333 }
334
335 //construct 'DefaultIndex' element in the internal structure from collectionConfig.xml
336 static private void doDefaultIndex (Document to, Node searchNode) {
337 Element toElement = to.getDocumentElement ();
338 Element default_index_element = to.createElement (StaticStrings.INDEX_DEFAULT_ELEMENT);
339 default_index_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
340
341 Element e = (Element)XMLTools.getChildByTagName (searchNode, StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);//defaultIndex
342 if (e == null) {
343 return;
344 }
345 String index_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
346
347 boolean old_index = false;
348 if(index_str.indexOf (StaticStrings.COLON_CHARACTER) != -1) {
349 //The index is 'level:source tuplets' which is for mg. Take out 'level'
350 old_index = true;
351 default_index_element.setAttribute (StaticStrings.LEVEL_ATTRIBUTE,
352 index_str.substring (0, index_str.indexOf (StaticStrings.COLON_CHARACTER)));
353 index_str = index_str.substring (index_str.indexOf (StaticStrings.COLON_CHARACTER) + 1);
354 } else {
355 default_index_element.setAttribute (StaticStrings.LEVEL_ATTRIBUTE, "");
356 }
357
358 //Each index may have a list of comma-separated strings.
359 //split them into 'content' elements in the internal structure
360 StringTokenizer content_tokenizer = new StringTokenizer (index_str, StaticStrings.COMMA_CHARACTER);
361 while(content_tokenizer.hasMoreTokens ()) {
362 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
363 String content_str = content_tokenizer.nextToken ();
364 // 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.
365 if(content_str.indexOf (StaticStrings.NS_SEP) == -1) {
366 if(content_str.equals (StaticStrings.TEXT_STR) ||
367 (!old_index && content_str.equals (StaticStrings.ALLFIELDS_STR))) {
368 // in this case, do nothing
369 }
370 else {
371 content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
372 }
373 }
374
375 content_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, content_str);
376 default_index_element.appendChild (content_element);
377 content_element = null;
378 }
379 appendProperly (toElement, default_index_element);
380 }
381 // For mg, this method is still called, but make it 'assigned=false'
382 static private void doDefaultLevel (Document to, Node searchNode) {
383 Element toElement = to.getDocumentElement ();
384 Element default_index_option = to.createElement (StaticStrings.INDEXOPTION_DEFAULT_ELEMENT);
385 default_index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.LEVEL_DEFAULT_STR);
386
387 Element e = (Element)XMLTools.getChildByTagName (searchNode, StaticStrings.LEVEL_DEFAULT_ELEMENT);
388 if (e != null) {
389 default_index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
390 String level = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
391 default_index_option.setAttribute (StaticStrings.VALUE_ATTRIBUTE, level);
392 } else {
393 //In the case of mg, there's no level! build a default one using 'assigned=false value=document'
394 default_index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
395 default_index_option.setAttribute (StaticStrings.VALUE_ATTRIBUTE, StaticStrings.DOCUMENT_STR);
396 }
397 appendProperly (toElement, default_index_option);
398 }
399
400 // Transform plugins (pluginListNode) of collectionConfig.xml into the internal structure (i.e. Document to)
401 static private void doPlugin (Document to, Node pluginListNode) {
402 Element toElement = to.getDocumentElement ();
403 NodeList plugin_children = ((Element)pluginListNode).getElementsByTagName (StaticStrings.PLUGIN_STR);
404 int plugin_nodes = plugin_children.getLength ();
405
406 if (plugin_nodes < 1) {
407 return;
408 }
409
410 for (int i=0; i<plugin_nodes; i++) {
411 Element e = (Element)plugin_children.item (i);
412 String str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
413 str = Utility.ensureNewPluginName(str);
414 Element plugin_element = to.createElement (StaticStrings.PLUGIN_ELEMENT);
415 plugin_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, str);
416
417
418 NodeList option_children = e.getElementsByTagName (StaticStrings.OPTION_STR);
419
420 for (int j=0; j<option_children.getLength (); j++) {
421 Element el = (Element)option_children.item (j);
422 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
423 if (name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
424 name_str = name_str.substring (1);
425 }
426 String value_str = el.getAttribute (StaticStrings.VALUE_ATTRIBUTE);
427 Element option_element = null;
428
429 if (name_str.equals ("") && !value_str.equals ("")) {
430 continue;
431 }
432
433
434 option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
435 option_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
436 if(name_str.equals (StaticStrings.RECPLUG_STR) && value_str.equals (StaticStrings.USE_METADATA_FILES_ARGUMENT)) {
437 continue; // ignore this option
438 }
439
440 if(value_str != null) {
441 // Remove any speech marks appended in strings containing whitespace
442 if(value_str.startsWith (StaticStrings.SPEECH_CHARACTER) && value_str.endsWith (StaticStrings.SPEECH_CHARACTER)) {
443 value_str = value_str.substring (1, value_str.length () - 1);
444 }
445 if(name_str.equals (StaticStrings.METADATA_STR)) {
446 // 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.
447 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
448 value_str = "";
449 for (int k=0; k<=values.length-1; k++) {
450 if (values[k].indexOf (StaticStrings.NS_SEP) == -1) {
451 values[k] = StaticStrings.EXTRACTED_NAMESPACE + values[k];
452 }
453
454 if (k < values.length-1) {
455 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
456
457 } else {
458 value_str = value_str + values[k];
459 }
460 }
461 }
462 }
463 if (!name_str.equals ("")) {
464 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
465 }
466 if (!value_str.equals ("")) {
467 XMLTools.setNodeText (option_element, value_str);
468 }
469 plugin_element.appendChild (option_element);
470
471 }
472
473 appendProperly (toElement, plugin_element);
474 }
475
476 }
477
478 //Handle classifiers
479 static private void doClassifier (Document to, Node browseNode) {
480 Element toElement = to.getDocumentElement ();
481 NodeList classifier_children = ((Element)browseNode).getElementsByTagName (StaticStrings.CLASSIFIER_STR);
482 int num_nodes = classifier_children.getLength ();
483
484 if (num_nodes < 1) {
485 return;
486 }
487
488 for (int i=0; i<num_nodes; i++) {
489 Element e = (Element)classifier_children.item (i);
490 String str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
491 Element classify_element = to.createElement (StaticStrings.CLASSIFY_ELEMENT);
492 classify_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, str);
493
494 String options_str = "";
495 NodeList option_children = e.getElementsByTagName (StaticStrings.OPTION_STR);
496 for (int j=0; j<option_children.getLength (); j++) {
497 Element el = (Element)option_children.item (j);
498 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
499 options_str = options_str + ((name_str.equals(""))? "" : (" " + name_str));
500 if (name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
501 name_str = name_str.substring (1);
502 }
503 String value_str = el.getAttribute (StaticStrings.VALUE_ATTRIBUTE);
504 options_str = options_str + ((name_str.equals(""))? "" : (" " + value_str));
505 Element option_element = null;
506
507 if (name_str.equals ("") && !value_str.equals ("")) {
508 continue; //invalid condition
509 }
510
511 option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
512 option_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
513
514 if (!name_str.equals ("")) {
515 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
516 }
517
518 if (!value_str.equals ("") && name_str.equals (StaticStrings.METADATA_STR)) {
519 // 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.
520 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
521 value_str = "";
522 for (int k=0; k<=values.length-1; k++) {
523 if (values[k].indexOf (StaticStrings.NS_SEP) == -1) {
524 values[k] = StaticStrings.EXTRACTED_NAMESPACE + values[k];
525 }
526 else {
527 MetadataElement metadata_element = MetadataTools.getMetadataElementWithName (values[k]);
528 if (metadata_element != null) {
529 values[k] = metadata_element.getDisplayName ();
530 }
531 }
532 if (k < values.length-1) {
533 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
534 } else {
535 value_str = value_str + values[k];
536 }
537 }
538 }
539
540 if (value_str != null && !value_str.equals ("")) {
541 XMLTools.setNodeText (option_element, value_str);
542 }
543 classify_element.appendChild (option_element);
544 }
545 //format element for this classifier
546 Element format = (Element)XMLTools.getChildByTagName (e, StaticStrings.FORMAT_STR);
547 if(format != null) {
548 classify_element.appendChild (doFormat(to, format, null));
549 }
550 appendProperly (toElement, classify_element);
551 }
552
553 // default format statement for all classifiers
554 Element default_classifier_format = (Element)XMLTools.getChildByTagName (browseNode, StaticStrings.FORMAT_STR);
555
556 to.getDocumentElement ().appendChild (doFormat(to, default_classifier_format, StaticStrings.BROWSE_STR));
557 }
558 static private Element doFormat(Document to, Element format, String name_str) {
559 Element format_element = to.createElement (StaticStrings.FORMAT_STR);
560 if (name_str != null) {
561 format_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
562 }
563 if (format != null) {
564 String gsf_text = XMLTools.xmlNodeToStringWithoutIndenting(format);
565
566 if (gsf_text.startsWith("<") && (gsf_text.indexOf("<") != gsf_text.lastIndexOf("<"))) {
567 gsf_text = gsf_text.substring(gsf_text.indexOf("<gsf"),
568 gsf_text.indexOf(StaticStrings.FORMAT_END_TAG));
569 }
570
571 XMLTools.setNodeText(format_element, gsf_text);
572 }
573 return format_element;
574 }
575 // Handling 'subcollection' elements in 'search' element of 'collectionConfig.xml'
576 static private void doSubcollection (Document to, Node searchNode) {
577 Element toElement = to.getDocumentElement ();
578 NodeList sub_children = ((Element)searchNode).getElementsByTagName (StaticStrings.SUBCOLLECTION_STR);
579 int sub_nodes = sub_children.getLength ();
580
581 // There is no subcollection
582 if (sub_nodes < 1) {
583 return;
584 }
585
586 for (int i=0; i<sub_nodes; i++) {
587 Element sub_child = (Element)sub_children.item (i);
588 String name_str = sub_child.getAttribute (StaticStrings.NAME_ATTRIBUTE);
589 String filter_str = sub_child.getAttribute (StaticStrings.FILTER_ATTRIBUTE);
590
591 // filter_str is in the form '<! (if set)><metadata>/<metadata value>/<flag (if any)>'
592
593 int pos = filter_str.indexOf (StaticStrings.SEPARATOR_CHARACTER);
594 String meta_str = "";
595 String meta_value_str = "";
596 String clude_str = "";
597 String flag_str = "";
598 if (pos == -1) {
599
600 meta_str = meta_value_str = filter_str;
601 clude_str = StaticStrings.INCLUDE_STR;
602 } else {
603 clude_str = StaticStrings.INCLUDE_STR;
604 if (filter_str.startsWith (StaticStrings.EXCLAMATION_CHARACTER)) {
605 clude_str = StaticStrings.EXCLUDE_STR;
606 // Peel off "!"
607 filter_str = filter_str.substring (StaticStrings.EXCLAMATION_CHARACTER.length ());
608 }
609
610 String[] strs = filter_str.split (StaticStrings.SEPARATOR_CHARACTER);
611 if (strs[0] != null && strs[0] != "") {
612 meta_str = strs[0];
613 }
614 if(!meta_str.equals (StaticStrings.FILENAME_STR) && meta_str.indexOf (StaticStrings.NS_SEP) == -1) {
615 meta_str = StaticStrings.EXTRACTED_NAMESPACE + meta_str;
616 }
617
618 if (strs[1] != null && strs[1] != "") {
619 meta_value_str = strs[1];
620 }
621 if (strs.length > 2) {
622 //This means there has been set a flag
623 if (strs[2] != null && strs[2] != "") {
624 flag_str = strs[2];
625 }
626 }
627 }
628 Element subcollection_element = to.createElement (StaticStrings.SUBCOLLECTION_ELEMENT);
629 subcollection_element.setAttribute (StaticStrings.NAME_STR, name_str);
630 subcollection_element.setAttribute (StaticStrings.CONTENT_ATTRIBUTE, meta_str);
631 subcollection_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, clude_str);
632 if (flag_str != "") {
633 subcollection_element.setAttribute (StaticStrings.OPTIONS_ATTRIBUTE, flag_str);
634 }
635 XMLTools.setNodeText (subcollection_element, meta_value_str);
636
637 toElement.appendChild (subcollection_element);
638 }
639 }
640 //Handle levels (document, section). In the internal structure, the element is called 'IndexOption'
641 static private void doLevel (Document to, Node searchNode) {
642 Element toElement = to.getDocumentElement ();
643 NodeList level_children = ((Element)searchNode).getElementsByTagName (StaticStrings.LEVEL_ATTRIBUTE);
644 int level_nodes = level_children.getLength ();
645
646 // it's mg, there's no level. So we construct a default 'indexOption' in the internal structure
647 if (level_nodes < 1) {
648 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
649 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
650 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.LEVELS_STR);
651
652 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
653 option_element.setAttribute (StaticStrings.NAME_STR, StaticStrings.DOCUMENT_STR);
654 index_option.appendChild (option_element);
655
656 appendProperly (toElement, index_option);
657
658 return;
659 }
660
661 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
662 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
663 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.LEVELS_STR);
664
665 for (int i=0; i<level_nodes; i++) {
666 Element level_element = (Element)level_children.item (i);
667 String level_str = level_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
668 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
669 option_element.setAttribute (StaticStrings.NAME_STR, level_str);
670 index_option.appendChild (option_element);
671
672
673 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'level' element
674 ArrayList displayItem_list = XMLTools.getNamedElementList (level_element,
675 StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
676 if (displayItem_list == null) {
677 return ;
678 }
679 for (int j=0; j<displayItem_list.size (); j++) {
680 Element item = (Element)displayItem_list.get (j);
681 String text = XMLTools.getNodeText (item);
682 String lang = item.getAttribute (StaticStrings.LANG_ATTRIBUTE);
683
684 //If there is nothing to display, don't bother creating the element
685 if (text == "") {
686 continue;
687 }
688 Element collectionmetadata = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
689 collectionmetadata.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
690 collectionmetadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, level_str);
691 collectionmetadata.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
692 XMLTools.setNodeText (collectionmetadata, text);
693
694 appendProperly (toElement, collectionmetadata);
695 }
696 }
697 appendProperly (toElement, index_option);
698 }
699 //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.
700 static private void doIndexSubcollection (Document to, Node searchNode) {
701 Element toElement = to.getDocumentElement ();
702 NodeList index_sub_children = ((Element)searchNode).getElementsByTagName (StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
703 int num_nodes = index_sub_children.getLength ();
704
705 // there is no subcollection index
706 if (num_nodes < 1) {
707 return;
708 }
709
710 Element subcollection_indexes = to.createElement (StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
711
712 for (int i=0; i<num_nodes; i++) {
713 Element index_element = to.createElement (StaticStrings.INDEX_ELEMENT);
714 Element index_sub_child = (Element)index_sub_children.item (i);
715 String name_str = index_sub_child.getAttribute (StaticStrings.NAME_ATTRIBUTE);
716
717 // name_str is in the form of comma separated strings, each of which is a subcollection filter name
718 String[] filters = name_str.split (StaticStrings.COMMA_CHARACTER);
719 for (int j=0; j<filters.length; j++) {
720
721 Element content_element = to.createElement (StaticStrings.CONTENT_ELEMENT);
722 content_element.setAttribute (StaticStrings.NAME_STR, filters[j]);
723 index_element.appendChild (content_element);
724 }
725 subcollection_indexes.appendChild (index_element);
726
727 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'indexSubcollection' element
728 ArrayList displayItem_list = XMLTools.getNamedElementList (index_sub_child,
729 StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
730 if (displayItem_list == null) {
731 // there is no display item for this element
732 continue;
733 }
734 for (int j=0; j<displayItem_list.size (); j++) {
735 Element item = (Element)displayItem_list.get (j);
736 String text = XMLTools.getNodeText (item);
737 String lang = item.getAttribute (StaticStrings.LANG_ATTRIBUTE);
738
739 //If there is nothing to display, don't bother creating the element
740 if (text == "") {
741 continue;
742 }
743 Element collectionmetadata = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
744 collectionmetadata.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
745 collectionmetadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
746 collectionmetadata.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
747 XMLTools.setNodeText (collectionmetadata, text);
748
749 appendProperly (toElement, collectionmetadata);
750 }
751 }
752 appendProperly (toElement, subcollection_indexes);
753 }
754 //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.
755 static private void doIndexLanguage (Document to, Node searchNode) {
756 Element toElement = to.getDocumentElement ();
757 NodeList index_sub_children = ((Element)searchNode).getElementsByTagName (StaticStrings.LANGUAGE_INDEX_ELEMENT);
758 int num_nodes = index_sub_children.getLength ();
759
760 // there is no subcollection index
761 if (num_nodes < 1) {
762 return;
763 }
764
765 Element language_indexes = to.createElement (StaticStrings.LANGUAGES_ELEMENT);
766
767 for (int i=0; i<num_nodes; i++) {
768 Element language_element = to.createElement (StaticStrings.LANGUAGE_ELEMENT);
769 Element index_sub_child = (Element)index_sub_children.item (i);
770 String name_str = index_sub_child.getAttribute (StaticStrings.NAME_ATTRIBUTE);
771 language_element.setAttribute (StaticStrings.NAME_STR, name_str);
772 language_indexes.appendChild (language_element);
773
774 // Contructing 'collectionmetadata' elements from the 'displayItem' of this 'indexLanguage' element
775 ArrayList displayItem_list = XMLTools.getNamedElementList (index_sub_child,
776 StaticStrings.DISPLAYITEM_STR, StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_STR);
777 if (displayItem_list == null) {
778 // there is no display item for this element
779 continue;
780 }
781 for (int j=0; j<displayItem_list.size (); j++) {
782 Element item = (Element)displayItem_list.get (j);
783 String text = XMLTools.getNodeText (item);
784 String lang = item.getAttribute (StaticStrings.LANG_ATTRIBUTE);
785
786 //If there is nothing to display, don't bother creating the element
787 if (text == "") {
788 continue;
789 }
790 Element collectionmetadata = to.createElement (StaticStrings.COLLECTIONMETADATA_ELEMENT);
791 collectionmetadata.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
792 collectionmetadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
793 collectionmetadata.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
794 XMLTools.setNodeText (collectionmetadata, text);
795
796 appendProperly (toElement, collectionmetadata);
797 }
798 }
799 toElement.appendChild (language_indexes);
800 }
801
802 // Handling search types
803 static private void doSearchType (Document to, Node searchNode) {
804 NodeList type_children = ((Element)searchNode).getElementsByTagName (StaticStrings.SEARCHTYPE_ELEMENT);
805 int num_types = type_children.getLength();
806 String searchtype_str = "";
807 if (num_types < 1) {
808 // not defined yet, add in default
809 searchtype_str = "plain,simpleform,advancedform";
810 }
811 else {
812 for(int i=0; i<num_types; i++) {
813 Node e = type_children.item (i);
814 String t = ((Element)e).getAttribute (StaticStrings.NAME_ATTRIBUTE);
815 if (i>0) {
816 searchtype_str += ",";
817 }
818 searchtype_str += t;
819 }
820 }
821
822 // pretend its a format statement
823 Element search_type_element = to.createElement (StaticStrings.FORMAT_STR);
824 search_type_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);
825 XMLTools.setNodeText(search_type_element, searchtype_str);
826 appendProperly (to.getDocumentElement (), search_type_element);
827
828 }
829
830 // Handling search format statement
831 static private void doSearchFormat (Document to, Node searchNode) {
832 // THere is currently just one format element for search. HOwever, need to check for old config files which used to have <format name="searchTypes">
833 NodeList format_children = ((Element)searchNode).getElementsByTagName (StaticStrings.FORMAT_STR);
834 int format_nodes = format_children.getLength ();
835 if (format_nodes < 1) {
836 return;
837 }
838 Element format = null;
839 for(int i=0; i<format_nodes; i++) {
840 Node e = format_children.item (i);
841 if (e.hasAttributes () == false) {
842 //The format element for format statement has no attribute
843 format = (Element)e;
844 }
845 }
846 //format statement for search
847 if (format != null) {
848 (to.getDocumentElement ()).appendChild (doFormat(to, format, StaticStrings.SEARCH_STR));
849 }
850 }
851 // Handling defaultIndexLanguage and languageMetadata in collectionConfig.xml ('elementNameFrom'); in the internal structure, they are called 'DefaultLanguage' and 'LanguageMetadata' ('elementNameTo') respectively.
852 // Converting from collectionConfig.xml to the internal xml structure.
853 static private void doLanguageMetadata (Document to, Node searchNode) {
854 Element toElement = to.getDocumentElement ();
855 String elementNameFrom = StaticStrings.LANGUAGE_METADATA_ELEMENT_STR;
856 String elementNameTo = StaticStrings.LANGUAGE_METADATA_ELEMENT;
857 Node from_element = XMLTools.getChildByTagName (searchNode, elementNameFrom);
858 if (from_element == null) {
859 return; // such an element not found
860 }
861
862 Element to_element = to.createElement (elementNameTo);
863
864 String name_str = ((Element)from_element).getAttribute (StaticStrings.NAME_ATTRIBUTE);
865 if (name_str.indexOf (StaticStrings.NS_SEP) == -1) {
866 name_str = StaticStrings.EXTRACTED_NAMESPACE + name_str;
867 }
868 to_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
869 to_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
870
871 toElement.appendChild (to_element);
872 }
873 static private void doReplaceListRef (Document to, Element from) {
874 Element toElement = to.getDocumentElement ();
875
876 NodeList replace_elements = from.getElementsByTagName(StaticStrings.REPLACELISTREF_STR);
877 int num_elems = replace_elements.getLength();
878 if (num_elems < 1) {
879 return;
880 }
881 for (int i=0; i<num_elems; i++) {
882 Element to_element = XMLTools.duplicateElement (to, (Element)replace_elements.item(i), true);
883 toElement.appendChild (to_element);
884 }
885 }
886 static private void convertReplaceListRef (Document from, Document to) {
887 Element toElement = to.getDocumentElement ();
888
889 NodeList replace_elements = from.getDocumentElement().getElementsByTagName(StaticStrings.REPLACELISTREF_STR);
890 int num_elems = replace_elements.getLength();
891 if (num_elems < 1) {
892 return;
893 }
894 for (int i=0; i<num_elems; i++) {
895 Element to_element = XMLTools.duplicateElement (to, (Element)replace_elements.item(i), true);
896 toElement.appendChild (to_element);
897 }
898 }
899
900 /** serviceRackList is currently not editable in GLI - just copy it in from config file and write it out again. */
901 static private void doServiceRackList (Document to, Element from) {
902 Element toElement = to.getDocumentElement ();
903
904 Node srl_element = XMLTools.getChildByTagName (from, StaticStrings.SERVICE_RACK_LIST_ELEMENT);
905 if (srl_element == null) {
906 return; // such an element not found
907 }
908
909 Element to_element = XMLTools.duplicateElement (to, (Element)srl_element, true);
910 toElement.appendChild (to_element);
911 }
912 static private void convertServiceRackList (Document from, Document to) {
913 Element toElement = to.getDocumentElement ();
914
915 Node srl_element = XMLTools.getChildByTagName (from.getDocumentElement (), StaticStrings.SERVICE_RACK_LIST_ELEMENT);
916 if (srl_element == null) {
917 return; // such an element not found
918 }
919
920 Element to_element = XMLTools.duplicateElement (to, (Element)srl_element, true);
921 toElement.appendChild (to_element);
922 }
923 static private void doDefaultIndexLanguage (Document to, Node searchNode) {
924 Element toElement = to.getDocumentElement ();
925 String elementNameFrom = StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT;
926 String elementNameTo = StaticStrings.LANGUAGE_DEFAULT_ELEMENT;
927 Node from_element = XMLTools.getChildByTagName (searchNode, elementNameFrom);
928 if (from_element == null) {
929 return; // such an element not found
930 }
931
932 Element to_element = to.createElement (elementNameTo);
933
934 String name_str = ((Element)from_element).getAttribute (StaticStrings.NAME_ATTRIBUTE);
935 to_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
936 to_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
937
938 toElement.appendChild (to_element);
939 }
940
941 //Handle 'indexOption' (i.e. casefold, stem etc). In the internal structure, the element is called 'IndexOption'
942 static private void doIndexOption (Document to, Node searchNode) {
943 Element toElement = to.getDocumentElement ();
944 Node index_option_node = XMLTools.getChildByTagName (searchNode, StaticStrings.INDEXOPTION_STR);
945 if (index_option_node == null) {
946 return;
947 }
948 NodeList option_children = ((Element)index_option_node).getElementsByTagName (StaticStrings.OPTION_STR);
949 int option_nodes = option_children.getLength ();
950
951 // for lucene, there is no 'indexOption'. We build a default 'indexOption' and 'assigned=false' in case the user switches to mg or mgpp
952 if (option_nodes < 1) {
953 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
954 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
955 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
956 String[] option_str =
957 { StaticStrings.CASEFOLD_OPTION_STR, StaticStrings.STEM_OPTION_STR };
958 for (int i=0; i<option_str.length; i++) {
959 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
960 option_element.setAttribute (StaticStrings.NAME_STR, option_str[i]);
961 index_option.appendChild (option_element);
962 }
963 appendProperly (toElement, index_option);
964 return;
965 }
966
967 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
968 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
969 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
970
971 for (int i=0; i<option_nodes; i++) {
972 String option_str = ((Element)option_children.item (i)).getAttribute (StaticStrings.NAME_ATTRIBUTE);
973 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
974 option_element.setAttribute (StaticStrings.NAME_STR, option_str);
975 index_option.appendChild (option_element);
976 }
977 appendProperly (toElement, index_option);
978 }
979
980 static private Element doBuildType (Document to, String att_value) {
981
982 //construct 'BuildType' element
983 Element element = to.createElement (StaticStrings.BUILDTYPE_ELEMENT);
984 element.setAttribute (StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
985 element.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
986 element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
987 element.setAttribute (StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
988
989 XMLTools.setNodeText (element, att_value);
990
991 return element;
992 }
993
994 // Convert 'description', 'smallicon' etc.
995 static private void convertDisplayItemList (Document from, Document to) {
996 Element displayItemList = to.createElement (StaticStrings.DISPLAYITEMLIST_STR);
997 Element destination = to.getDocumentElement ();
998
999 String []att_values =
1000 {StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR,
1001 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR,
1002 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR,
1003 StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR};
1004
1005 String []map_attrs =
1006 {StaticStrings.DESCRIPTION_STR,
1007 StaticStrings.SMALLICON_STR,
1008 StaticStrings.ICON_STR,
1009 StaticStrings.NAME_STR};
1010
1011 for (int i=0; i<att_values.length; i++) {
1012
1013 //dOc
1014 ArrayList e_list = XMLTools.getNamedElementList (from.getDocumentElement (),
1015 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1016 StaticStrings.NAME_ATTRIBUTE, att_values[i]);
1017 // if such elements don't exist, don't bother
1018 if (e_list == null) {
1019 continue;
1020 }
1021 for (int j=0; j<e_list.size (); j++) {
1022 Element e = (Element)e_list.get (j);
1023 if (e.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1024 continue;
1025 }
1026 String text = XMLTools.getNodeText (e);
1027 String lang = e.getAttribute (StaticStrings.LANGUAGE_ATTRIBUTE);
1028
1029 Element displayItem = constructElement (StaticStrings.DISPLAYITEM_STR, map_attrs[i],
1030 StaticStrings.LANG_STR, lang, text, to);
1031 displayItemList.appendChild (displayItem);
1032 }
1033
1034 }
1035 destination.appendChild (displayItemList);
1036 }
1037 // This method creates a DisplayItem element of the type of 'to' by using the ingredients from the element 'e'
1038 static private Element constructDisplayItem (Element e, Document to) {
1039 String lang_string = e.getAttribute (StaticStrings.LANGUAGE_ATTRIBUTE);
1040 String text = XMLTools.getNodeText (e);
1041 Element displayItem = to.createElement (StaticStrings.DISPLAYITEM_STR);
1042 displayItem.setAttribute (StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_ATTRIBUTE);
1043 displayItem.setAttribute (StaticStrings.LANG_STR, lang_string);
1044 XMLTools.setNodeText (displayItem, text);
1045 return displayItem;
1046 }
1047 static private void convertMetadataList (Document from, Document to) {
1048 Element metadataList = to.createElement (StaticStrings.METADATALIST_STR);
1049 Element destination = to.getDocumentElement ();
1050
1051 String []ele_names =
1052 {StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT,
1053 StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT,
1054 StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT};
1055 String []att_names =
1056 {StaticStrings.COLLECTIONMETADATA_CREATOR_STR,
1057 StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR,
1058 StaticStrings.COLLECTIONMETADATA_PUBLIC_STR};
1059 for (int i=0; i<ele_names.length; i++) {
1060 Element e = XMLTools.getNamedElement (from.getDocumentElement (),
1061 ele_names[i], StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1062 if (e == null) {
1063 continue;
1064 }
1065 String text = XMLTools.getNodeText (e);
1066 Element metadata = to.createElement (StaticStrings.METADATA_STR);
1067 metadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1068 metadata.setAttribute (StaticStrings.LANG_STR, StaticStrings.ENGLISH_LANGUAGE_STR);
1069 XMLTools.setNodeText (metadata, text);
1070 metadataList.appendChild (metadata);
1071 }
1072
1073 destination.appendChild (metadataList);
1074 }
1075 // This method creates an element with the name 'element_name' of the type of 'to' by using the other three strings
1076 static private Element constructElement (String element_name, String name_value, String lang_att, String lang_value, String text, Document to) {
1077 Element e = to.createElement (element_name);
1078 e.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1079 e.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_value);
1080 e.setAttribute (lang_att, lang_value);
1081 XMLTools.setNodeText (e, text);
1082
1083 return e;
1084 }
1085 // Convert classify in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1086 static private void convertClassifier (Document from, Document to) {
1087 Element browse_element = to.createElement (StaticStrings.BROWSE_STR);
1088 NodeList children = from.getDocumentElement ().getElementsByTagName (StaticStrings.CLASSIFY_ELEMENT);
1089
1090 int num_children = (children == null)? 0 : children.getLength ();
1091
1092 if (num_children == 0) {
1093 return ;
1094 }
1095
1096 for (int i=0; i<num_children; i++) {
1097
1098 Element child = (Element)children.item (i);
1099 if (child.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1100 continue;
1101 }
1102 String str = child.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1103 Element classifier_element = to.createElement (StaticStrings.CLASSIFIER_STR);
1104 classifier_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, str);
1105
1106 NodeList option_children = child.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1107 for (int j=0; j<option_children.getLength (); j++) {
1108 Element el = (Element)option_children.item (j);
1109 if (el.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1110 continue;
1111 }
1112 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1113 String value_str = XMLTools.getNodeText (el);
1114
1115
1116 if (name_str == null && value_str == null) {
1117 continue;
1118 }
1119 Element option_element = to.createElement (StaticStrings.OPTION_STR);
1120 if (name_str != null && name_str.equals (StaticStrings.METADATA_STR)) {
1121
1122 // 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.
1123 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
1124 value_str = "";
1125 for (int k=0; k<=values.length-1; k++) {
1126 if(values[k].startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1127 values[k] = values[k].substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1128 }
1129 else {
1130 MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName (values[k]);
1131 if (metadata_element != null) {
1132 values[k] = metadata_element.getFullName ();
1133 }
1134 }
1135 if (k < values.length-1) {
1136 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1137 } else {
1138 value_str = value_str + values[k];
1139 }
1140 }
1141 }
1142
1143 if (!name_str.equals ("")) {
1144 if (!name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
1145 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1146 }
1147 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1148 }
1149
1150 if (!value_str.equals ("")) {
1151 option_element.setAttribute (StaticStrings.VALUE_ATTRIBUTE, value_str);
1152 }
1153
1154 classifier_element.appendChild (option_element);
1155 }
1156
1157 //format element for this classifier
1158 Element e = (Element)XMLTools.getChildByTagName (child, StaticStrings.FORMAT_STR);
1159
1160 if (e != null) {
1161 classifier_element.appendChild (convertFormat(to, e));
1162 }
1163 browse_element.appendChild (classifier_element);
1164 }
1165
1166 //convert default classifier format
1167 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1168 StaticStrings.NAME_ATTRIBUTE, StaticStrings.BROWSE_STR);
1169 browse_element.appendChild (convertFormat(to, e));
1170
1171 to.getDocumentElement ().appendChild (browse_element);
1172 }
1173 static private Element convertFormat(Document to, Element e) {
1174 String format_str = XMLTools.getNodeText(e);
1175 Element format = to.createElement (StaticStrings.FORMAT_STR);
1176 //XMLTools.copyAllChildren (format, e);
1177 XMLTools.setNodeText(format, format_str);
1178 return format;
1179 }
1180 //convert format statement for search
1181 static private void convertSearchFormat (Document from, Document to) {
1182 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1183 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1184 StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCH_STR);
1185
1186 search.appendChild (convertFormat(to, e));
1187
1188 }
1189 //convert format statement for display of the documents
1190 static private void convertDisplayFormat (Document from, Document to) {
1191 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1192 StaticStrings.NAME_ATTRIBUTE, StaticStrings.DISPLAY_STR);
1193 if (e == null) {
1194 return;
1195 }
1196 Element display = to.createElement (StaticStrings.DISPLAY_STR);
1197 display.appendChild (convertFormat(to, e));
1198 to.getDocumentElement ().appendChild (display);
1199 }
1200 // Convert plugins in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1201 static private void convertPlugin (Document from, Document to) {
1202 Element import_element = to.createElement (StaticStrings.IMPORT_STR);
1203 Element plugin_list_element = to.createElement (StaticStrings.PLUGINLIST_STR);
1204
1205 NodeList children = from.getDocumentElement ().getElementsByTagName (StaticStrings.PLUGIN_ELEMENT);
1206 int num_children = (children == null)? 0 : children.getLength ();
1207 if (num_children == 0) {
1208 return ;
1209 }
1210
1211 for (int i=0; i<num_children; i++) {
1212
1213 Element child = (Element)children.item (i);
1214 if (child.getAttribute (StaticStrings.SEPARATOR_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1215 continue;
1216 }
1217 if (child.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1218 continue;
1219 }
1220
1221 String str = child.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1222 Element plugin_element = to.createElement (StaticStrings.PLUGIN_STR);
1223 plugin_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, str);
1224
1225 NodeList option_children = child.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1226 for (int j=0; j<option_children.getLength (); j++) {
1227 Element el = (Element)option_children.item (j);
1228 if(!el.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1229 continue;
1230 }
1231 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1232 String value_str = XMLTools.getNodeText (el);
1233
1234
1235 if (name_str == null && value_str == null) {
1236 continue;
1237 }
1238 Element option_element = to.createElement (StaticStrings.OPTION_STR);
1239 if (name_str != null && name_str.equals (StaticStrings.METADATA_STR)) {
1240
1241 // 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.
1242 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
1243 value_str = "";
1244 for (int k=0; k<=values.length-1; k++) {
1245 if(values[k].startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1246 values[k] = values[k].substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1247 }
1248
1249 if (k < values.length-1) {
1250 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1251 } else {
1252 value_str = value_str + values[k];
1253 }
1254 }
1255 }
1256
1257 if (!name_str.equals ("")) {
1258 if (!name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
1259 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1260 }
1261 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1262 }
1263
1264 if (!value_str.equals ("")) {
1265 option_element.setAttribute (StaticStrings.VALUE_ATTRIBUTE, value_str);
1266 }
1267
1268 plugin_element.appendChild (option_element);
1269 }//for loop ends
1270
1271 plugin_list_element.appendChild (plugin_element);
1272 }//for loop ends
1273
1274 import_element.appendChild (plugin_list_element);
1275
1276 //do the plugout element (used by building flax collections)
1277 Node plugout = XMLTools.getChildByTagNameIndexed (from.getDocumentElement (), PLUGOUT_ELEMENT, 0);
1278 if (plugout != null) {
1279 Element to_element = XMLTools.duplicateElement (to, (Element)plugout, true);
1280 import_element.appendChild (to_element);
1281 }
1282
1283 to.getDocumentElement ().appendChild (import_element);
1284 }
1285
1286 //Handle 'searchType' of collectionConfig.xml. In the internal structure, its also called 'searchType', eg. plain, form
1287 static private void convertSearchType (Document from, Document to) {
1288 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1289 StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);//searchType
1290
1291 if (e == null) {
1292 return;
1293 }
1294 String searchtype_str = XMLTools.getNodeText(e);
1295 //Get the 'search' element from 'to'
1296 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1297
1298 String[] types = searchtype_str.split(",");
1299 for (int i=0; i<types.length; i++) {
1300 Element search_type_element = to.createElement (StaticStrings.SEARCHTYPE_ELEMENT);
1301 search_type_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, types[i]);
1302 search.appendChild (search_type_element);
1303 }
1304 }
1305
1306 static private void convertBuildType (Document from, Document to) {
1307 Element e = XMLTools.getNamedElement (from.getDocumentElement (),
1308 StaticStrings.BUILDTYPE_ELEMENT,
1309 StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
1310 if (e == null) {
1311 return;
1312 }
1313 String indexer = XMLTools.getNodeText (e);
1314 Element search = to.createElement (StaticStrings.SEARCH_STR);
1315 search.setAttribute (StaticStrings.TYPE_ATTRIBUTE, indexer);
1316 to.getDocumentElement ().appendChild (search);
1317 }
1318 static private void convertDefaultIndex (Document from, Document to, Element search) {
1319 Element source = from.getDocumentElement ();
1320
1321 Element default_index_element = (Element)XMLTools.getChildByTagName (source, StaticStrings.INDEX_DEFAULT_ELEMENT);
1322 if (default_index_element == null) {
1323 return;
1324 }
1325
1326 String indexer = search.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1327 String level_str = default_index_element.getAttribute (StaticStrings.LEVEL_ATTRIBUTE);
1328 // Debugging purposes
1329 if (level_str.equals ("") && indexer.equals (StaticStrings.MG_STR) ) {
1330 System.out.println ("Bug: DefaultIndex should have its level attribute not empty.");
1331 }
1332
1333 NodeList content_elements = default_index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1334 int content_elements_length = content_elements.getLength ();
1335
1336 // Don't output anything if no indexes are set
1337 if(content_elements_length == 0) {
1338 return ;//
1339 }
1340
1341 String index_str = "";
1342
1343 if (indexer.equals (StaticStrings.MG_STR)) {
1344 //combine level with indexes
1345 index_str = level_str + StaticStrings.COLON_CHARACTER;
1346 }
1347 else { //for mgpp/lucene, just take index
1348 //do nothing
1349 }
1350
1351 for(int k = 0; k < content_elements_length; k++) {
1352 Element content_element = (Element) content_elements.item (k);
1353 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1354 continue;
1355 }
1356 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1357
1358 if(name_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1359 name_str = name_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1360 }
1361
1362 index_str = index_str + name_str;
1363
1364 // Make it comma separated string
1365 if(k < content_elements_length - 1) {
1366 index_str = index_str + StaticStrings.COMMA_CHARACTER;
1367 }
1368 content_element = null;
1369 }//for loop ends
1370
1371
1372 Element default_index = to.createElement (StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);
1373 default_index.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_str);
1374 search.appendChild (default_index);
1375
1376 }
1377 static private void convertSubcollection (Document from, Document to) {
1378 Element source = from.getDocumentElement ();
1379 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1380 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1381
1382 // Get the Subcollection element from the internal structure
1383 NodeList subcollection_elements = source.getElementsByTagName (StaticStrings.SUBCOLLECTION_ELEMENT);
1384 if (subcollection_elements == null) {
1385 return;
1386 }
1387 int subcollection_elements_length = subcollection_elements.getLength ();
1388
1389 if (subcollection_elements_length == 0) { // no
1390 return ;
1391 }
1392
1393 for(int j = 0; j < subcollection_elements_length; j++) {
1394
1395 Element e = (Element) subcollection_elements.item (j);
1396 if (e.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1397 continue;
1398 }
1399 String content = e.getAttribute (StaticStrings.CONTENT_ATTRIBUTE);
1400 String name = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1401 String options = e.getAttribute (StaticStrings.OPTIONS_ATTRIBUTE);
1402 String type = e.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1403 String text = XMLTools.getNodeText (e);
1404
1405 String filter = "";
1406 if (type.equals (StaticStrings.EXCLUDE_STR)) {
1407 filter = StaticStrings.EXCLAMATION_CHARACTER;
1408 }
1409
1410 if(content.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1411 content = content.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1412 }
1413 filter = filter + content + StaticStrings.SEPARATOR_CHARACTER + text;
1414 if (options != null && options != "") {
1415 filter = filter + StaticStrings.SEPARATOR_CHARACTER + options;
1416 }
1417 Element subcollection = to.createElement (StaticStrings.SUBCOLLECTION_STR);
1418 subcollection.setAttribute (StaticStrings.FILTER_ATTRIBUTE, filter);
1419 subcollection.setAttribute (StaticStrings.NAME_ATTRIBUTE, name);
1420
1421 search.appendChild (subcollection);
1422 }
1423 }
1424 static private void convertSubcollectionIndexes (Document from, Document to) {
1425 Element source = from.getDocumentElement ();
1426 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1427 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1428
1429 // Get the SubcollectionIndexes element from the internal structure
1430 Element subcollection_indexes = (Element)XMLTools.getChildByTagName (source, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
1431 if (subcollection_indexes == null) {
1432 return;
1433 }
1434 NodeList index_elements = subcollection_indexes.getElementsByTagName (StaticStrings.INDEX_ELEMENT);
1435 int index_elements_length = index_elements.getLength ();
1436
1437 if (index_elements_length == 0) { // no indexes
1438 return ;
1439 }
1440
1441 for(int j = 0; j < index_elements_length; j++) {
1442 Element index_element = (Element) index_elements.item (j);
1443 if (index_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1444 continue;
1445 }
1446
1447 Element index = to.createElement (StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
1448
1449 String index_value = "";
1450
1451 NodeList content_elements = index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1452 int content_elements_length = content_elements.getLength ();
1453
1454 for(int k = 0; k < content_elements_length; k++) {
1455 Element content_element = (Element) content_elements.item (k);
1456 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1457 continue;
1458 }
1459 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1460 index_value += name_str;
1461 // Make it comma separated string
1462 if(k < content_elements_length - 1) {
1463 index_value += StaticStrings.COMMA_CHARACTER;
1464 }
1465 content_element = null;
1466 }//for loop ends
1467
1468 index.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_value);
1469
1470 // Now constructing 'displayItem' element for this 'indexSubcollection' element
1471 // from the collectionmetadata element
1472 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1473 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1474 StaticStrings.NAME_ATTRIBUTE, index_value);
1475
1476 if (collectionmetadata_list != null) {
1477
1478 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1479 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1480 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1481 continue;
1482 }
1483 Element displayItem = constructDisplayItem (collectionmetadata, to);
1484 index.appendChild (displayItem);
1485 }
1486 }
1487
1488 search.appendChild (index);
1489
1490 } //for loop ends
1491 }
1492
1493 static private void convertLanguages (Document from, Document to) {
1494 Element source = from.getDocumentElement ();
1495 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1496 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1497
1498 // Get the Languages element from the internal structure
1499 Element languages = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGES_ELEMENT);
1500 if (languages == null) {
1501 return;
1502 }
1503 NodeList language_elements = languages.getElementsByTagName (StaticStrings.LANGUAGE_ELEMENT);
1504 int language_elements_length = language_elements.getLength ();
1505
1506 if (language_elements_length == 0) {
1507 return ;
1508 }
1509
1510 for(int j = 0; j < language_elements_length; j++) {
1511 Element element = (Element) language_elements.item (j);
1512 if (element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1513 continue;
1514 }
1515
1516 // Create indexLanguage element
1517 Element index_language = to.createElement (StaticStrings.LANGUAGE_INDEX_ELEMENT);
1518
1519 String name_str = element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1520 index_language.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1521
1522 // Now constructing 'displayItem' element for this 'indexLanguage' element
1523 // from the collectionmetadata element
1524 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1525 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1526 StaticStrings.NAME_ATTRIBUTE, name_str);
1527
1528 if (collectionmetadata_list != null) {
1529
1530 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1531 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1532 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1533 continue;
1534 }
1535 Element displayItem = constructDisplayItem (collectionmetadata, to);
1536 index_language.appendChild (displayItem);
1537 }
1538 }
1539
1540 search.appendChild (index_language);
1541
1542 } //for loop ends
1543
1544 // Convert DefaultLanguage
1545 // Get the DefaultLanguage element from the internal structure
1546 Element default_language = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGE_DEFAULT_ELEMENT);
1547 if(default_language != null) {
1548 String lang_name = default_language.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1549 Element default_index_language = to.createElement (StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT);
1550 default_index_language.setAttribute (StaticStrings.NAME_ATTRIBUTE, lang_name);
1551 search.appendChild (default_index_language);
1552 }
1553 // Convert LanguageMetadata
1554 // Get the LanguageMetadata element from the internal structure
1555 Element language_metadata = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGE_METADATA_ELEMENT);
1556 if(language_metadata != null) {
1557 String meta_name = language_metadata.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1558 Element language_meta = to.createElement (StaticStrings.LANGUAGE_METADATA_ELEMENT_STR);
1559 if(meta_name.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1560 meta_name = meta_name.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1561 }
1562 language_meta.setAttribute (StaticStrings.NAME_ATTRIBUTE, meta_name);
1563 search.appendChild (language_meta);
1564 }
1565 }
1566
1567 //convert indexes and their displayItems, which go in 'search' element in collectionConfig.xml
1568 //parameter 'to' is the document to be saved as collectionConfig.xml
1569 //parameter 'from' is the internal xml structure
1570 static private void convertIndex (Document from, Document to) {
1571 Element source = from.getDocumentElement ();
1572 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1573 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1574
1575 //THere are two sets of indexes elements, find the one which is assigned 'true'
1576 Element indexes = XMLTools.getNamedElement (source,
1577 StaticStrings.INDEXES_ELEMENT,
1578 StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1579 if (indexes == null) {
1580 return;
1581 }
1582 NodeList index_elements = indexes.getElementsByTagName (StaticStrings.INDEX_ELEMENT);
1583 int index_elements_length = index_elements.getLength ();
1584
1585 if (index_elements_length == 0) { // no indexes
1586 return ;
1587 }
1588
1589 //find out it's mg or mgpp/lucene
1590 String mg = search.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1591 boolean mg_indexer = false;
1592 if (mg.equals (StaticStrings.MG_STR)) {
1593 mg_indexer = true;//it's mg, then the level is set as attribute of
1594 }
1595 if (mg_indexer == false) {
1596 // It's mgpp. Construct 'level' and 'defaultLevel' elements separately.
1597 convertLevels (from, to, search);
1598 }
1599
1600 for(int j = 0; j < index_elements_length; j++) {
1601 Element index_element = (Element) index_elements.item (j);
1602 if (index_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1603 continue;
1604 }
1605
1606 Element index_ele = to.createElement (StaticStrings.INDEX_LOW_STR);//index
1607
1608 // Used for creating displayItem for this element 'index_ele' further below
1609 // full_index_names contain 'ex.'
1610 String full_index_name = "";
1611 String level_str = "";
1612
1613 StringBuffer index_value = new StringBuffer ();
1614 if (mg_indexer == true) {
1615 // For mg indexer, there is a 'level' attribute in the index element of the internal structure
1616 // But mgpp/lucene don't
1617 level_str = index_element.getAttribute (StaticStrings.LEVEL_ATTRIBUTE);
1618 if(level_str.length () > 0) {
1619 index_value.append (level_str).append (StaticStrings.COLON_CHARACTER);
1620 //index_value = index_value.StaticStrings.COLON_CHARACTER;
1621 }
1622 }
1623
1624 NodeList content_elements = index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1625 int content_elements_length = content_elements.getLength ();
1626
1627 for(int k = 0; k < content_elements_length; k++) {
1628 Element content_element = (Element) content_elements.item (k);
1629 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1630 continue;
1631 }
1632 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1633
1634 full_index_name = full_index_name + name_str;
1635 if (k < content_elements_length - 1) {
1636 full_index_name = full_index_name + StaticStrings.COMMA_CHARACTER;
1637 }
1638
1639 if(name_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1640 name_str = name_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1641 }
1642
1643 index_value.append (name_str);
1644 name_str = null;
1645 // Make it comma separated string
1646 if(k < content_elements_length - 1) {
1647 index_value.append (StaticStrings.COMMA_CHARACTER);
1648 }
1649 content_element = null;
1650 }//for loop ends
1651
1652 String temp_str = index_value.toString ();
1653 index_ele.setAttribute (StaticStrings.NAME_ATTRIBUTE, temp_str);
1654
1655 // Now constructing 'displayItem' element for this 'index_ele' element
1656 // The index names in the collectionmetadata elements in the internal structure are not the names that
1657 // are used in the content elements (i.e. ex.Source or dc.Subject and keywords), but the names that are
1658 // in the configuration files (i.e. Source or dc.Subject)
1659 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1660 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1661 StaticStrings.NAME_ATTRIBUTE, temp_str);
1662
1663 if (collectionmetadata_list == null) {
1664 //try the full name, i.e. with 'ex.'
1665 if (mg_indexer == true) {
1666 // but first append level info if we are mg
1667 full_index_name = level_str+StaticStrings.COLON_CHARACTER+full_index_name;
1668 }
1669 collectionmetadata_list = XMLTools.getNamedElementList (source,
1670 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1671 StaticStrings.NAME_ATTRIBUTE, full_index_name);
1672 }
1673
1674 if (collectionmetadata_list != null) {
1675
1676 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1677 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1678 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1679 continue;
1680 }
1681 Element displayItem = constructDisplayItem (collectionmetadata, to);
1682
1683 index_ele.appendChild (displayItem);
1684 }
1685 }
1686
1687 search.appendChild (index_ele);
1688
1689 } //for loop ends
1690
1691 //Convert default index
1692 convertDefaultIndex (from, to, search);
1693 convertIndexOptions(from, to, search);
1694 }
1695 // Convert levels for mgpp/lucene. This method is called by converIndex() when mgpp indexer is detected.
1696 static private void convertLevels (Document from, Document to, Element search) {
1697 Element source = from.getDocumentElement ();
1698 Element index_option = XMLTools.getNamedElement (source,
1699 StaticStrings.INDEXOPTIONS_ELEMENT,
1700 StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVELS_STR);
1701 if (index_option == null) {
1702 return;
1703 }
1704 //Debugging purposes
1705 if (index_option.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1706 DebugStream.println ("For mgpp, there should be an IndexOption element for levels which is assigned 'true': possible bug.");
1707 }
1708
1709 NodeList option_elements = index_option.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1710 int num_elements = option_elements.getLength ();
1711
1712 // Don't output anything if no indexes are set
1713 if(num_elements == 0) {
1714 return ;//
1715 }
1716
1717 for(int k = 0; k < num_elements; k++) {
1718 Element e = (Element) option_elements.item (k);
1719 String name_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1720 Element level_element = to.createElement (StaticStrings.LEVEL_ELEMENT);
1721 level_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1722
1723 //Now construct displayItem for this level element from collectionmetadata
1724 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1725 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1726 StaticStrings.NAME_ATTRIBUTE, name_str);
1727
1728 if (collectionmetadata_list != null) {
1729
1730 for(int j = 0; j < collectionmetadata_list.size (); j++) {
1731 Element collectionmetadata = (Element)collectionmetadata_list.get (j);
1732
1733 Element displayItem = constructDisplayItem (collectionmetadata, to);
1734 level_element.appendChild (displayItem);
1735 }
1736 }
1737 search.appendChild (level_element);
1738 }
1739
1740 //Convert default level
1741 Element default_index_option = XMLTools.getNamedElement (source,
1742 StaticStrings.INDEXOPTION_DEFAULT_ELEMENT,
1743 StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVEL_DEFAULT_STR);
1744 if (default_index_option == null) {
1745 return;
1746 }
1747 Element default_level = to.createElement (StaticStrings.LEVEL_DEFAULT_ELEMENT);
1748 String default_level_str = default_index_option.getAttribute (StaticStrings.VALUE_ATTRIBUTE);
1749 default_level.setAttribute (StaticStrings.NAME_ATTRIBUTE, default_level_str);
1750 search.appendChild (default_level);
1751
1752 }
1753 // Convert indexoptions for mg/mgpp/lucene. This method is called by convertIndex().
1754 static private void convertIndexOptions (Document from, Document to, Element search) {
1755 Element source = from.getDocumentElement ();
1756 Element index_option = XMLTools.getNamedElement (source,
1757 StaticStrings.INDEXOPTIONS_ELEMENT,
1758 StaticStrings.NAME_ATTRIBUTE, StaticStrings.INDEXOPTIONS_STR);
1759 if (index_option == null) {
1760 return;
1761 }
1762 //Debugging purposes
1763 if (index_option.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1764 DebugStream.println ("There should be an IndexOption element which is assigned 'true': possible bug.");
1765 }
1766 Element indexOptionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
1767 NodeList option_elements = index_option.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1768 int num_elements = option_elements.getLength ();
1769 // Don't output anything if no index
1770 if(num_elements == 0) {
1771 return ;//
1772 }
1773 search.appendChild (indexOptionEl);
1774
1775 for(int k = 0; k < num_elements; k++) {
1776 Element e = (Element) option_elements.item (k);
1777 String name_att = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1778 Element optionEl = to.createElement(StaticStrings.OPTION_STR);
1779 optionEl.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_att);
1780 indexOptionEl.appendChild(optionEl);
1781 }
1782
1783 }
1784 // Append the element son to the element mother in the appropriate position.
1785 static public void appendProperly (Element mother, Element son) {
1786 if (son == null)
1787 return;
1788
1789 Node reference_node = findInsertionPoint (mother, son);
1790 if(reference_node != null) {
1791 mother.insertBefore (son, reference_node);
1792 }
1793 else {
1794 mother.appendChild (son);
1795 }
1796 }
1797 /** Find the best insertion position for the given DOM Element 'target_element' in the DOM Element 'document_element'. This should try to match command tag, and if found should then try to group by name or type (eg CollectionMeta), or append to end is no such grouping exists (eg Plugins). Failing a command match it will check against the command order for the best insertion location.
1798 * @param target_element the command Element to be inserted
1799 * @return the Element which the given command should be inserted before, or null to append to end of list
1800 */
1801 static public Node findInsertionPoint (Element document_element, Element target_element) {
1802 ///ystem.err.println("Find insertion point: " + target_element.getNodeName());
1803 String target_element_name = target_element.getNodeName ();
1804
1805 // Try to find commands with the same tag.
1806 NodeList matching_elements = document_element.getElementsByTagName (target_element_name);
1807 // If we found matching elements, then we have our most likely insertion location, so check within for groupings
1808 if(matching_elements.getLength () != 0) {
1809 ///ystem.err.println("Found matching elements.");
1810 // Only CollectionMeta are grouped.
1811 if(target_element_name.equals (StaticStrings.COLLECTIONMETADATA_ELEMENT)) {
1812 ///ystem.err.println("Dealing with collection metadata");
1813 // 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.
1814 // So if the command to be added is special add it immediately after any other special command
1815 if(target_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1816 int index = 0;
1817 Element matched_element = (Element) matching_elements.item (index);
1818 Element sibling_element = (Element) matched_element.getNextSibling ();
1819 while(sibling_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1820 index++;
1821 matched_element = (Element) matching_elements.item (index);
1822 sibling_element = (Element) matched_element.getNextSibling ();
1823 }
1824 if(sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1825 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1826 document_element.insertBefore (newline_element, sibling_element);
1827 }
1828 return sibling_element;
1829 }
1830 // Otherwise try to find a matching 'name' and add after the last one in that group.
1831 else {
1832 int index = 0;
1833 target_element_name = target_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1834 boolean found = false;
1835 // Skip all of the special metadata
1836 Element matched_element = (Element) matching_elements.item (index);
1837 while(matched_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1838 index++;
1839 matched_element = (Element) matching_elements.item (index);
1840 }
1841 // Begin search
1842 while(!found && matched_element != null) {
1843 if(matched_element.getAttribute (StaticStrings.NAME_ATTRIBUTE).equals (target_element_name)) {
1844 found = true;
1845 }
1846 else {
1847 index++;
1848 matched_element = (Element) matching_elements.item (index);
1849 }
1850 }
1851 // If we found a match, we need to continue checking until we find the last name match.
1852 if(found) {
1853 index++;
1854 Element previous_sibling = matched_element;
1855 Element sibling_element = (Element) matching_elements.item (index);
1856 while(sibling_element != null && sibling_element.getAttribute (StaticStrings.NAME_ATTRIBUTE).equals (target_element_name)) {
1857 previous_sibling = sibling_element;
1858 index++;
1859 sibling_element = (Element) matching_elements.item (index);
1860 }
1861 // 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!
1862 return previous_sibling.getNextSibling ();
1863 }
1864 // If not found we just add after last metadata element
1865 else {
1866 Element last_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1867 return last_element.getNextSibling ();
1868 }
1869 }
1870
1871 }
1872 else {
1873 ///ystem.err.println("Not dealing with collection meta.");
1874 Element matched_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1875 // 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)
1876 Node sibling_element = matched_element.getNextSibling ();
1877 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1878 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1879 document_element.insertBefore (newline_element, sibling_element);
1880 }
1881 return sibling_element; // Note that this may be null
1882 }
1883 }
1884 ///ystem.err.println("No matching elements found.");
1885 // Locate where this command is in the ordering
1886 int command_index = -1;
1887 for(int i = 0; command_index == -1 && i < CollectionConfiguration.COMMAND_ORDER.length; i++) {
1888 if(CollectionConfiguration.COMMAND_ORDER[i].equals (target_element_name)) {
1889 command_index = i;
1890 }
1891 }
1892 ///ystem.err.println("Command index is: " + command_index);
1893 // Now move forward, checking for existing elements in each of the preceeding command orders.
1894 int preceeding_index = command_index - 1;
1895 ///ystem.err.println("Searching before the target command.");
1896 while(preceeding_index >= 0) {
1897 matching_elements = document_element.getElementsByTagName (CollectionConfiguration.COMMAND_ORDER[preceeding_index]);
1898 // If we've found a match
1899 if(matching_elements.getLength () > 0) {
1900 // We add after the last element
1901 Element matched_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1902 // 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)
1903 Node sibling_element = matched_element.getNextSibling ();
1904 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1905 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1906 document_element.insertBefore (newline_element, sibling_element);
1907 }
1908 return sibling_element; // Note that this may be null
1909 }
1910 preceeding_index--;
1911 }
1912 // If all that fails, we now move backwards through the commands
1913 int susceeding_index = command_index + 1;
1914 ///ystem.err.println("Searching after the target command.");
1915 while(susceeding_index < CollectionConfiguration.COMMAND_ORDER.length) {
1916 matching_elements = document_element.getElementsByTagName (CollectionConfiguration.COMMAND_ORDER[susceeding_index]);
1917 // If we've found a match
1918 if(matching_elements.getLength () > 0) {
1919 // We add before the first element
1920 Element matched_element = (Element) matching_elements.item (0);
1921 // 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)
1922 Node sibling_element = matched_element.getPreviousSibling ();
1923 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1924 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1925 document_element.insertBefore (newline_element, sibling_element);
1926 }
1927 return sibling_element; // Note that this may be null
1928 }
1929 susceeding_index++;
1930 }
1931 // Well. Apparently there are no other commands in this collection configuration. So append away...
1932 return null;
1933 }
1934 // From collectionConfig.xml to internal structure:add 'ex.' namespace (if none).
1935 // From internal structure to collectionConfig.xml:always peel off 'ex.' namespace (if any), except for format statement
1936 //This method parses 'xml_file_doc' into 'dOc'
1937 static public void parse(File xml_file, Document dOc) {
1938
1939 Document xml_file_doc = XMLTools.parseXMLFile (xml_file);
1940 Element fromElement = xml_file_doc.getDocumentElement ();
1941 Element toElement = dOc.getDocumentElement ();
1942
1943 // It's deliberately set that 'creator', 'maintainer', and 'public' are only in English (as they are just names).
1944 // So the following ArrayList have only one element.
1945 Node metadataListNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.METADATALIST_STR, 0);
1946 if (metadataListNode != null) {
1947 ArrayList creator = doMetadataList (dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT,
1948 StaticStrings.COLLECTIONMETADATA_CREATOR_STR);
1949 ArrayList maintainer = doMetadataList (dOc, metadataListNode,
1950 StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT,
1951 StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR);
1952 ArrayList is_public = doMetadataList (dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT,
1953 StaticStrings.COLLECTIONMETADATA_PUBLIC_STR);
1954
1955 appendArrayList (toElement, creator);
1956 appendArrayList (toElement, maintainer);
1957 appendArrayList (toElement, is_public);
1958 }
1959
1960 Node searchNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.SEARCH_STR, 0);
1961 String buildtype_value = ((Element)searchNode).getAttribute (StaticStrings.TYPE_ATTRIBUTE);//might be mg|mgpp|lucene
1962 Element buildtype = doBuildType (dOc, buildtype_value);
1963 appendProperly (toElement, buildtype);
1964
1965
1966 Node importNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.IMPORT_STR, 0);
1967 if (importNode == null) {
1968 System.out.println ("There is no content in the 'import' block.");
1969 }
1970 if (importNode != null) {
1971 //do plugin list nodes
1972 Node pluginListNode = XMLTools.getChildByTagNameIndexed ((Element)importNode, StaticStrings.PLUGINLIST_STR, 0);
1973 if (pluginListNode == null) {
1974 System.out.println ("There is no pluginlist set.");
1975 }
1976 if (pluginListNode != null) {
1977
1978 doPlugin (dOc, pluginListNode);
1979 }
1980
1981 //do the plugout element (used by building flax collections)
1982 Node plugout = XMLTools.getChildByTagNameIndexed ((Element)importNode, PLUGOUT_ELEMENT, 0);
1983 if (plugout != null) {
1984 Element to_element = XMLTools.duplicateElement (dOc, (Element)plugout, true);
1985 toElement.appendChild (to_element);
1986 }
1987 }
1988
1989 Node browseNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.BROWSE_STR, 0);
1990 if (browseNode != null) {
1991 if (browseNode == null) {
1992 System.out.println ("There is no classifier.");
1993 }
1994 doClassifier (dOc, browseNode);
1995 }
1996
1997 Node displayItemListNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.DISPLAYITEMLIST_STR, 0);
1998 if (displayItemListNode != null) {
1999 ArrayList description = doDisplayItemList (dOc, displayItemListNode, StaticStrings.DESCRIPTION_STR,
2000 StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR);
2001 ArrayList smallicon = doDisplayItemList (dOc, displayItemListNode, StaticStrings.SMALLICON_STR,
2002 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR);
2003 ArrayList icon = doDisplayItemList (dOc, displayItemListNode, StaticStrings.ICON_STR,
2004 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR);
2005 ArrayList name = doDisplayItemList (dOc, displayItemListNode, StaticStrings.NAME_STR,
2006 StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR);
2007
2008 appendArrayList (toElement, description);
2009 appendArrayList (toElement, smallicon);
2010 appendArrayList (toElement, icon);
2011 appendArrayList (toElement, name);
2012 }
2013
2014 if (buildtype_value.equalsIgnoreCase ("mg")) {
2015 doMGIndexes (dOc, searchNode);
2016 }
2017 else {
2018 doMGPPIndexes (dOc, searchNode);
2019 }
2020
2021 doDefaultIndex (dOc, searchNode);
2022 doDefaultLevel (dOc, searchNode);
2023 doLevel (dOc, searchNode);
2024 doIndexOption (dOc, searchNode);
2025 doSubcollection (dOc, searchNode);
2026 doIndexSubcollection (dOc, searchNode);
2027 doIndexLanguage (dOc, searchNode);
2028 doDefaultIndexLanguage (dOc, searchNode);
2029 doLanguageMetadata (dOc, searchNode);
2030 doSearchType (dOc, searchNode);
2031 doSearchFormat (dOc, searchNode);
2032 doDisplayFormat (dOc, fromElement);
2033 doReplaceListRef (dOc, fromElement);
2034 doServiceRackList (dOc, fromElement);
2035
2036 }
2037
2038
2039 static public String generateStringVersion(Document doc) {
2040 return XMLTools.xmlNodeToString(doc);
2041 }
2042
2043 static public void save (File collect_config_xml_file, Document doc) {
2044
2045 Document collection_config_xml_document = convertInternalToCollectionConfig (doc);
2046 String[] nonEscapingTagNames = {StaticStrings.FORMAT_STR};
2047 XMLTools.writeXMLFile (collect_config_xml_file, collection_config_xml_document, nonEscapingTagNames);
2048
2049 }
2050
2051 //Convert the internal XML DOM tree (dOc) into that of collectionConfig.xml (skeleton)
2052 static private Document convertInternalToCollectionConfig (Document dOc) {
2053 //first parse an empty skeleton of xml config file
2054 //The aim is to convert the internal structure into this skeleton
2055 Document skeleton = XMLTools.parseXMLFile ("xml/CollectionConfig.xml", true);
2056 //Element internal = dOc.getDocumentElement();
2057 convertMetadataList (dOc, skeleton);
2058 convertDisplayItemList (dOc, skeleton);
2059 convertBuildType (dOc, skeleton);
2060 convertIndex (dOc, skeleton);
2061 convertPlugin (dOc, skeleton);//also do the plugout element
2062 convertClassifier (dOc, skeleton);
2063 convertSubcollectionIndexes (dOc, skeleton);
2064 convertLanguages (dOc, skeleton);
2065 convertSubcollection (dOc, skeleton);
2066 convertSearchType (dOc, skeleton);
2067 convertSearchFormat (dOc, skeleton);
2068 convertDisplayFormat (dOc, skeleton);
2069 convertReplaceListRef (dOc, skeleton);
2070 convertServiceRackList(dOc, skeleton);
2071
2072 return skeleton;
2073 }
2074
2075 // Append the elements, which are of Element type, in 'list' to Element 'to'
2076 static private void appendArrayList (Element to, ArrayList list) {
2077 if (list == null) return;
2078
2079 for (int i=0; i<list.size (); i++) {
2080 appendProperly (to, (Element)list.get (i));
2081 }
2082 }
2083
2084
2085
2086}
Note: See TracBrowser for help on using the repository browser.