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

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

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