source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGPPSearch.java@ 4081

Last change on this file since 4081 was 4081, checked in by kjdon, 21 years ago

added All fields to field list
  • Property svn:keywords set to Author Date Id Revision
File size: 24.9 KB
Line 
1/*
2 * GS2MGPPSearch.java
3 * Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19package org.greenstone.gsdl3.service;
20
21
22// Greenstone classes
23import org.greenstone.mgpp.*;
24import org.greenstone.gsdl3.util.*;
25
26// XML classes
27import org.w3c.dom.Element;
28import org.w3c.dom.Node;
29import org.w3c.dom.NodeList;
30
31// General Java classes
32import java.io.File;
33import java.util.HashMap;
34import java.util.Vector;
35import java.util.Set;
36import java.util.Map;
37import java.util.Iterator;
38
39
40/**
41 * A ServiceRack class for searching in greenstone 2 MGPP collections
42 *
43 * @author <a href="mailto:[email protected]">Katherine Don</a>
44 * @version $Revision: 4081 $
45 * @see ServiceRack
46 */
47public class GS2MGPPSearch
48 extends GS2Search {
49
50 // extra services offered by mgpp collections
51 private static final String FIELD_QUERY_SERVICE = "FieldQuery";
52 private static final String ADVANCED_FIELD_QUERY_SERVICE = "AdvancedFieldQuery";
53
54 // extra parameters used
55 private static final String LEVEL_PARAM = "level";
56 private static final String RANK_PARAM = "sortBy";
57 private static final String RANK_PARAM_RANK = "1";
58 private static final String RANK_PARAM_NONE = "0";
59 private static final String SIMPLE_FIELD_PARAM = "simpleField";
60 private static final String ADVANCED_FIELD_PARAM = "complexField";
61 // more params for field query
62 private static final String FIELD_QUERY_PARAM = "fqv";
63 private static final String FIELD_STEM_PARAM = "fqs";
64 private static final String FIELD_CASE_PARAM = "fqc";
65 private static final String FIELD_FIELD_PARAM = "fqf";
66 private static final String FIELD_COMBINE_PARAM = "fqk";
67 private static final String FIELD_COMBINE_PARAM_AND = "0";
68 private static final String FIELD_COMBINE_PARAM_OR = "1";
69 private static final String FIELD_COMBINE_PARAM_NOT = "2";
70
71 private static final int TEXT_QUERY = 0;
72 private static final int SIMPLE_QUERY = 1;
73 private static final int ADVANCED_QUERY = 2;
74
75 protected static final String FIELD_ATT = "field";
76 private MGPPWrapper mgpp_src_=null;
77
78 private String default_level_=null;
79
80 /** constructor */
81 public GS2MGPPSearch()
82 {
83 mgpp_src_ = new MGPPWrapper();
84 }
85
86
87 /** configure this service */
88 public boolean configure(Element info, Element extra_info)
89 {
90 // Do generic configuration
91 if (super.configure(info, extra_info) == false)
92 return false;
93
94 // Do specific configuration
95 System.out.println("Configuring GS2MGPPSearch...");
96
97 // Get the default level out of <defaultLevel> (buildConfig.xml)
98 Element def = (Element) GSXML.getChildByTagName(info, DEFAULT_LEVEL_ELEM);
99 if (def != null) {
100 default_level_ = def.getAttribute(GSXML.NAME_ATT);
101 }
102 if (default_level_ == null || default_level_.equals("")) {
103 System.err.println("Error: default level not specified!");
104 return false;
105 }
106
107 // the default level is also the level which gdbm is expecting
108 // this must not be overwritten
109 mgpp_src_.setReturnLevel(default_level_);
110 // return term info
111 mgpp_src_.setReturnTerms(true);
112 // set the default - this may be overwritten by query params
113 mgpp_src_.setQueryLevel(default_level_);
114
115 // set up the extra services which are available for this collection
116 // check the config info - if there is no field list, then there is no fielded searching
117
118 Element field_list = (Element) GSXML.getChildByTagName(info, GSXML.FIELD_ELEM+GSXML.LIST_MODIFIER);
119 if (field_list==null) {
120 // nothing more to do
121 return true;
122 }
123 // else set up the fielded query services
124
125 // set up short_service_info_ - for now just has name and type
126 Element fq_service = doc_.createElement(GSXML.SERVICE_ELEM);
127 fq_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
128 fq_service.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
129 short_service_info_.appendChild(fq_service);
130
131 Element afq_service = doc_.createElement(GSXML.SERVICE_ELEM);
132 afq_service.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
133 afq_service.setAttribute(GSXML.NAME_ATT, ADVANCED_FIELD_QUERY_SERVICE);
134 short_service_info_.appendChild(afq_service);
135
136 // set up service_info_map_ has full details about each service
137 // incl params lists etc.
138 Element fq_service_full = (Element) fq_service.cloneNode(true);
139 Element fq_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
140 createFieldQueryParamList(fq_param_list, false, null);
141 fq_service_full.appendChild(fq_param_list);
142 service_info_map_.put(FIELD_QUERY_SERVICE, fq_service_full);
143
144 Element afq_service_full = (Element) afq_service.cloneNode(true);
145 Element afq_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
146 createAdvancedFieldQueryParamList(afq_param_list, false, null);
147 afq_service_full.appendChild(afq_param_list);
148 service_info_map_.put(ADVANCED_FIELD_QUERY_SERVICE, afq_service_full);
149
150
151 //set up format info - the info is the same as that for text query
152 Element format_info = (Element)format_info_map_.get(TEXT_QUERY_SERVICE);
153 if (format_info != null) {
154 format_info_map_.put(FIELD_QUERY_SERVICE, format_info);
155 format_info_map_.put(ADVANCED_FIELD_QUERY_SERVICE, format_info);
156 }
157 return true;
158 }
159
160
161 /** creates a new param element and adds it to the param list */
162 protected void createParameter(String name, Element param_list, boolean display, String lang) {
163 Element param=null;
164
165 if (name.equals(LEVEL_PARAM)) {
166 // the level info - read from config file
167 Element level_list = (Element)GSXML.getChildByTagName(config_info_, LEVEL_ELEM+GSXML.LIST_MODIFIER);
168 NodeList levels = level_list.getElementsByTagName(LEVEL_ELEM);
169 int len = levels.getLength();
170 if (len > 1) { // add level param to list only if more than one index specified
171 String [] levs = new String[len];
172 String [] lev_names = new String[len];
173 for (int i=0; i<len; i++) {
174 levs[i] = ((Element)levels.item(i)).getAttribute(GSXML.NAME_ATT);
175 if (display) {
176 lev_names[i] = getTextString("level."+levs[i], lang);
177 }
178 }
179 if (display) {
180 param = GSXML.createParameterDisplay(doc_, LEVEL_PARAM, getTextString("param."+LEVEL_PARAM, lang), levs, lev_names);
181 } else {
182 param = GSXML.createParameter(doc_, LEVEL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, default_level_, levs);
183 }
184 }
185 } else if (name.equals(RANK_PARAM)) {
186 String [] vals1 = {RANK_PARAM_RANK, RANK_PARAM_NONE };
187 if (display) {
188 String [] vals1_texts = { getTextString("param."+RANK_PARAM+"."+RANK_PARAM_RANK, lang), getTextString("param."+RANK_PARAM+"."+RANK_PARAM_NONE, lang)};
189
190 param = GSXML.createParameterDisplay(doc_, RANK_PARAM, getTextString("param."+RANK_PARAM, lang), vals1, vals1_texts);
191 } else {
192 param = GSXML.createParameter(doc_, RANK_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, RANK_PARAM_RANK, vals1 );
193 }
194 } else if (name.equals(FIELD_QUERY_PARAM)) {
195 if (display) {
196 param = GSXML.createParameterDisplay(doc_, FIELD_QUERY_PARAM, getTextString("param."+FIELD_QUERY_PARAM, lang), null, null);
197 } else {
198 param = GSXML.createParameter(doc_, FIELD_QUERY_PARAM, GSXML.PARAM_TYPE_STRING, null, null);
199 }
200
201 } else if (name.equals(FIELD_CASE_PARAM)) {
202 if (display) {
203 String[] bool_ops = {"0", "1"};
204 String[] bool_texts = {getTextString("param.boolean.off", lang),getTextString("param.boolean.on", lang)};
205 param = GSXML.createParameterDisplay(doc_, FIELD_CASE_PARAM, getTextString("param."+FIELD_CASE_PARAM, lang), bool_ops, bool_texts);
206
207 } else {
208 param = GSXML.createParameter(doc_, FIELD_CASE_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
209
210 }
211 } else if (name.equals(FIELD_STEM_PARAM)) {
212 if (display) {
213 String[] bool_ops = {"0", "1"};
214 String[] bool_texts = {getTextString("param.boolean.off", lang),getTextString("param.boolean.on", lang)};
215 param = GSXML.createParameterDisplay(doc_, FIELD_STEM_PARAM, getTextString("param."+FIELD_STEM_PARAM, lang), bool_ops, bool_texts);
216 } else {
217 param = GSXML.createParameter(doc_, FIELD_STEM_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
218
219 }
220
221 } else if (name.equals(FIELD_FIELD_PARAM)) {
222
223 // the field list - read from config file
224 Element field_list = (Element)GSXML.getChildByTagName(config_info_, GSXML.FIELD_ELEM+GSXML.LIST_MODIFIER);
225 NodeList fields = field_list.getElementsByTagName(GSXML.FIELD_ELEM);
226 int len = fields.getLength();
227 String [] f_names = new String [len+1];
228 String [] f_texts = new String [len+1];
229
230 f_names[0] = "ZZ";
231 if (display) {
232 f_texts[0] = getTextString("param.fqf.all", lang);
233 }
234 for (int i=0; i< len;i++) {
235 f_names[i+1] = ((Element)fields.item(i)).getAttribute(GSXML.SHORTNAME_ATT);
236 if (display) {
237 // should these be changed to a text element based on lang?
238 // or is the name of a metadata element eg dc:Title its
239 // name in all langs
240 f_texts[i+1] = ((Element)fields.item(i)).getAttribute(GSXML.NAME_ATT);
241 }
242 }
243 if (display) {
244 param = GSXML.createParameterDisplay(doc_, FIELD_FIELD_PARAM, getTextString("param."+FIELD_FIELD_PARAM, lang), f_names, f_texts);
245
246 } else {
247 param = GSXML.createParameter(doc_, FIELD_FIELD_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", f_names );
248
249 }
250 } else if (name.equals(FIELD_COMBINE_PARAM)) {
251
252 String []vals = {FIELD_COMBINE_PARAM_AND, FIELD_COMBINE_PARAM_OR, FIELD_COMBINE_PARAM_NOT};
253 if (display) {
254 String []val_texts = {getTextString("param."+FIELD_COMBINE_PARAM+"."+FIELD_COMBINE_PARAM_AND, lang), getTextString("param."+FIELD_COMBINE_PARAM+"."+FIELD_COMBINE_PARAM_OR, lang), getTextString("param."+FIELD_COMBINE_PARAM+"."+FIELD_COMBINE_PARAM_NOT, lang)};
255
256 param = GSXML.createParameterDisplay(doc_, FIELD_COMBINE_PARAM, "", vals, val_texts);
257
258 } else {
259 param = GSXML.createParameter(doc_, FIELD_COMBINE_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, FIELD_COMBINE_PARAM_AND, vals);
260 param.setAttribute(GSXML.PARAM_IGNORE_POS_ATT, "0");
261
262 }
263 }
264
265 // add the param to the list
266 if (param !=null) {
267 param_list.appendChild(param);
268 }
269 else {
270 super.createParameter(name, param_list, display, lang);
271 }
272 }
273
274
275 /** this creates all teh params and appends them to param_list.
276 * if display=true it creates the text strings version
277 * otherwise it creates the description version
278 */
279 protected boolean createTextQueryParamList(Element param_list,
280 boolean display,
281 String lang)
282 {
283 // the order they are specified here is the order they appear on
284 // the query form
285 createParameter(INDEX_PARAM, param_list, display, lang);
286 createParameter(LEVEL_PARAM, param_list, display, lang);
287 createParameter(CASE_PARAM, param_list, display, lang);
288 createParameter(STEM_PARAM, param_list, display, lang);
289 createParameter(MATCH_PARAM, param_list, display, lang);
290 createParameter(RANK_PARAM, param_list, display, lang);
291 createParameter(MAXDOCS_PARAM, param_list, display, lang);
292 createParameter(QUERY_PARAM, param_list, display, lang);
293
294 return true;
295 }
296
297
298 // for now, the field queries just use the default index.
299 // however, it is entirely possible to create two indexes with different
300 // metadata. then you run into problems with displaying the form - you
301 // need to use javascript to change teh field and maybe level lists
302 // depending on which index is selected, or have the index preselected
303 // before going to the query form
304
305
306 /** this creates all teh params and appends them to param_list.
307 * if display=true it creates the text strings version
308 * otherwise it creates the description version
309 */
310 protected boolean createFieldQueryParamList(Element param_list, boolean display,
311 String lang)
312 {
313 createParameter(LEVEL_PARAM, param_list, display, lang);
314 createParameter(MATCH_PARAM, param_list, display, lang);
315 createParameter(CASE_PARAM, param_list, display, lang);
316 createParameter(STEM_PARAM, param_list, display, lang);
317 createParameter(RANK_PARAM, param_list, display, lang);
318 createParameter(MAXDOCS_PARAM, param_list, display, lang);
319
320 // create a multi param for the fields etc
321 // text box, field
322 Element multiparam = null;
323 Element param=null;
324 if (display) {
325 param = GSXML.createParameterDisplay(doc_, SIMPLE_FIELD_PARAM, "", null, null);
326 param_list.appendChild(param);
327 } else {
328 multiparam = GSXML.createParameter(doc_, SIMPLE_FIELD_PARAM, GSXML.PARAM_TYPE_MULTI, null, null);
329 multiparam.setAttribute("occurs", "4");
330 param_list.appendChild(multiparam);
331 }
332 // the components
333 if (display) {
334 createParameter(FIELD_QUERY_PARAM, param_list, display, lang);
335 createParameter(FIELD_FIELD_PARAM, param_list, display, lang);
336 } else {
337 createParameter(FIELD_QUERY_PARAM, multiparam, display, lang);
338 createParameter(FIELD_FIELD_PARAM, multiparam, display, lang);
339 }
340 return true;
341 }
342
343 protected boolean createAdvancedFieldQueryParamList(Element param_list, boolean display,
344 String lang) {
345
346 // first do index and level params
347 createParameter(LEVEL_PARAM, param_list, display, lang);
348 createParameter(RANK_PARAM, param_list, display, lang);
349 createParameter(MAXDOCS_PARAM, param_list, display, lang);
350
351
352 // create a multi param for the fields etc
353 // text box, stem, case, field
354
355 Element multiparam = null;
356 Element param=null;
357
358 if (display) {
359 param = GSXML.createParameterDisplay(doc_, ADVANCED_FIELD_PARAM, "", null, null);
360 param_list.appendChild(param);
361 } else {
362 multiparam = GSXML.createParameter(doc_, ADVANCED_FIELD_PARAM, GSXML.PARAM_TYPE_MULTI, null, null);
363 multiparam.setAttribute("occurs", "4");
364 param_list.appendChild(multiparam);
365 }
366
367 if (display) {
368 createParameter(FIELD_COMBINE_PARAM, param_list, display, lang);
369 createParameter(FIELD_QUERY_PARAM, param_list, display, lang);
370 createParameter(FIELD_CASE_PARAM, param_list, display, lang);
371 createParameter(FIELD_STEM_PARAM, param_list, display, lang);
372 createParameter(FIELD_FIELD_PARAM, param_list, display, lang);
373 } else {
374 createParameter(FIELD_COMBINE_PARAM, multiparam, display, lang);
375 createParameter(FIELD_QUERY_PARAM, multiparam, display, lang);
376 createParameter(FIELD_CASE_PARAM, multiparam, display, lang);
377 createParameter(FIELD_STEM_PARAM, multiparam, display, lang);
378 createParameter(FIELD_FIELD_PARAM, multiparam, display, lang);
379 }
380
381 return true;
382 }
383
384
385 /** creates a display element containing all the text strings needed to display
386 the service page, in the language specified */
387 protected Element createServiceDisplay(String service, String lang)
388 {
389 // Create a service display for the basic text query service
390 Element display = super.createServiceDisplay(service, lang);
391
392 // Now add MGPP's special services
393 if (service.equals(FIELD_QUERY_SERVICE)) {
394 createFieldQueryParamList(display, true, lang);
395 }
396 if (service.equals(ADVANCED_FIELD_QUERY_SERVICE)) {
397 createAdvancedFieldQueryParamList(display, true, lang);
398 }
399
400 return display;
401 }
402
403 // the following three functions are needed so the base class can
404 // call the process+SERVICE_NAME methods
405 /** process a text query */
406 protected Element processTextQuery(Element request) {
407 return processAnyQuery(request, TEXT_QUERY);
408 }
409
410 /** process a field query */
411 protected Element processFieldQuery(Element request) {
412 return processAnyQuery(request, SIMPLE_QUERY);
413 }
414
415 /** process an advanced field query */
416 protected Element processAdvancedFieldQuery(Element request) {
417 return processAnyQuery(request, ADVANCED_QUERY);
418 }
419
420 /** process a query */
421 protected Element processAnyQuery(Element request, int query_type)
422 {
423
424 String service_name=null;
425 String empty_query_test_param=null;
426 // set up the type specific bits
427 switch (query_type) {
428 case TEXT_QUERY:
429 service_name = TEXT_QUERY_SERVICE;
430 empty_query_test_param = QUERY_PARAM;
431 break;
432 case SIMPLE_QUERY:
433 service_name = FIELD_QUERY_SERVICE;
434 empty_query_test_param = FIELD_QUERY_PARAM;
435 break;
436 case ADVANCED_QUERY:
437 service_name = ADVANCED_FIELD_QUERY_SERVICE;
438 empty_query_test_param = FIELD_QUERY_PARAM;
439 break;
440 default:
441 // should never get here
442 System.err.println("GS2MGPPSearch: wrong query type!!");
443 return null;
444 }
445
446 // Create a new (empty) result message
447 Element result = doc_.createElement(GSXML.RESPONSE_ELEM);
448 result.setAttribute(GSXML.FROM_ATT, service_name);
449 result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
450
451 // Get the parameters of the request
452 Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
453 if (param_list == null) {
454 System.err.println("Error: TextQuery request had no paramList.");
455 return result; // Return the empty result
456 }
457
458 // Process the request parameters
459 HashMap params = GSXML.extractParams(param_list, false);
460
461 // Make sure a query has been specified
462 String query = (String) params.get(empty_query_test_param);
463 if (query == null || query.equals("")) {
464 return result; // Return the empty result
465 }
466
467 // If an index hasn't been specified, use the default
468 String index = (String) params.get(INDEX_PARAM);
469 if (index == null) {
470 index = default_index_;
471 }
472
473 // set up mgpp_src
474 // String basedir = GSFile.collectionBaseDir(site_home_, cluster_name_);
475 // String indexdir = GSFile.collectionIndexPath(cluster_name_, index);
476 String basedir = "";
477 String indexdir = GSFile.collectionBaseDir(site_home_, cluster_name_) +
478 File.separatorChar + GSFile.collectionIndexPath(cluster_name_, index);
479
480 mgpp_src_.loadIndexData(basedir, indexdir);
481 setStandardQueryParams(params);
482
483 // if field search, create the query string
484 switch (query_type) {
485 case SIMPLE_QUERY:
486 query = parseFieldQueryParams(params);
487 break;
488 case ADVANCED_QUERY:
489 query = parseAdvancedFieldQueryParams(params);
490 break;
491 }
492 // run the query
493 mgpp_src_.runQuery(query);
494 MGPPQueryResult mqr= mgpp_src_.getQueryResult();
495
496 // build up the response
497
498 // Create a metadata list to store information about the query results
499 // should we be using metadataList? or something else?
500 Element metadata_list = doc_.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
501 result.appendChild(metadata_list);
502
503 // Add a metadata element specifying the number of matching documents
504 long totalDocs = mqr.getTotalDocs();
505 Element num_matches_elem = doc_.createElement(GSXML.METADATA_ELEM);
506 num_matches_elem.setAttribute(GSXML.NAME_ATT, "numDocsMatched");
507 num_matches_elem.setAttribute(GSXML.VALUE_ATT, "" + totalDocs);
508 metadata_list.appendChild(num_matches_elem);
509
510 // Create a document list to store the matching documents, and add them
511 Vector docs = mqr.getDocs();
512 Element document_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
513 result.appendChild(document_list);
514 for (int d = 0; d < docs.size(); d++) {
515 long docnum = ((MGPPDocInfo) docs.elementAt(d)).num_;
516 String doc_id = gdbm_src_.docnum2Oid(docnum);
517 Element doc_node = createDocumentNodeElement(doc_id);
518 document_list.appendChild(doc_node);
519 }
520
521 // Create a term list to store the term information, and add it
522 String query_level = (String)params.get(LEVEL_PARAM); // the current query level
523 Element term_list = doc_.createElement(GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
524 result.appendChild(term_list);
525 Vector terms = mqr.getTerms();
526 for (int t = 0; t < terms.size(); t++) {
527 MGPPTermInfo term_info = (MGPPTermInfo) terms.get(t);
528
529 Element term_elem = doc_.createElement(GSXML.TERM_ELEM);
530 term_elem.setAttribute(GSXML.NAME_ATT, term_info.term_);
531 term_elem.setAttribute(STEM_ATT, "" + term_info.stem_method_);
532 term_elem.setAttribute(FREQ_ATT, "" + term_info.term_freq_);
533 term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "" + term_info.match_docs_);
534 String field = term_info.tag_;
535 if (field.equals(query_level)) {
536 // ignore
537 field = "";
538 }
539 term_elem.setAttribute(FIELD_ATT, field);
540
541 Vector equiv_terms = term_info.equiv_terms_;
542 Element equiv_term_list = doc_.createElement(EQUIV_TERM_ELEM+GSXML.LIST_MODIFIER);
543 term_elem.appendChild(equiv_term_list);
544
545 for (int et = 0; et < equiv_terms.size(); et++) {
546 String equiv_term = (String) equiv_terms.get(et);
547
548 Element equiv_term_elem = doc_.createElement(GSXML.TERM_ELEM);
549 equiv_term_elem.setAttribute(GSXML.NAME_ATT, equiv_term);
550 equiv_term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "");
551 equiv_term_elem.setAttribute(FREQ_ATT, "");
552 equiv_term_list.appendChild(equiv_term_elem);
553 }
554
555 term_list.appendChild(term_elem);
556 }
557
558 return result;
559 }
560
561 // should probably use a list rather than map
562 protected boolean setStandardQueryParams(HashMap params) {
563
564 Set entries = params.entrySet();
565 Iterator i = entries.iterator();
566 while (i.hasNext()) {
567 Map.Entry m = (Map.Entry)i.next();
568 String name = (String)m.getKey();
569 String value = (String)m.getValue();
570
571 if (name.equals(CASE_PARAM)) {
572 boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
573 mgpp_src_.setCase(val);
574 } else if (name.equals(STEM_PARAM)) {
575 boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
576 mgpp_src_.setStem(val);
577 } else if (name.equals(MAXDOCS_PARAM)) {
578 int docs = Integer.parseInt(value);
579 mgpp_src_.setMaxDocs(docs);
580 } else if (name.equals(LEVEL_PARAM)) {
581 mgpp_src_.setQueryLevel(value);
582 } else if (name.equals(MATCH_PARAM)) {
583 int mode;
584 if (value.equals(MATCH_PARAM_ALL)) mode=1;
585 else mode=0;
586 mgpp_src_.setMatchMode(mode);
587 } else if (name.equals(RANK_PARAM)) {
588 if (value.equals(RANK_PARAM_RANK)) {
589 mgpp_src_.setSortByRank(true);
590 } else if (value.equals(RANK_PARAM_NONE)) {
591 mgpp_src_.setSortByRank(false);
592 }
593 } // ignore any others
594 }
595 return true;
596 }
597
598 /** combines all the field params into a single query
599 * - for simple field query */
600 protected String parseFieldQueryParams(HashMap params) {
601
602 StringBuffer final_query = new StringBuffer(256);
603 String text_line = (String)params.get(FIELD_QUERY_PARAM);
604 String[] texts = text_line.split(",", -1);
605 String field_line = (String)params.get(FIELD_FIELD_PARAM);
606 String[] fields = field_line.split(",", -1);
607 String combine="&";
608 String match = (String)params.get(MATCH_PARAM);
609 if (match.equals(MATCH_PARAM_SOME)) {
610 combine = "|";
611 }
612
613 for (int i=0; i<texts.length; i++) {
614
615 String q = texts[i].trim();
616 if (!q.equals("")) {
617 addQueryElem(final_query, q, fields[i], combine);
618 }
619 }
620
621 return final_query.toString();
622 }
623
624 /** combines all the field params into a single query
625 * - for advanced field query */
626 protected String parseAdvancedFieldQueryParams(HashMap params) {
627
628 StringBuffer final_query = new StringBuffer(256);
629 String text_line = (String)params.get(FIELD_QUERY_PARAM);
630 String[] texts = text_line.split(",", -1);
631 String field_line = (String)params.get(FIELD_FIELD_PARAM);
632 String[] fields = field_line.split(",", -1);
633 String case_line = (String)params.get(FIELD_CASE_PARAM);
634 String[] cases = case_line.split(",", -1);
635 String stem_line = (String)params.get(FIELD_STEM_PARAM);
636 String[] stems = stem_line.split(",", -1);
637 String combine_line = (String)params.get(FIELD_COMBINE_PARAM);
638 String [] combines = combine_line.split(",", -1);
639 String combine = "&";
640 for (int i=0; i<texts.length; i++) {
641 if (i==0) {
642 combine = "";
643 } else {
644 String x = combines[i-1]; // assume first one is missing
645 if (x.equals(FIELD_COMBINE_PARAM_AND)) {
646 combine = "&";
647 } else if (x.equals(FIELD_COMBINE_PARAM_OR)) {
648 combine = "|";
649 } else if (x.equals(FIELD_COMBINE_PARAM_NOT)) {
650 combine = "!";
651 }
652
653 }
654
655 String q = texts[i].trim();
656 if (!q.equals("")) {
657 q = addStemAndCase(q, stems[i], cases[i]);
658 addQueryElem(final_query, q, fields[i], combine);
659 }
660 }
661
662 return final_query.toString();
663 }
664
665 protected void addQueryElem(StringBuffer s, String q, String f, String c) {
666
667 String combine="";
668 if (s.length()>0) {
669 combine = " "+c+" ";
670 }
671 if (f.equals("")||f.equals("ZZ")) {
672 s.append(combine+q);
673 } else {
674 s.append(combine+"["+q+"]:"+f);
675 }
676 }
677
678 protected String addStemAndCase(String q, String s, String c) {
679 String mods = "#";
680 if (c.equals("1")) {
681 mods += "i";
682 } else {
683 mods += "c";
684 }
685 if (s.equals("1")) {
686 mods += "s";
687 } else {
688 mods+= "u";
689 }
690 StringBuffer temp = new StringBuffer();
691 String [] terms = q.split(" ");
692 for (int i=0; i<terms.length; i++) {
693 String t = terms[i].trim();
694
695 if (!t.equals("") && !t.equals("TX")) {
696 temp.append(" "+t+mods);
697 }
698 }
699 return temp.toString();
700 }
701
702
703}
704
705
Note: See TracBrowser for help on using the repository browser.