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

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

search types now separate elements in config file, not format elements. but in internal dom we pretend they are format statements to keep the interface the same as before.
File size: 93.6 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 Node replace_element = XMLTools.getChildByTagName (from, StaticStrings.REPLACELISTREF_STR);
877 if (replace_element == null) {
878 return; // such an element not found
879 }
880
881 Element to_element = XMLTools.duplicateElement (to, (Element)replace_element, true);
882 toElement.appendChild (to_element);
883 }
884 static private void convertReplaceListRef (Document from, Document to) {
885 Element toElement = to.getDocumentElement ();
886
887 Node replace_element = XMLTools.getChildByTagName (from.getDocumentElement (), StaticStrings.REPLACELISTREF_STR);
888 if (replace_element == null) {
889 return; // such an element not found
890 }
891
892 Element to_element = XMLTools.duplicateElement (to, (Element)replace_element, true);
893 toElement.appendChild (to_element);
894 }
895 static private void doOAIElement (Document to, Element from) {
896 Element toElement = to.getDocumentElement ();
897
898 Node oai_element = XMLTools.getChildByTagName (from, StaticStrings.OAI_ELEMENT);
899 if (oai_element == null) {
900 return; // such an element not found
901 }
902
903 Element to_element = XMLTools.duplicateElement (to, (Element)oai_element, true);
904 toElement.appendChild (to_element);
905 }
906 static private void convertOAIElement (Document from, Document to) {
907 Element toElement = to.getDocumentElement ();
908
909 Node oai_element = XMLTools.getChildByTagName (from.getDocumentElement (), StaticStrings.OAI_ELEMENT);
910 if (oai_element == null) {
911 return; // such an element not found
912 }
913
914 Element to_element = XMLTools.duplicateElement (to, (Element)oai_element, true);
915 toElement.appendChild (to_element);
916 }
917 static private void doDefaultIndexLanguage (Document to, Node searchNode) {
918 Element toElement = to.getDocumentElement ();
919 String elementNameFrom = StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT;
920 String elementNameTo = StaticStrings.LANGUAGE_DEFAULT_ELEMENT;
921 Node from_element = XMLTools.getChildByTagName (searchNode, elementNameFrom);
922 if (from_element == null) {
923 return; // such an element not found
924 }
925
926 Element to_element = to.createElement (elementNameTo);
927
928 String name_str = ((Element)from_element).getAttribute (StaticStrings.NAME_ATTRIBUTE);
929 to_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
930 to_element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
931
932 toElement.appendChild (to_element);
933 }
934
935 //Handle 'indexOption' (i.e. casefold, stem etc). In the internal structure, the element is called 'IndexOption'
936 static private void doIndexOption (Document to, Node searchNode) {
937 Element toElement = to.getDocumentElement ();
938 Node index_option_node = XMLTools.getChildByTagName (searchNode, StaticStrings.INDEXOPTION_STR);
939 if (index_option_node == null) {
940 return;
941 }
942 NodeList option_children = ((Element)index_option_node).getElementsByTagName (StaticStrings.OPTION_STR);
943 int option_nodes = option_children.getLength ();
944
945 // for lucene, there is no 'indexOption'. We build a default 'indexOption' and 'assigned=false' in case the user switches to mg or mgpp
946 if (option_nodes < 1) {
947 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
948 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
949 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
950 String[] option_str =
951 { StaticStrings.CASEFOLD_OPTION_STR, StaticStrings.STEM_OPTION_STR };
952 for (int i=0; i<option_str.length; i++) {
953 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
954 option_element.setAttribute (StaticStrings.NAME_STR, option_str[i]);
955 index_option.appendChild (option_element);
956 }
957 appendProperly (toElement, index_option);
958 return;
959 }
960
961 Element index_option = to.createElement (StaticStrings.INDEXOPTIONS_ELEMENT);
962 index_option.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
963 index_option.setAttribute (StaticStrings.NAME_STR, StaticStrings.INDEXOPTIONS_STR);
964
965 for (int i=0; i<option_nodes; i++) {
966 String option_str = ((Element)option_children.item (i)).getAttribute (StaticStrings.NAME_ATTRIBUTE);
967 Element option_element = to.createElement (StaticStrings.OPTION_ELEMENT);
968 option_element.setAttribute (StaticStrings.NAME_STR, option_str);
969 index_option.appendChild (option_element);
970 }
971 appendProperly (toElement, index_option);
972 }
973
974 static private Element doBuildType (Document to, String att_value) {
975
976 //construct 'BuildType' element
977 Element element = to.createElement (StaticStrings.BUILDTYPE_ELEMENT);
978 element.setAttribute (StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
979 element.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
980 element.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
981 element.setAttribute (StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
982
983 XMLTools.setNodeText (element, att_value);
984
985 return element;
986 }
987
988 // Convert 'description', 'smallicon' etc.
989 static private void convertDisplayItemList (Document from, Document to) {
990 Element displayItemList = to.createElement (StaticStrings.DISPLAYITEMLIST_STR);
991 Element destination = to.getDocumentElement ();
992
993 String []att_values =
994 {StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR,
995 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR,
996 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR,
997 StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR};
998
999 String []map_attrs =
1000 {StaticStrings.DESCRIPTION_STR,
1001 StaticStrings.SMALLICON_STR,
1002 StaticStrings.ICON_STR,
1003 StaticStrings.NAME_STR};
1004
1005 for (int i=0; i<att_values.length; i++) {
1006
1007 //dOc
1008 ArrayList e_list = XMLTools.getNamedElementList (from.getDocumentElement (),
1009 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1010 StaticStrings.NAME_ATTRIBUTE, att_values[i]);
1011 // if such elements don't exist, don't bother
1012 if (e_list == null) {
1013 continue;
1014 }
1015 for (int j=0; j<e_list.size (); j++) {
1016 Element e = (Element)e_list.get (j);
1017 if (e.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1018 continue;
1019 }
1020 String text = XMLTools.getNodeText (e);
1021 String lang = e.getAttribute (StaticStrings.LANGUAGE_ATTRIBUTE);
1022
1023 Element displayItem = constructElement (StaticStrings.DISPLAYITEM_STR, map_attrs[i],
1024 StaticStrings.LANG_STR, lang, text, to);
1025 displayItemList.appendChild (displayItem);
1026 }
1027
1028 }
1029 destination.appendChild (displayItemList);
1030 }
1031 // This method creates a DisplayItem element of the type of 'to' by using the ingredients from the element 'e'
1032 static private Element constructDisplayItem (Element e, Document to) {
1033 String lang_string = e.getAttribute (StaticStrings.LANGUAGE_ATTRIBUTE);
1034 String text = XMLTools.getNodeText (e);
1035 Element displayItem = to.createElement (StaticStrings.DISPLAYITEM_STR);
1036 displayItem.setAttribute (StaticStrings.NAME_ATTRIBUTE, StaticStrings.NAME_ATTRIBUTE);
1037 displayItem.setAttribute (StaticStrings.LANG_STR, lang_string);
1038 XMLTools.setNodeText (displayItem, text);
1039 return displayItem;
1040 }
1041 static private void convertMetadataList (Document from, Document to) {
1042 Element metadataList = to.createElement (StaticStrings.METADATALIST_STR);
1043 Element destination = to.getDocumentElement ();
1044
1045 String []ele_names =
1046 {StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT,
1047 StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT,
1048 StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT};
1049 String []att_names =
1050 {StaticStrings.COLLECTIONMETADATA_CREATOR_STR,
1051 StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR,
1052 StaticStrings.COLLECTIONMETADATA_PUBLIC_STR};
1053 for (int i=0; i<ele_names.length; i++) {
1054 Element e = XMLTools.getNamedElement (from.getDocumentElement (),
1055 ele_names[i], StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1056 if (e == null) {
1057 continue;
1058 }
1059 String text = XMLTools.getNodeText (e);
1060 Element metadata = to.createElement (StaticStrings.METADATA_STR);
1061 metadata.setAttribute (StaticStrings.NAME_ATTRIBUTE, att_names[i]);
1062 metadata.setAttribute (StaticStrings.LANG_STR, StaticStrings.ENGLISH_LANGUAGE_STR);
1063 XMLTools.setNodeText (metadata, text);
1064 metadataList.appendChild (metadata);
1065 }
1066
1067 destination.appendChild (metadataList);
1068 }
1069 // This method creates an element with the name 'element_name' of the type of 'to' by using the other three strings
1070 static private Element constructElement (String element_name, String name_value, String lang_att, String lang_value, String text, Document to) {
1071 Element e = to.createElement (element_name);
1072 e.setAttribute (StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1073 e.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_value);
1074 e.setAttribute (lang_att, lang_value);
1075 XMLTools.setNodeText (e, text);
1076
1077 return e;
1078 }
1079 // Convert classify in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1080 static private void convertClassifier (Document from, Document to) {
1081 Element browse_element = to.createElement (StaticStrings.BROWSE_STR);
1082 NodeList children = from.getDocumentElement ().getElementsByTagName (StaticStrings.CLASSIFY_ELEMENT);
1083
1084 int num_children = (children == null)? 0 : children.getLength ();
1085
1086 if (num_children == 0) {
1087 return ;
1088 }
1089
1090 for (int i=0; i<num_children; i++) {
1091
1092 Element child = (Element)children.item (i);
1093 if (child.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1094 continue;
1095 }
1096 String str = child.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1097 Element classifier_element = to.createElement (StaticStrings.CLASSIFIER_STR);
1098 classifier_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, str);
1099
1100 NodeList option_children = child.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1101 for (int j=0; j<option_children.getLength (); j++) {
1102 Element el = (Element)option_children.item (j);
1103 if (el.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1104 continue;
1105 }
1106 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1107 String value_str = XMLTools.getNodeText (el);
1108
1109
1110 if (name_str == null && value_str == null) {
1111 continue;
1112 }
1113 Element option_element = to.createElement (StaticStrings.OPTION_STR);
1114 if (name_str != null && name_str.equals (StaticStrings.METADATA_STR)) {
1115
1116 // 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.
1117 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
1118 value_str = "";
1119 for (int k=0; k<=values.length-1; k++) {
1120 if(values[k].startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1121 values[k] = values[k].substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1122 }
1123 else {
1124 MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName (values[k]);
1125 if (metadata_element != null) {
1126 values[k] = metadata_element.getFullName ();
1127 }
1128 }
1129 if (k < values.length-1) {
1130 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1131 } else {
1132 value_str = value_str + values[k];
1133 }
1134 }
1135 }
1136
1137 if (!name_str.equals ("")) {
1138 if (!name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
1139 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1140 }
1141 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1142 }
1143
1144 if (!value_str.equals ("")) {
1145 option_element.setAttribute (StaticStrings.VALUE_ATTRIBUTE, value_str);
1146 }
1147
1148 classifier_element.appendChild (option_element);
1149 }
1150
1151 //format element for this classifier
1152 Element e = (Element)XMLTools.getChildByTagName (child, StaticStrings.FORMAT_STR);
1153
1154 if (e != null) {
1155 classifier_element.appendChild (convertFormat(to, e));
1156 }
1157 browse_element.appendChild (classifier_element);
1158 }
1159
1160 //convert default classifier format
1161 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1162 StaticStrings.NAME_ATTRIBUTE, StaticStrings.BROWSE_STR);
1163 browse_element.appendChild (convertFormat(to, e));
1164
1165 to.getDocumentElement ().appendChild (browse_element);
1166 }
1167 static private Element convertFormat(Document to, Element e) {
1168 String format_str = XMLTools.getNodeText(e);
1169 Element format = to.createElement (StaticStrings.FORMAT_STR);
1170 //XMLTools.copyAllChildren (format, e);
1171 XMLTools.setNodeText(format, format_str);
1172 return format;
1173 }
1174 //convert format statement for search
1175 static private void convertSearchFormat (Document from, Document to) {
1176 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1177 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1178 StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCH_STR);
1179
1180 search.appendChild (convertFormat(to, e));
1181
1182 }
1183 //convert format statement for display of the documents
1184 static private void convertDisplayFormat (Document from, Document to) {
1185 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1186 StaticStrings.NAME_ATTRIBUTE, StaticStrings.DISPLAY_STR);
1187 if (e == null) {
1188 return;
1189 }
1190 Element display = to.createElement (StaticStrings.DISPLAY_STR);
1191 display.appendChild (convertFormat(to, e));
1192 to.getDocumentElement ().appendChild (display);
1193 }
1194 // Convert plugins in the internal(i.e. Document from) to collectionconfig.xml (i.e. Document to)
1195 static private void convertPlugin (Document from, Document to) {
1196 Element import_element = to.createElement (StaticStrings.IMPORT_STR);
1197 Element plugin_list_element = to.createElement (StaticStrings.PLUGINLIST_STR);
1198
1199 NodeList children = from.getDocumentElement ().getElementsByTagName (StaticStrings.PLUGIN_ELEMENT);
1200 int num_children = (children == null)? 0 : children.getLength ();
1201 if (num_children == 0) {
1202 return ;
1203 }
1204
1205 for (int i=0; i<num_children; i++) {
1206
1207 Element child = (Element)children.item (i);
1208 if (child.getAttribute (StaticStrings.SEPARATOR_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1209 continue;
1210 }
1211 if (child.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1212 continue;
1213 }
1214
1215 String str = child.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1216 Element plugin_element = to.createElement (StaticStrings.PLUGIN_STR);
1217 plugin_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, str);
1218
1219 NodeList option_children = child.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1220 for (int j=0; j<option_children.getLength (); j++) {
1221 Element el = (Element)option_children.item (j);
1222 if(!el.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1223 continue;
1224 }
1225 String name_str = el.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1226 String value_str = XMLTools.getNodeText (el);
1227
1228
1229 if (name_str == null && value_str == null) {
1230 continue;
1231 }
1232 Element option_element = to.createElement (StaticStrings.OPTION_STR);
1233 if (name_str != null && name_str.equals (StaticStrings.METADATA_STR)) {
1234
1235 // 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.
1236 String[] values = value_str.split (StaticStrings.COMMA_CHARACTER);
1237 value_str = "";
1238 for (int k=0; k<=values.length-1; k++) {
1239 if(values[k].startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1240 values[k] = values[k].substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1241 }
1242
1243 if (k < values.length-1) {
1244 value_str = value_str + values[k] + StaticStrings.COMMA_CHARACTER;
1245 } else {
1246 value_str = value_str + values[k];
1247 }
1248 }
1249 }
1250
1251 if (!name_str.equals ("")) {
1252 if (!name_str.startsWith (StaticStrings.MINUS_CHARACTER)) {
1253 name_str = StaticStrings.MINUS_CHARACTER + name_str;
1254 }
1255 option_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1256 }
1257
1258 if (!value_str.equals ("")) {
1259 option_element.setAttribute (StaticStrings.VALUE_ATTRIBUTE, value_str);
1260 }
1261
1262 plugin_element.appendChild (option_element);
1263 }//for loop ends
1264
1265 plugin_list_element.appendChild (plugin_element);
1266 }//for loop ends
1267
1268 import_element.appendChild (plugin_list_element);
1269
1270 //do the plugout element (used by building flax collections)
1271 Node plugout = XMLTools.getChildByTagNameIndexed (from.getDocumentElement (), PLUGOUT_ELEMENT, 0);
1272 if (plugout != null) {
1273 Element to_element = XMLTools.duplicateElement (to, (Element)plugout, true);
1274 import_element.appendChild (to_element);
1275 }
1276
1277 to.getDocumentElement ().appendChild (import_element);
1278 }
1279
1280 //Handle 'searchType' of collectionConfig.xml. In the internal structure, its also called 'searchType', eg. plain, form
1281 static private void convertSearchType (Document from, Document to) {
1282 Element e = XMLTools.getNamedElement (from.getDocumentElement (), StaticStrings.FORMAT_STR,
1283 StaticStrings.NAME_ATTRIBUTE, StaticStrings.SEARCHTYPE_ELEMENT);//searchType
1284
1285 if (e == null) {
1286 return;
1287 }
1288 String searchtype_str = XMLTools.getNodeText(e);
1289 //Get the 'search' element from 'to'
1290 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1291
1292 String[] types = searchtype_str.split(",");
1293 for (int i=0; i<types.length; i++) {
1294 Element search_type_element = to.createElement (StaticStrings.SEARCHTYPE_ELEMENT);
1295 search_type_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, types[i]);
1296 search.appendChild (search_type_element);
1297 }
1298 }
1299
1300 static private void convertBuildType (Document from, Document to) {
1301 Element e = XMLTools.getNamedElement (from.getDocumentElement (),
1302 StaticStrings.BUILDTYPE_ELEMENT,
1303 StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
1304 if (e == null) {
1305 return;
1306 }
1307 String indexer = XMLTools.getNodeText (e);
1308 Element search = to.createElement (StaticStrings.SEARCH_STR);
1309 search.setAttribute (StaticStrings.TYPE_ATTRIBUTE, indexer);
1310 to.getDocumentElement ().appendChild (search);
1311 }
1312 static private void convertDefaultIndex (Document from, Document to, Element search) {
1313 Element source = from.getDocumentElement ();
1314
1315 Element default_index_element = (Element)XMLTools.getChildByTagName (source, StaticStrings.INDEX_DEFAULT_ELEMENT);
1316 if (default_index_element == null) {
1317 return;
1318 }
1319
1320 String indexer = search.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1321 String level_str = default_index_element.getAttribute (StaticStrings.LEVEL_ATTRIBUTE);
1322 // Debugging purposes
1323 if (level_str.equals ("") && indexer.equals (StaticStrings.MG_STR) ) {
1324 System.out.println ("Bug: DefaultIndex should have its level attribute not empty.");
1325 }
1326
1327 NodeList content_elements = default_index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1328 int content_elements_length = content_elements.getLength ();
1329
1330 // Don't output anything if no indexes are set
1331 if(content_elements_length == 0) {
1332 return ;//
1333 }
1334
1335 String index_str = "";
1336
1337 if (indexer.equals (StaticStrings.MG_STR)) {
1338 //combine level with indexes
1339 index_str = level_str + StaticStrings.COLON_CHARACTER;
1340 }
1341 else { //for mgpp/lucene, just take index
1342 //do nothing
1343 }
1344
1345 for(int k = 0; k < content_elements_length; k++) {
1346 Element content_element = (Element) content_elements.item (k);
1347 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1348 continue;
1349 }
1350 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1351
1352 if(name_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1353 name_str = name_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1354 }
1355
1356 index_str = index_str + name_str;
1357
1358 // Make it comma separated string
1359 if(k < content_elements_length - 1) {
1360 index_str = index_str + StaticStrings.COMMA_CHARACTER;
1361 }
1362 content_element = null;
1363 }//for loop ends
1364
1365
1366 Element default_index = to.createElement (StaticStrings.INDEX_DEFAULT_ELEMENT_LOWERCASE);
1367 default_index.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_str);
1368 search.appendChild (default_index);
1369
1370 }
1371 static private void convertSubcollection (Document from, Document to) {
1372 Element source = from.getDocumentElement ();
1373 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1374 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1375
1376 // Get the Subcollection element from the internal structure
1377 NodeList subcollection_elements = source.getElementsByTagName (StaticStrings.SUBCOLLECTION_ELEMENT);
1378 if (subcollection_elements == null) {
1379 return;
1380 }
1381 int subcollection_elements_length = subcollection_elements.getLength ();
1382
1383 if (subcollection_elements_length == 0) { // no
1384 return ;
1385 }
1386
1387 for(int j = 0; j < subcollection_elements_length; j++) {
1388
1389 Element e = (Element) subcollection_elements.item (j);
1390 if (e.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1391 continue;
1392 }
1393 String content = e.getAttribute (StaticStrings.CONTENT_ATTRIBUTE);
1394 String name = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1395 String options = e.getAttribute (StaticStrings.OPTIONS_ATTRIBUTE);
1396 String type = e.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1397 String text = XMLTools.getNodeText (e);
1398
1399 String filter = "";
1400 if (type.equals (StaticStrings.EXCLUDE_STR)) {
1401 filter = StaticStrings.EXCLAMATION_CHARACTER;
1402 }
1403
1404 if(content.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1405 content = content.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1406 }
1407 filter = filter + content + StaticStrings.SEPARATOR_CHARACTER + text;
1408 if (options != null && options != "") {
1409 filter = filter + StaticStrings.SEPARATOR_CHARACTER + options;
1410 }
1411 Element subcollection = to.createElement (StaticStrings.SUBCOLLECTION_STR);
1412 subcollection.setAttribute (StaticStrings.FILTER_ATTRIBUTE, filter);
1413 subcollection.setAttribute (StaticStrings.NAME_ATTRIBUTE, name);
1414
1415 search.appendChild (subcollection);
1416 }
1417 }
1418 static private void convertSubcollectionIndexes (Document from, Document to) {
1419 Element source = from.getDocumentElement ();
1420 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1421 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1422
1423 // Get the SubcollectionIndexes element from the internal structure
1424 Element subcollection_indexes = (Element)XMLTools.getChildByTagName (source, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
1425 if (subcollection_indexes == null) {
1426 return;
1427 }
1428 NodeList index_elements = subcollection_indexes.getElementsByTagName (StaticStrings.INDEX_ELEMENT);
1429 int index_elements_length = index_elements.getLength ();
1430
1431 if (index_elements_length == 0) { // no indexes
1432 return ;
1433 }
1434
1435 for(int j = 0; j < index_elements_length; j++) {
1436 Element index_element = (Element) index_elements.item (j);
1437 if (index_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1438 continue;
1439 }
1440
1441 Element index = to.createElement (StaticStrings.SUBCOLLECTION_INDEX_ELEMENT);
1442
1443 String index_value = "";
1444
1445 NodeList content_elements = index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1446 int content_elements_length = content_elements.getLength ();
1447
1448 for(int k = 0; k < content_elements_length; k++) {
1449 Element content_element = (Element) content_elements.item (k);
1450 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1451 continue;
1452 }
1453 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1454 index_value += name_str;
1455 // Make it comma separated string
1456 if(k < content_elements_length - 1) {
1457 index_value += StaticStrings.COMMA_CHARACTER;
1458 }
1459 content_element = null;
1460 }//for loop ends
1461
1462 index.setAttribute (StaticStrings.NAME_ATTRIBUTE, index_value);
1463
1464 // Now constructing 'displayItem' element for this 'indexSubcollection' element
1465 // from the collectionmetadata element
1466 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1467 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1468 StaticStrings.NAME_ATTRIBUTE, index_value);
1469
1470 if (collectionmetadata_list != null) {
1471
1472 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1473 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1474 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1475 continue;
1476 }
1477 Element displayItem = constructDisplayItem (collectionmetadata, to);
1478 index.appendChild (displayItem);
1479 }
1480 }
1481
1482 search.appendChild (index);
1483
1484 } //for loop ends
1485 }
1486
1487 static private void convertLanguages (Document from, Document to) {
1488 Element source = from.getDocumentElement ();
1489 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1490 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1491
1492 // Get the Languages element from the internal structure
1493 Element languages = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGES_ELEMENT);
1494 if (languages == null) {
1495 return;
1496 }
1497 NodeList language_elements = languages.getElementsByTagName (StaticStrings.LANGUAGE_ELEMENT);
1498 int language_elements_length = language_elements.getLength ();
1499
1500 if (language_elements_length == 0) {
1501 return ;
1502 }
1503
1504 for(int j = 0; j < language_elements_length; j++) {
1505 Element element = (Element) language_elements.item (j);
1506 if (element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1507 continue;
1508 }
1509
1510 // Create indexLanguage element
1511 Element index_language = to.createElement (StaticStrings.LANGUAGE_INDEX_ELEMENT);
1512
1513 String name_str = element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1514 index_language.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1515
1516 // Now constructing 'displayItem' element for this 'indexLanguage' element
1517 // from the collectionmetadata element
1518 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1519 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1520 StaticStrings.NAME_ATTRIBUTE, name_str);
1521
1522 if (collectionmetadata_list != null) {
1523
1524 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1525 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1526 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1527 continue;
1528 }
1529 Element displayItem = constructDisplayItem (collectionmetadata, to);
1530 index_language.appendChild (displayItem);
1531 }
1532 }
1533
1534 search.appendChild (index_language);
1535
1536 } //for loop ends
1537
1538 // Convert DefaultLanguage
1539 // Get the DefaultLanguage element from the internal structure
1540 Element default_language = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGE_DEFAULT_ELEMENT);
1541 if(default_language != null) {
1542 String lang_name = default_language.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1543 Element default_index_language = to.createElement (StaticStrings.LANGUAGE_DEFAULT_INDEX_ELEMENT);
1544 default_index_language.setAttribute (StaticStrings.NAME_ATTRIBUTE, lang_name);
1545 search.appendChild (default_index_language);
1546 }
1547 // Convert LanguageMetadata
1548 // Get the LanguageMetadata element from the internal structure
1549 Element language_metadata = (Element)XMLTools.getChildByTagName (source, StaticStrings.LANGUAGE_METADATA_ELEMENT);
1550 if(language_metadata != null) {
1551 String meta_name = language_metadata.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1552 Element language_meta = to.createElement (StaticStrings.LANGUAGE_METADATA_ELEMENT_STR);
1553 if(meta_name.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1554 meta_name = meta_name.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1555 }
1556 language_meta.setAttribute (StaticStrings.NAME_ATTRIBUTE, meta_name);
1557 search.appendChild (language_meta);
1558 }
1559 }
1560
1561 //convert indexes and their displayItems, which go in 'search' element in collectionConfig.xml
1562 //parameter 'to' is the document to be saved as collectionConfig.xml
1563 //parameter 'from' is the internal xml structure
1564 static private void convertIndex (Document from, Document to) {
1565 Element source = from.getDocumentElement ();
1566 //Get the 'search' element from 'to' which has already been created in 'convertBuildType'
1567 Element search = (Element)XMLTools.getChildByTagName (to.getDocumentElement (), StaticStrings.SEARCH_STR);
1568
1569 //THere are two sets of indexes elements, find the one which is assigned 'true'
1570 Element indexes = XMLTools.getNamedElement (source,
1571 StaticStrings.INDEXES_ELEMENT,
1572 StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
1573 if (indexes == null) {
1574 return;
1575 }
1576 NodeList index_elements = indexes.getElementsByTagName (StaticStrings.INDEX_ELEMENT);
1577 int index_elements_length = index_elements.getLength ();
1578
1579 if (index_elements_length == 0) { // no indexes
1580 return ;
1581 }
1582
1583 //find out it's mg or mgpp/lucene
1584 String mg = search.getAttribute (StaticStrings.TYPE_ATTRIBUTE);
1585 boolean mg_indexer = false;
1586 if (mg.equals (StaticStrings.MG_STR)) {
1587 mg_indexer = true;//it's mg, then the level is set as attribute of
1588 }
1589 if (mg_indexer == false) {
1590 // It's mgpp. Construct 'level' and 'defaultLevel' elements separately.
1591 convertLevels (from, to, search);
1592 }
1593
1594 for(int j = 0; j < index_elements_length; j++) {
1595 Element index_element = (Element) index_elements.item (j);
1596 if (index_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1597 continue;
1598 }
1599
1600 Element index_ele = to.createElement (StaticStrings.INDEX_LOW_STR);//index
1601
1602 // Used for creating displayItem for this element 'index_ele' further below
1603 // full_index_names contain 'ex.'
1604 String full_index_name = "";
1605 String level_str = "";
1606
1607 StringBuffer index_value = new StringBuffer ();
1608 if (mg_indexer == true) {
1609 // For mg indexer, there is a 'level' attribute in the index element of the internal structure
1610 // But mgpp/lucene don't
1611 level_str = index_element.getAttribute (StaticStrings.LEVEL_ATTRIBUTE);
1612 if(level_str.length () > 0) {
1613 index_value.append (level_str).append (StaticStrings.COLON_CHARACTER);
1614 //index_value = index_value.StaticStrings.COLON_CHARACTER;
1615 }
1616 }
1617
1618 NodeList content_elements = index_element.getElementsByTagName (StaticStrings.CONTENT_ELEMENT);
1619 int content_elements_length = content_elements.getLength ();
1620
1621 for(int k = 0; k < content_elements_length; k++) {
1622 Element content_element = (Element) content_elements.item (k);
1623 if (content_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1624 continue;
1625 }
1626 String name_str = content_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1627
1628 full_index_name = full_index_name + name_str;
1629 if (k < content_elements_length - 1) {
1630 full_index_name = full_index_name + StaticStrings.COMMA_CHARACTER;
1631 }
1632
1633 if(name_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
1634 name_str = name_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
1635 }
1636
1637 index_value.append (name_str);
1638 name_str = null;
1639 // Make it comma separated string
1640 if(k < content_elements_length - 1) {
1641 index_value.append (StaticStrings.COMMA_CHARACTER);
1642 }
1643 content_element = null;
1644 }//for loop ends
1645
1646 String temp_str = index_value.toString ();
1647 index_ele.setAttribute (StaticStrings.NAME_ATTRIBUTE, temp_str);
1648
1649 // Now constructing 'displayItem' element for this 'index_ele' element
1650 // The index names in the collectionmetadata elements in the internal structure are not the names that
1651 // are used in the content elements (i.e. ex.Source or dc.Subject and keywords), but the names that are
1652 // in the configuration files (i.e. Source or dc.Subject)
1653 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1654 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1655 StaticStrings.NAME_ATTRIBUTE, temp_str);
1656
1657 if (collectionmetadata_list == null) {
1658 //try the full name, i.e. with 'ex.'
1659 if (mg_indexer == true) {
1660 // but first append level info if we are mg
1661 full_index_name = level_str+StaticStrings.COLON_CHARACTER+full_index_name;
1662 }
1663 collectionmetadata_list = XMLTools.getNamedElementList (source,
1664 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1665 StaticStrings.NAME_ATTRIBUTE, full_index_name);
1666 }
1667
1668 if (collectionmetadata_list != null) {
1669
1670 for(int k = 0; k < collectionmetadata_list.size (); k++) {
1671 Element collectionmetadata = (Element)collectionmetadata_list.get (k);
1672 if (collectionmetadata.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1673 continue;
1674 }
1675 Element displayItem = constructDisplayItem (collectionmetadata, to);
1676
1677 index_ele.appendChild (displayItem);
1678 }
1679 }
1680
1681 search.appendChild (index_ele);
1682
1683 } //for loop ends
1684
1685 //Convert default index
1686 convertDefaultIndex (from, to, search);
1687 convertIndexOptions(from, to, search);
1688 }
1689 // Convert levels for mgpp/lucene. This method is called by converIndex() when mgpp indexer is detected.
1690 static private void convertLevels (Document from, Document to, Element search) {
1691 Element source = from.getDocumentElement ();
1692 Element index_option = XMLTools.getNamedElement (source,
1693 StaticStrings.INDEXOPTIONS_ELEMENT,
1694 StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVELS_STR);
1695 if (index_option == null) {
1696 return;
1697 }
1698 //Debugging purposes
1699 if (index_option.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1700 DebugStream.println ("For mgpp, there should be an IndexOption element for levels which is assigned 'true': possible bug.");
1701 }
1702
1703 NodeList option_elements = index_option.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1704 int num_elements = option_elements.getLength ();
1705
1706 // Don't output anything if no indexes are set
1707 if(num_elements == 0) {
1708 return ;//
1709 }
1710
1711 for(int k = 0; k < num_elements; k++) {
1712 Element e = (Element) option_elements.item (k);
1713 String name_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1714 Element level_element = to.createElement (StaticStrings.LEVEL_ELEMENT);
1715 level_element.setAttribute (StaticStrings.NAME_ATTRIBUTE, name_str);
1716
1717 //Now construct displayItem for this level element from collectionmetadata
1718 ArrayList collectionmetadata_list = XMLTools.getNamedElementList (source,
1719 StaticStrings.COLLECTIONMETADATA_ELEMENT,
1720 StaticStrings.NAME_ATTRIBUTE, name_str);
1721
1722 if (collectionmetadata_list != null) {
1723
1724 for(int j = 0; j < collectionmetadata_list.size (); j++) {
1725 Element collectionmetadata = (Element)collectionmetadata_list.get (j);
1726
1727 Element displayItem = constructDisplayItem (collectionmetadata, to);
1728 level_element.appendChild (displayItem);
1729 }
1730 }
1731 search.appendChild (level_element);
1732 }
1733
1734 //Convert default level
1735 Element default_index_option = XMLTools.getNamedElement (source,
1736 StaticStrings.INDEXOPTION_DEFAULT_ELEMENT,
1737 StaticStrings.NAME_ATTRIBUTE, StaticStrings.LEVEL_DEFAULT_STR);
1738 if (default_index_option == null) {
1739 return;
1740 }
1741 Element default_level = to.createElement (StaticStrings.LEVEL_DEFAULT_ELEMENT);
1742 String default_level_str = default_index_option.getAttribute (StaticStrings.VALUE_ATTRIBUTE);
1743 default_level.setAttribute (StaticStrings.NAME_ATTRIBUTE, default_level_str);
1744 search.appendChild (default_level);
1745
1746 }
1747 // Convert indexoptions for mg/mgpp/lucene. This method is called by convertIndex().
1748 static private void convertIndexOptions (Document from, Document to, Element search) {
1749 Element source = from.getDocumentElement ();
1750 Element index_option = XMLTools.getNamedElement (source,
1751 StaticStrings.INDEXOPTIONS_ELEMENT,
1752 StaticStrings.NAME_ATTRIBUTE, StaticStrings.INDEXOPTIONS_STR);
1753 if (index_option == null) {
1754 return;
1755 }
1756 //Debugging purposes
1757 if (index_option.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.FALSE_STR)) {
1758 DebugStream.println ("There should be an IndexOption element which is assigned 'true': possible bug.");
1759 }
1760 Element indexOptionEl = to.createElement(StaticStrings.INDEXOPTION_STR);
1761 NodeList option_elements = index_option.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
1762 int num_elements = option_elements.getLength ();
1763 // Don't output anything if no index
1764 if(num_elements == 0) {
1765 return ;//
1766 }
1767 search.appendChild (indexOptionEl);
1768
1769 for(int k = 0; k < num_elements; k++) {
1770 Element e = (Element) option_elements.item (k);
1771 String name_att = e.getAttribute(StaticStrings.NAME_ATTRIBUTE);
1772 Element optionEl = to.createElement(StaticStrings.OPTION_STR);
1773 optionEl.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_att);
1774 indexOptionEl.appendChild(optionEl);
1775 }
1776
1777 }
1778 // Append the element son to the element mother in the appropriate position.
1779 static public void appendProperly (Element mother, Element son) {
1780 if (son == null)
1781 return;
1782
1783 Node reference_node = findInsertionPoint (mother, son);
1784 if(reference_node != null) {
1785 mother.insertBefore (son, reference_node);
1786 }
1787 else {
1788 mother.appendChild (son);
1789 }
1790 }
1791 /** 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.
1792 * @param target_element the command Element to be inserted
1793 * @return the Element which the given command should be inserted before, or null to append to end of list
1794 */
1795 static public Node findInsertionPoint (Element document_element, Element target_element) {
1796 ///ystem.err.println("Find insertion point: " + target_element.getNodeName());
1797 String target_element_name = target_element.getNodeName ();
1798
1799 // Try to find commands with the same tag.
1800 NodeList matching_elements = document_element.getElementsByTagName (target_element_name);
1801 // If we found matching elements, then we have our most likely insertion location, so check within for groupings
1802 if(matching_elements.getLength () != 0) {
1803 ///ystem.err.println("Found matching elements.");
1804 // Only CollectionMeta are grouped.
1805 if(target_element_name.equals (StaticStrings.COLLECTIONMETADATA_ELEMENT)) {
1806 ///ystem.err.println("Dealing with collection metadata");
1807 // 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.
1808 // So if the command to be added is special add it immediately after any other special command
1809 if(target_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1810 int index = 0;
1811 Element matched_element = (Element) matching_elements.item (index);
1812 Element sibling_element = (Element) matched_element.getNextSibling ();
1813 while(sibling_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1814 index++;
1815 matched_element = (Element) matching_elements.item (index);
1816 sibling_element = (Element) matched_element.getNextSibling ();
1817 }
1818 if(sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1819 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1820 document_element.insertBefore (newline_element, sibling_element);
1821 }
1822 return sibling_element;
1823 }
1824 // Otherwise try to find a matching 'name' and add after the last one in that group.
1825 else {
1826 int index = 0;
1827 target_element_name = target_element.getAttribute (StaticStrings.NAME_ATTRIBUTE);
1828 boolean found = false;
1829 // Skip all of the special metadata
1830 Element matched_element = (Element) matching_elements.item (index);
1831 while(matched_element.getAttribute (StaticStrings.SPECIAL_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
1832 index++;
1833 matched_element = (Element) matching_elements.item (index);
1834 }
1835 // Begin search
1836 while(!found && matched_element != null) {
1837 if(matched_element.getAttribute (StaticStrings.NAME_ATTRIBUTE).equals (target_element_name)) {
1838 found = true;
1839 }
1840 else {
1841 index++;
1842 matched_element = (Element) matching_elements.item (index);
1843 }
1844 }
1845 // If we found a match, we need to continue checking until we find the last name match.
1846 if(found) {
1847 index++;
1848 Element previous_sibling = matched_element;
1849 Element sibling_element = (Element) matching_elements.item (index);
1850 while(sibling_element != null && sibling_element.getAttribute (StaticStrings.NAME_ATTRIBUTE).equals (target_element_name)) {
1851 previous_sibling = sibling_element;
1852 index++;
1853 sibling_element = (Element) matching_elements.item (index);
1854 }
1855 // 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!
1856 return previous_sibling.getNextSibling ();
1857 }
1858 // If not found we just add after last metadata element
1859 else {
1860 Element last_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1861 return last_element.getNextSibling ();
1862 }
1863 }
1864
1865 }
1866 else {
1867 ///ystem.err.println("Not dealing with collection meta.");
1868 Element matched_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1869 // 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)
1870 Node sibling_element = matched_element.getNextSibling ();
1871 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1872 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1873 document_element.insertBefore (newline_element, sibling_element);
1874 }
1875 return sibling_element; // Note that this may be null
1876 }
1877 }
1878 ///ystem.err.println("No matching elements found.");
1879 // Locate where this command is in the ordering
1880 int command_index = -1;
1881 for(int i = 0; command_index == -1 && i < CollectionConfiguration.COMMAND_ORDER.length; i++) {
1882 if(CollectionConfiguration.COMMAND_ORDER[i].equals (target_element_name)) {
1883 command_index = i;
1884 }
1885 }
1886 ///ystem.err.println("Command index is: " + command_index);
1887 // Now move forward, checking for existing elements in each of the preceeding command orders.
1888 int preceeding_index = command_index - 1;
1889 ///ystem.err.println("Searching before the target command.");
1890 while(preceeding_index >= 0) {
1891 matching_elements = document_element.getElementsByTagName (CollectionConfiguration.COMMAND_ORDER[preceeding_index]);
1892 // If we've found a match
1893 if(matching_elements.getLength () > 0) {
1894 // We add after the last element
1895 Element matched_element = (Element) matching_elements.item (matching_elements.getLength () - 1);
1896 // 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)
1897 Node sibling_element = matched_element.getNextSibling ();
1898 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1899 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1900 document_element.insertBefore (newline_element, sibling_element);
1901 }
1902 return sibling_element; // Note that this may be null
1903 }
1904 preceeding_index--;
1905 }
1906 // If all that fails, we now move backwards through the commands
1907 int susceeding_index = command_index + 1;
1908 ///ystem.err.println("Searching after the target command.");
1909 while(susceeding_index < CollectionConfiguration.COMMAND_ORDER.length) {
1910 matching_elements = document_element.getElementsByTagName (CollectionConfiguration.COMMAND_ORDER[susceeding_index]);
1911 // If we've found a match
1912 if(matching_elements.getLength () > 0) {
1913 // We add before the first element
1914 Element matched_element = (Element) matching_elements.item (0);
1915 // 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)
1916 Node sibling_element = matched_element.getPreviousSibling ();
1917 if(sibling_element != null && sibling_element.getNodeName ().equals (CollectionConfiguration.NEWLINE_ELEMENT)) {
1918 Element newline_element = document_element.getOwnerDocument().createElement (CollectionConfiguration.NEWLINE_ELEMENT);
1919 document_element.insertBefore (newline_element, sibling_element);
1920 }
1921 return sibling_element; // Note that this may be null
1922 }
1923 susceeding_index++;
1924 }
1925 // Well. Apparently there are no other commands in this collection configuration. So append away...
1926 return null;
1927 }
1928 // From collectionConfig.xml to internal structure:add 'ex.' namespace (if none).
1929 // From internal structure to collectionConfig.xml:always peel off 'ex.' namespace (if any), except for format statement
1930 //This method parses 'xml_file_doc' into 'dOc'
1931 static public void parse(File xml_file, Document dOc) {
1932
1933 Document xml_file_doc = XMLTools.parseXMLFile (xml_file);
1934 Element fromElement = xml_file_doc.getDocumentElement ();
1935 Element toElement = dOc.getDocumentElement ();
1936
1937 // It's deliberately set that 'creator', 'maintainer', and 'public' are only in English (as they are just names).
1938 // So the following ArrayList have only one element.
1939 Node metadataListNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.METADATALIST_STR, 0);
1940 if (metadataListNode != null) {
1941 ArrayList creator = doMetadataList (dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT,
1942 StaticStrings.COLLECTIONMETADATA_CREATOR_STR);
1943 ArrayList maintainer = doMetadataList (dOc, metadataListNode,
1944 StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT,
1945 StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR);
1946 ArrayList is_public = doMetadataList (dOc, metadataListNode, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT,
1947 StaticStrings.COLLECTIONMETADATA_PUBLIC_STR);
1948
1949 appendArrayList (toElement, creator);
1950 appendArrayList (toElement, maintainer);
1951 appendArrayList (toElement, is_public);
1952 }
1953
1954 Node searchNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.SEARCH_STR, 0);
1955 String buildtype_value = ((Element)searchNode).getAttribute (StaticStrings.TYPE_ATTRIBUTE);//might be mg|mgpp|lucene
1956 Element buildtype = doBuildType (dOc, buildtype_value);
1957 appendProperly (toElement, buildtype);
1958
1959
1960 Node importNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.IMPORT_STR, 0);
1961 if (importNode == null) {
1962 System.out.println ("There is no content in the 'import' block.");
1963 }
1964 if (importNode != null) {
1965 //do plugin list nodes
1966 Node pluginListNode = XMLTools.getChildByTagNameIndexed ((Element)importNode, StaticStrings.PLUGINLIST_STR, 0);
1967 if (pluginListNode == null) {
1968 System.out.println ("There is no pluginlist set.");
1969 }
1970 if (pluginListNode != null) {
1971
1972 doPlugin (dOc, pluginListNode);
1973 }
1974
1975 //do the plugout element (used by building flax collections)
1976 Node plugout = XMLTools.getChildByTagNameIndexed ((Element)importNode, PLUGOUT_ELEMENT, 0);
1977 if (plugout != null) {
1978 Element to_element = XMLTools.duplicateElement (dOc, (Element)plugout, true);
1979 toElement.appendChild (to_element);
1980 }
1981 }
1982
1983 Node browseNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.BROWSE_STR, 0);
1984 if (browseNode != null) {
1985 if (browseNode == null) {
1986 System.out.println ("There is no classifier.");
1987 }
1988 doClassifier (dOc, browseNode);
1989 }
1990
1991 Node displayItemListNode = XMLTools.getChildByTagNameIndexed (fromElement, StaticStrings.DISPLAYITEMLIST_STR, 0);
1992 if (displayItemListNode != null) {
1993 ArrayList description = doDisplayItemList (dOc, displayItemListNode, StaticStrings.DESCRIPTION_STR,
1994 StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR);
1995 ArrayList smallicon = doDisplayItemList (dOc, displayItemListNode, StaticStrings.SMALLICON_STR,
1996 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR);
1997 ArrayList icon = doDisplayItemList (dOc, displayItemListNode, StaticStrings.ICON_STR,
1998 StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR);
1999 ArrayList name = doDisplayItemList (dOc, displayItemListNode, StaticStrings.NAME_STR,
2000 StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR);
2001
2002 appendArrayList (toElement, description);
2003 appendArrayList (toElement, smallicon);
2004 appendArrayList (toElement, icon);
2005 appendArrayList (toElement, name);
2006 }
2007
2008 if (buildtype_value.equalsIgnoreCase ("mg")) {
2009 doMGIndexes (dOc, searchNode);
2010 }
2011 else {
2012 doMGPPIndexes (dOc, searchNode);
2013 }
2014
2015 doDefaultIndex (dOc, searchNode);
2016 doDefaultLevel (dOc, searchNode);
2017 doLevel (dOc, searchNode);
2018 doIndexOption (dOc, searchNode);
2019 doSubcollection (dOc, searchNode);
2020 doIndexSubcollection (dOc, searchNode);
2021 doIndexLanguage (dOc, searchNode);
2022 doDefaultIndexLanguage (dOc, searchNode);
2023 doLanguageMetadata (dOc, searchNode);
2024 doSearchType (dOc, searchNode);
2025 doSearchFormat (dOc, searchNode);
2026 doDisplayFormat (dOc, fromElement);
2027 doReplaceListRef (dOc, fromElement);
2028 doOAIElement (dOc, fromElement);
2029
2030 }
2031
2032
2033 static public String generateStringVersion(Document doc) {
2034 return XMLTools.xmlNodeToString(doc);
2035 }
2036
2037 static public void save (File collect_config_xml_file, Document doc) {
2038
2039 Document collection_config_xml_document = convertInternalToCollectionConfig (doc);
2040 String[] nonEscapingTagNames = {StaticStrings.FORMAT_STR};
2041 XMLTools.writeXMLFile (collect_config_xml_file, collection_config_xml_document, nonEscapingTagNames);
2042
2043 }
2044
2045 //Convert the internal XML DOM tree (dOc) into that of collectionConfig.xml (skeleton)
2046 static private Document convertInternalToCollectionConfig (Document dOc) {
2047 //first parse an empty skeleton of xml config file
2048 //The aim is to convert the internal structure into this skeleton
2049 Document skeleton = XMLTools.parseXMLFile ("xml/CollectionConfig.xml", true);
2050 //Element internal = dOc.getDocumentElement();
2051 convertMetadataList (dOc, skeleton);
2052 convertDisplayItemList (dOc, skeleton);
2053 convertBuildType (dOc, skeleton);
2054 convertIndex (dOc, skeleton);
2055 convertPlugin (dOc, skeleton);//also do the plugout element
2056 convertClassifier (dOc, skeleton);
2057 convertSubcollectionIndexes (dOc, skeleton);
2058 convertLanguages (dOc, skeleton);
2059 convertSubcollection (dOc, skeleton);
2060 convertSearchType (dOc, skeleton);
2061 convertSearchFormat (dOc, skeleton);
2062 convertDisplayFormat (dOc, skeleton);
2063 convertReplaceListRef (dOc, skeleton);
2064 convertOAIElement(dOc, skeleton);
2065
2066 return skeleton;
2067 }
2068
2069 // Append the elements, which are of Element type, in 'list' to Element 'to'
2070 static private void appendArrayList (Element to, ArrayList list) {
2071 if (list == null) return;
2072
2073 for (int i=0; i<list.size (); i++) {
2074 appendProperly (to, (Element)list.get (i));
2075 }
2076 }
2077
2078
2079
2080}
Note: See TracBrowser for help on using the repository browser.