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

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

tidied up System.out.prints
  • Property svn:keywords set to Author Date Id Revision
File size: 24.7 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: 3946 $
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.err.println("GS2MGPPSearch: 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
474 mgpp_src_.loadIndexData(basedir, indexdir);
475 setStandardQueryParams(params);
476
477 // if field search, create the query string
478 switch (query_type) {
479 case SIMPLE_QUERY:
480 query = parseFieldQueryParams(params);
481 break;
482 case ADVANCED_QUERY:
483 query = parseAdvancedFieldQueryParams(params);
484 break;
485 }
486 // run the query
487 mgpp_src_.runQuery(query);
488 MGPPQueryResult mqr= mgpp_src_.getQueryResult();
489
490 // build up the response
491
492 // Create a metadata list to store information about the query results
493 // should we be using metadataList? or something else?
494 Element metadata_list = doc_.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
495 result.appendChild(metadata_list);
496
497 // Add a metadata element specifying the number of matching documents
498 long totalDocs = mqr.getTotalDocs();
499 Element num_matches_elem = doc_.createElement(GSXML.METADATA_ELEM);
500 num_matches_elem.setAttribute(GSXML.NAME_ATT, "numDocsMatched");
501 num_matches_elem.setAttribute(GSXML.VALUE_ATT, "" + totalDocs);
502 metadata_list.appendChild(num_matches_elem);
503
504 // Create a document list to store the matching documents, and add them
505 Vector docs = mqr.getDocs();
506 Element document_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
507 result.appendChild(document_list);
508 for (int d = 0; d < docs.size(); d++) {
509 long docnum = ((MGPPDocInfo) docs.elementAt(d)).num_;
510 String doc_id = gdbm_src_.docnum2Oid(docnum);
511 Element doc_node = createDocumentNodeElement(doc_id);
512 document_list.appendChild(doc_node);
513 }
514
515 // Create a term list to store the term information, and add it
516 String query_level = (String)params.get(LEVEL_PARAM); // the current query level
517 Element term_list = doc_.createElement(GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
518 result.appendChild(term_list);
519 Vector terms = mqr.getTerms();
520 for (int t = 0; t < terms.size(); t++) {
521 MGPPTermInfo term_info = (MGPPTermInfo) terms.get(t);
522
523 Element term_elem = doc_.createElement(GSXML.TERM_ELEM);
524 term_elem.setAttribute(GSXML.NAME_ATT, term_info.term_);
525 term_elem.setAttribute(STEM_ATT, "" + term_info.stem_method_);
526 term_elem.setAttribute(FREQ_ATT, "" + term_info.term_freq_);
527 term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "" + term_info.match_docs_);
528 String field = term_info.tag_;
529 if (field.equals(query_level)) {
530 // ignore
531 field = "";
532 }
533 term_elem.setAttribute(FIELD_ATT, field);
534
535 Vector equiv_terms = term_info.equiv_terms_;
536 Element equiv_term_list = doc_.createElement(EQUIV_TERM_ELEM+GSXML.LIST_MODIFIER);
537 term_elem.appendChild(equiv_term_list);
538
539 for (int et = 0; et < equiv_terms.size(); et++) {
540 String equiv_term = (String) equiv_terms.get(et);
541
542 Element equiv_term_elem = doc_.createElement(GSXML.TERM_ELEM);
543 equiv_term_elem.setAttribute(GSXML.NAME_ATT, equiv_term);
544 equiv_term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "");
545 equiv_term_elem.setAttribute(FREQ_ATT, "");
546 equiv_term_list.appendChild(equiv_term_elem);
547 }
548
549 term_list.appendChild(term_elem);
550 }
551
552 return result;
553 }
554
555 // should probably use a list rather than map
556 protected boolean setStandardQueryParams(HashMap params) {
557
558 Set entries = params.entrySet();
559 Iterator i = entries.iterator();
560 while (i.hasNext()) {
561 Map.Entry m = (Map.Entry)i.next();
562 String name = (String)m.getKey();
563 String value = (String)m.getValue();
564
565 if (name.equals(CASE_PARAM)) {
566 boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
567 mgpp_src_.setCase(val);
568 } else if (name.equals(STEM_PARAM)) {
569 boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
570 mgpp_src_.setStem(val);
571 } else if (name.equals(MAXDOCS_PARAM)) {
572 int docs = Integer.parseInt(value);
573 mgpp_src_.setMaxDocs(docs);
574 } else if (name.equals(LEVEL_PARAM)) {
575 mgpp_src_.setQueryLevel(value);
576 } else if (name.equals(MATCH_PARAM)) {
577 int mode;
578 if (value.equals(MATCH_PARAM_ALL)) mode=1;
579 else mode=0;
580 mgpp_src_.setMatchMode(mode);
581 } else if (name.equals(RANK_PARAM)) {
582 if (value.equals(RANK_PARAM_RANK)) {
583 mgpp_src_.setSortByRank(true);
584 } else if (value.equals(RANK_PARAM_NONE)) {
585 mgpp_src_.setSortByRank(false);
586 }
587 } // ignore any others
588 }
589 return true;
590 }
591
592 /** combines all the field params into a single query
593 * - for simple field query */
594 protected String parseFieldQueryParams(HashMap params) {
595
596 StringBuffer final_query = new StringBuffer(256);
597 String text_line = (String)params.get(FIELD_QUERY_PARAM);
598 String[] texts = text_line.split(",", -1);
599 String field_line = (String)params.get(FIELD_FIELD_PARAM);
600 String[] fields = field_line.split(",", -1);
601 String combine="&";
602 String match = (String)params.get(MATCH_PARAM);
603 if (match.equals(MATCH_PARAM_SOME)) {
604 combine = "|";
605 }
606
607 for (int i=0; i<texts.length; i++) {
608
609 String q = texts[i].trim();
610 if (!q.equals("")) {
611 addQueryElem(final_query, q, fields[i], combine);
612 }
613 }
614
615 return final_query.toString();
616 }
617
618 /** combines all the field params into a single query
619 * - for advanced field query */
620 protected String parseAdvancedFieldQueryParams(HashMap params) {
621
622 StringBuffer final_query = new StringBuffer(256);
623 String text_line = (String)params.get(FIELD_QUERY_PARAM);
624 String[] texts = text_line.split(",", -1);
625 String field_line = (String)params.get(FIELD_FIELD_PARAM);
626 String[] fields = field_line.split(",", -1);
627 String case_line = (String)params.get(FIELD_CASE_PARAM);
628 String[] cases = case_line.split(",", -1);
629 String stem_line = (String)params.get(FIELD_STEM_PARAM);
630 String[] stems = stem_line.split(",", -1);
631 String combine_line = (String)params.get(FIELD_COMBINE_PARAM);
632 String [] combines = combine_line.split(",", -1);
633 String combine = "&";
634 for (int i=0; i<texts.length; i++) {
635 if (i==0) {
636 combine = "";
637 } else {
638 String x = combines[i-1]; // assume first one is missing
639 if (x.equals(FIELD_COMBINE_PARAM_AND)) {
640 combine = "&";
641 } else if (x.equals(FIELD_COMBINE_PARAM_OR)) {
642 combine = "|";
643 } else if (x.equals(FIELD_COMBINE_PARAM_NOT)) {
644 combine = "!";
645 }
646
647 }
648
649 String q = texts[i].trim();
650 if (!q.equals("")) {
651 q = addStemAndCase(q, stems[i], cases[i]);
652 addQueryElem(final_query, q, fields[i], combine);
653 }
654 }
655
656 return final_query.toString();
657 }
658
659 protected void addQueryElem(StringBuffer s, String q, String f, String c) {
660
661 String combine="";
662 if (s.length()>0) {
663 combine = " "+c+" ";
664 }
665 if (f!="") {
666 s.append(combine+"["+q+"]:"+f);
667 } else {
668 s.append(combine+q);
669 }
670 }
671
672 protected String addStemAndCase(String q, String s, String c) {
673 String mods = "#";
674 if (c.equals("1")) {
675 mods += "i";
676 } else {
677 mods += "c";
678 }
679 if (s.equals("1")) {
680 mods += "s";
681 } else {
682 mods+= "u";
683 }
684 StringBuffer temp = new StringBuffer();
685 String [] terms = q.split(" ");
686 for (int i=0; i<terms.length; i++) {
687 String t = terms[i].trim();
688
689 if (!t.equals("") && !t.equals("TX")) {
690 temp.append(" "+t+mods);
691 }
692 }
693 return temp.toString();
694 }
695
696
697}
698
699
Note: See TracBrowser for help on using the repository browser.