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

Last change on this file since 24367 was 24367, checked in by ak19, 13 years ago

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