1 package com.indexdata.mkjsf.pazpar2.commands;
\r
3 import java.util.Arrays;
\r
4 import java.util.List;
\r
6 import javax.enterprise.context.SessionScoped;
\r
7 import javax.inject.Named;
\r
9 import org.apache.log4j.Logger;
\r
11 import com.indexdata.mkjsf.pazpar2.Pz2Service;
\r
12 import com.indexdata.mkjsf.pazpar2.commands.sp.SearchCommandSp;
\r
13 import com.indexdata.mkjsf.pazpar2.commands.sp.ServiceProxyCommand;
\r
14 import com.indexdata.mkjsf.pazpar2.data.ResponseDataObject;
\r
17 * <b><code>search</code></b> Pazpar2 command, referenced as: <code>pzreq.search</code>
\r
19 * @author Niels Erik
\r
22 @SessionScoped @Named
\r
23 public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand {
\r
25 private static final long serialVersionUID = -1888520867838597236L;
\r
26 private static Logger logger = Logger.getLogger(SearchCommand.class);
\r
28 public SearchCommand() {
\r
32 public ResponseDataObject run() {
\r
33 logger.info("Running " + getCommandName());
\r
34 Pz2Service.get().getStateMgr().hasPendingStateChange("search",false);
\r
35 Pz2Service.get().getPzresp().resetSearchAndBeyond();
\r
36 Pz2Service.get().getPzreq().getRecord().removeParametersInState();
\r
37 Pz2Service.get().getPzreq().getShow().setParameterInState(new CommandParameter("start","=",0));
\r
38 Pz2Service.get().getSearchClient().setSearchCommand(this);
\r
43 * Sets the <code>query</code> parameter. See Pazpar2 documentation for details.
\r
45 public void setQuery(String query) {
\r
46 setParameter(new QueryParameter("query","=",query));
\r
49 public void setBooleanOperatorForQuery(String operator) {
\r
50 Pazpar2Command copy = this.copy();
\r
51 ((QueryParameter) getParameter("query")).setBooleanOperator(operator);
\r
56 * Returns the simple part of the <code>query</code> parameter value, excluding parts that
\r
57 * were added as expressions (that is, not set with <code>setQuery()</code>).
\r
59 public String getQuery () {
\r
60 return getParameter("query") == null ? null : ((QueryParameter)getParameter("query")).getSimpleValue();
\r
64 * Returns the complete <code>query</code> parameter value, including expressions.
\r
66 public String getExtendedQuery () {
\r
67 return getParameter("query") == null ? null : ((QueryParameter)getParameter("query")).getValueWithExpressions();
\r
71 * Sets the <code>filter</code> parameter. See Pazpar2 documentation for details.
\r
73 public void setFilter(String compoundExpression) {
\r
74 if (getParameter("filter") != null) removeParameterInState("filter");
\r
75 if (compoundExpression != null && compoundExpression.length()>0) {
\r
76 // Split expression by commas that are not escaped with backslash
\r
77 String[] subExpressions = compoundExpression.split("(?<!\\\\),");
\r
78 for (int i=0; i<subExpressions.length; i++) {
\r
80 setParameterInState(new FilterParameter(new Expression(subExpressions[i])));
\r
82 addExpressionInState("filter",new Expression(subExpressions[i]));
\r
90 * Sets the <code>filter</code> parameter. See Pazpar2 documentation for details.
\r
92 public void setFilter(String field, String operator, String value, String label) {
\r
93 setParameter(new FilterParameter(new Expression(field,operator,value,label)));
\r
97 * Checks if there are any filter expressions matching any of the given expressionFields
\r
98 * @param expressionFields expression fields (left-of-operator entities) to look for
\r
99 * @return true if expression(s) found with any of <code>expressionFields</code>
\r
101 public boolean hasFilterExpression(String... expressionFields) {
\r
102 logger.trace("Checking for filter expression for " + Arrays.deepToString(expressionFields));
\r
103 for (String field : expressionFields) {
\r
104 if (getFilterExpressions(field) != null && getFilterExpressions(field).size()>0) {
\r
105 logger.trace("Filter expression found (" + field + ")");
\r
109 logger.trace("No filter expressions found");
\r
115 * Returns the <code>filter</code> parameter value.
\r
117 public String getFilter() {
\r
118 return getParameter("filter") == null ? null : ((FilterParameter)getParameter("filter")).getValueWithExpressions();
\r
122 * Returns the first filter expression of the given type
\r
123 * @param expressionField expression field (left-of-operator entity) to look for
\r
124 * @return the first filter expression found with the field <code>expressionField</code> or null if none found
\r
126 public Expression getOneFilterExpression(String expressionField) {
\r
127 List<Expression> exprs = getFilterExpressions(expressionField);
\r
128 if (exprs != null && exprs.size()>0) {
\r
129 if (exprs.size()>1) {
\r
130 logger.warn("More that one filter expression found for [" + expressionField + "] but only asked to return the first one");
\r
132 return exprs.get(0);
\r
140 * Returns list of all filter expressions
\r
142 public List<Expression> getFilterExpressions() {
\r
143 return getParameter("filter").getExpressions();
\r
147 public List<Expression> getFilterExpressions(String... expressionFields) {
\r
148 logger.trace("Checking for filter parameter");
\r
149 if (parameters.get("filter")!=null) {
\r
150 logger.trace("Found");
\r
151 return getParameter("filter").getExpressions(expressionFields);
\r
153 logger.trace("Not found");
\r
158 public boolean hasFilter () {
\r
159 return getFilter().length()>0;
\r
163 * Adds a filter expression with a label for display. The filter is added to the end
\r
164 * of an ordered list.
\r
171 public void addFilter(String field, String operator, String value, String label) {
\r
172 if (getParameter("filter") == null) {
\r
173 setFilter(field + operator + value);
\r
175 addExpression("filter",new Expression(field,operator,value,(label != null ? label : value)));
\r
180 * Clears the filter parameter
\r
182 public void removeFilters () {
\r
183 removeParameter("filter");
\r
187 * Removes a filter expression by exact attributes
\r
193 public void removeFilter(String field, String operator, String value) {
\r
194 removeExpression("filter",new Expression(field, operator, value, null));
\r
198 * Removes all filter expressions matching a field listed in <code>fieldsToRemove</code>
\r
199 * @param fieldsToRemove
\r
201 public void removeFilters(String... fieldsToRemove) {
\r
202 removeExpressions("filter",fieldsToRemove);
\r
206 * Removes filter expressions coming after the expression matching the provided filter expression,
\r
207 * if they have a field listed in <code>fieldsToRemove</code>. To be used for bread crumb like UI
\r
213 * @param fieldsToRemove
\r
215 public void removeFiltersAfter(String field, String operator, String value, String... fieldsToRemove) {
\r
216 removeExpressionsAfter("filter",new Expression(field,operator,value,null),fieldsToRemove);
\r
220 * Sets the <code>limit</code> parameter. See Pazpar2 documentation for details.
\r
222 public void setLimit (String compoundExpression) {
\r
223 if (getParameter("limit") != null) removeParameterInState("limit");
\r
224 if (compoundExpression != null && compoundExpression.length()>0) {
\r
225 // Split expression by commas that are not escaped with backslash
\r
226 String[] subExpressions = compoundExpression.split("(?<!\\\\),");
\r
227 for (int i=0; i<subExpressions.length; i++) {
\r
229 setParameterInState(new LimitParameter(new Expression(subExpressions[i])));
\r
231 addExpressionInState("limit",new Expression(subExpressions[i]));
\r
235 checkInState(this);
\r
239 * Sets the <code>limit</code> parameter including a label. See Pazpar2 documentation for details.
\r
241 public void setLimit(String field, String operator, String value, String label) {
\r
242 setParameter(new LimitParameter(new Expression(field,operator,value,label)));
\r
246 * Returns the <code>limit</code> parameter value.
\r
248 public String getLimit () {
\r
249 return getParameter("limit") == null ? null : ((LimitParameter)getParameter("limit")).getValueWithExpressions();
\r
253 * Checks if there are any limit expressions matching any of the given expressionFields
\r
254 * @param expressionFields expression fields (left-of-operator entities) to look for
\r
255 * @return true if expression(s) found with any of <code>expressionFields</code>
\r
257 public boolean hasLimitExpression(String... expressionFields) {
\r
258 logger.trace("Checking for limit expression for " + Arrays.deepToString(expressionFields));
\r
259 for (String field : expressionFields) {
\r
260 if (getLimitExpressions(field) != null && getLimitExpressions(field).size()>0) {
\r
261 logger.trace("Limit expression found (" + field + ")");
\r
265 logger.trace("No limit expressions found");
\r
270 * Returns the first limit expression of the given type
\r
271 * @param expressionField expression field (left-of-operator entity) to look for
\r
272 * @return the first limit expression found with the field <code>expressionField</code> or null if none found
\r
274 public Expression getOneLimitExpression(String expressionField) {
\r
275 List<Expression> exprs = getLimitExpressions(expressionField);
\r
276 if (exprs != null && exprs.size()>0) {
\r
277 if (exprs.size()>1) {
\r
278 logger.warn("More that one limit expression found for [" + expressionField + "] but only asked to return the first one");
\r
280 return exprs.get(0);
\r
287 * Return a list of all current limit expressions
\r
289 public List<Expression> getLimitExpressions() {
\r
290 return getParameter("limit").getExpressions();
\r
294 * Returns a list of limit expressions with fields that matches one of <code>expressionFields</code>
\r
296 * @param expressionFields limit expressions to look for
\r
298 public List<Expression> getLimitExpressions(String... expressionFields) {
\r
299 logger.trace("Checking for limit parameter");
\r
300 if (parameters.get("limit")!=null) {
\r
301 logger.trace("Found");
\r
302 return getParameter("limit").getExpressions(expressionFields);
\r
304 logger.trace("Not found");
\r
310 * Adds a limit expression with a label for display. The limit is added to the end
\r
311 * of an ordered list.
\r
318 public void addLimit(String field, String operator, String value, String label) {
\r
319 if (getParameter("limit") == null) {
\r
320 setLimit(field, operator, value, label);
\r
322 addExpression("limit",new Expression(field,operator,value,label));
\r
327 * Clears the limit parameter
\r
329 public void removeLimits() {
\r
330 removeParameter("limit");
\r
334 * Removes all limit expressions that have fields as listed in <code>fieldsToRemove</code>
\r
335 * @param fieldsToRemove
\r
337 public void removeLimits(String... fieldsToRemove) {
\r
338 removeExpressions("limit",fieldsToRemove);
\r
342 * Removes a limit expression by exact attributes
\r
348 public void removeLimit(String field, String operator, String value) {
\r
349 removeExpression("limit",new Expression(field, operator, value, null));
\r
353 * Removes limit expressions coming after the provided limit expression, if they have a field listed in
\r
354 * <code>fieldsToRemove</code>. To be used for bread crumb like UI controls.
\r
359 * @param fieldsToRemove
\r
361 public void removeLimitsAfter(String field, String operator, String value, String... fieldsToRemove) {
\r
362 removeExpressionsAfter("limit",new Expression(field,operator,value,null),fieldsToRemove);
\r
367 * Sets the <code>startrecs</code> parameter. See Pazpar2 documentation for details.
\r
369 public void setStartrecs (String startrecs) {
\r
370 setParameter(new CommandParameter("startrecs","=",startrecs));
\r
374 * Returns the <code>startrecs</code> parameter value.
\r
376 public String getStartrecs () {
\r
377 return getParameterValue("startrecs");
\r
381 * Sets the <code>maxrecs</code> parameter. See Pazpar2 documentation for details.
\r
383 public void setMaxrecs (String maxrecs) {
\r
384 setParameter(new CommandParameter("maxrecs","=",maxrecs));
\r
388 * Returns the <code>maxrecs</code> parameter value.
\r
390 public String getMaxrecs () {
\r
391 return getParameterValue("maxrecs");
\r
395 * Sets the <code>sort</code> parameter. See Pazpar2 documentation for details.
\r
397 public void setSort (String sort) {
\r
398 setParameter(new CommandParameter("sort","=",sort));
\r
402 * Returns the <code>sort</code> parameter value.
\r
404 public String getSort () {
\r
405 return getParameterValue("sort");
\r
409 * Sets the <code>rank</code> parameter. See Pazpar2 documentation for details.
\r
411 public void setRank (String rank) {
\r
412 setParameter(new CommandParameter("rank","=",rank));
\r
416 * Returns the <code>rank</code> parameter value.
\r
418 public String getRank () {
\r
419 return getParameterValue("rank");
\r
423 * Sets the <code>mergekey</code> parameter. See Pazpar2 documentation for details.
\r
425 public void setMergekey (String mergekey) {
\r
426 setParameter(new CommandParameter("mergekey","=",mergekey));
\r
430 * Returns the <code>mergekey</code> parameter value.
\r
432 public String getMergekey () {
\r
433 return getParameterValue("mergekey");
\r
438 * Adds an expression - for instance a facet criterion, with an optional label - to the query parameter
\r
442 * <li><code>{au}{=}{"Steinbeck, John"}{Steinbeck, John}</code>
\r
445 public void addQueryExpression(String field, String operator, String term, String label) {
\r
446 if (term != null && term.length()>0) {
\r
447 addExpression("query", new Expression(field,operator,term,label));
\r
452 * Removes a query expression - for instance a facet criterion - by its exact attributes
\r
458 public void removeQueryExpression(String field, String operator, String value) {
\r
459 removeExpression("query",new Expression(field, operator, value, null));
\r
464 * Sets a facet to limit the current query by. The
\r
465 * facet is appended to the query string itself (rather
\r
466 * as a separately managed entity. It will thus appear
\r
467 * in a query field as retrieved by getQuery(). It will
\r
468 * not be removed by removeFacet(...)
\r
470 * @param facetKey i.e. 'au' for author
\r
471 * @param term i.e. 'Dickens, Charles'
\r
473 public void setFacetOnQuery (String facetKey, String term) {
\r
474 String facetExpression = facetKey + "=" + term;
\r
475 if (term != null && term.length()>0) {
\r
476 String currentQuery= getQuery();
\r
477 setParameter(new QueryParameter("query","=", currentQuery + " and " + facetExpression));
\r
482 * Removes a facet set by setFacet(...)
\r
484 * Will not remove facets set by setFacetOnQuery(...)
\r
486 * @param facetKey i.e. 'au' for author
\r
487 * @param term i.e. 'Dickens, Charles'
\r
489 public void removeFacet(String facetKey, String term) {
\r
490 if (getParameter("query") != null) {
\r
491 removeExpression("query",new Expression(facetKey,"=",term,null));
\r
495 public SearchCommand copy () {
\r
496 SearchCommand newCommand = new SearchCommand();
\r
497 for (String parameterName : parameters.keySet()) {
\r
498 newCommand.setParameterInState(parameters.get(parameterName).copy());
\r
504 public ServiceProxyCommand getSp() {
\r
505 return new SearchCommandSp(this);
\r
509 public boolean spOnly() {
\r