X-Git-Url: http://lists.indexdata.dk/cgi-bin?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fcom%2Findexdata%2Fmkjsf%2Fpazpar2%2Fcommands%2FSearchCommand.java;h=e36b239c728162585cb085070cb47a81e3c8f7c5;hb=464c86e1706170a0be7be81d239d8c16fad78ec4;hp=f2eb3bef2dd9480332ac625f646fbd29c10794cf;hpb=45780ca51a3f1a967acda7c4d7d71aebe7081a67;p=mkjsf-moved-to-github.git diff --git a/src/main/java/com/indexdata/mkjsf/pazpar2/commands/SearchCommand.java b/src/main/java/com/indexdata/mkjsf/pazpar2/commands/SearchCommand.java index f2eb3be..e36b239 100644 --- a/src/main/java/com/indexdata/mkjsf/pazpar2/commands/SearchCommand.java +++ b/src/main/java/com/indexdata/mkjsf/pazpar2/commands/SearchCommand.java @@ -1,5 +1,8 @@ package com.indexdata.mkjsf.pazpar2.commands; +import java.util.Arrays; +import java.util.List; + import javax.enterprise.context.SessionScoped; import javax.inject.Named; @@ -13,8 +16,7 @@ import com.indexdata.mkjsf.pazpar2.data.ResponseDataObject; public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand { private static final long serialVersionUID = -1888520867838597236L; - private static Logger logger = Logger.getLogger(SearchCommand.class); - private SingleTargetFilter singleTargetFilter = null; + private static Logger logger = Logger.getLogger(SearchCommand.class); public SearchCommand() { super("search"); @@ -29,55 +31,192 @@ public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand Pz2Service.get().getSearchClient().setSearchCommand(this); return super.run(); } - public void setQuery(String query) { - setParameter(new CommandParameter("query","=",query)); + setParameter(new QueryParameter("query","=",query)); + } + + public void setBooleanOperatorForQuery(String operator) { + Pazpar2Command copy = this.copy(); + ((QueryParameter) getParameter("query")).setBooleanOperator(operator); + checkInState(copy); } public String getQuery () { + return getParameter("query") == null ? null : getParameter("query").getSimpleValue(); + } + + public String getExtendedQuery () { return getParameter("query") == null ? null : getParameter("query").getValueWithExpressions(); } public void setFilter(String filterExpression) { - setParameter(new CommandParameter("filter","=",filterExpression)); + if (filterExpression != null && filterExpression.length()>0) { + if (filterExpression.split("[=~]").length==1) { + removeFilters(filterExpression.split("[=~]")[0]); + } else if (filterExpression.split("[=~]").length==2) { + setParameter(new FilterParameter(new Expression(filterExpression))); + } else { + logger.error("Could not parse filter expression [" + filterExpression + "]"); + } + } + } + + public void setFilter(String field, String operator, String value, String label) { + setParameter(new FilterParameter(new Expression(field,operator,value,label))); } + public boolean hasFilterExpression(String... expressionFields) { + logger.trace("Checking for filter expression for " + Arrays.deepToString(expressionFields)); + for (String field : expressionFields) { + if (getFilterExpressions(field) != null && getFilterExpressions(field).size()>0) { + logger.trace("Filter expression found (" + field + ")"); + return true; + } + } + logger.trace("No filter expressions found"); + return false; + } + + public String getFilter() { - return getParameter("filter") == null ? null : getParameter("filter").getValueWithExpressions(); + return getParameter("filter") == null ? null : ((FilterParameter)getParameter("filter")).getValueWithExpressions(); + } + + public Expression getOneFilterExpression(String expressionField) { + List exprs = getFilterExpressions(expressionField); + if (exprs != null && exprs.size()>0) { + if (exprs.size()>1) { + logger.warn("More that one filter expression found for [" + expressionField + "] but only asked to return the first one"); + } + return exprs.get(0); + } else { + return null; + } + } + + + public List getFilterExpressions() { + return getParameter("filter").getExpressions(); + } + + public List getFilterExpressions(String... expressionFields) { + logger.trace("Checking for filter parameter"); + if (parameters.get("filter")!=null) { + logger.trace("Found"); + return getParameter("filter").getExpressions(expressionFields); + } else { + logger.trace("Not found"); + return null; + } + } + + public boolean hasFilter () { + return getFilter().length()>0; } - public void addFilter(String filterExpression) { - // TODO: implement - if (hasParameterValue("filter")) { - setFilter(filterExpression); + public void addFilter(String field, String operator, String value, String label) { + if (getParameter("filter") == null) { + setFilter(field + operator + value); } else { - getParameter("filter"); + addExpression("filter",new Expression(field,operator,value,(label != null ? label : value))); } - throw new UnsupportedOperationException("removeFilter(filterExpression) yet to be implemented."); } public void removeFilters () { removeParameter("filter"); } - public void removeFilter(String filterExpression) { - // TODO: implement - throw new UnsupportedOperationException("removeFilter(filterExpression) yet to be implemented."); + public void removeFilter(String field, String operator, String value) { + removeExpression("filter",new Expression(field, operator, value, null)); + } + + public void removeFilters(String... fieldsToRemove) { + removeExpressions("filter",fieldsToRemove); + } + + public void removeFiltersAfter(String field, String operator, String value, String... fieldsToRemove) { + removeExpressionsAfter("filter",new Expression(field,operator,value,null),fieldsToRemove); } - public boolean hasFilter () { - return getFilter().length()>0; + public void setLimit (String limitExpression) { + if (limitExpression != null && limitExpression.length()>0) { + setParameter(new LimitParameter(new Expression(limitExpression))); + } } - public void setLimit (String limitExpression) { - setParameter(new CommandParameter("limit","=",limitExpression)); + public void setLimit(String field, String operator, String value, String label) { + setParameter(new LimitParameter(new Expression(field,operator,value,label))); } - + public String getLimit () { - return getParameterValue("limit"); + return getParameter("limit") == null ? null : ((FilterParameter)getParameter("limit")).getValueWithExpressions(); } - + + public boolean hasLimitExpression(String... expressionFields) { + logger.trace("Checking for limit expression for " + Arrays.deepToString(expressionFields)); + for (String field : expressionFields) { + if (getLimitExpressions(field) != null && getLimitExpressions(field).size()>0) { + logger.trace("Limit expression found (" + field + ")"); + return true; + } + } + logger.trace("No limit expressions found"); + return false; + } + + public Expression getOneLimitExpression(String expressionField) { + List exprs = getLimitExpressions(expressionField); + if (exprs != null && exprs.size()>0) { + if (exprs.size()>1) { + logger.warn("More that one limit expression found for [" + expressionField + "] but only asked to return the first one"); + } + return exprs.get(0); + } else { + return null; + } + } + + public List getLimitExpressions() { + return getParameter("limit").getExpressions(); + } + + public List getLimitExpressions(String... expressionFields) { + logger.trace("Checking for limit parameter"); + if (parameters.get("limit")!=null) { + logger.trace("Found"); + return getParameter("limit").getExpressions(expressionFields); + } else { + logger.trace("Not found"); + return null; + } + } + + public void addLimit(String field, String operator, String value, String label) { + if (getParameter("limit") == null) { + setLimit(field, operator, value, label); + } else { + addExpression("limit",new Expression(field,operator,value,label)); + } + } + + public void removeLimits() { + removeParameter("limit"); + } + + public void removeLimits(String... fieldsToRemove) { + removeExpressions("limit",fieldsToRemove); + } + + public void removeLimit(String field, String operator, String value) { + removeExpression("limit",new Expression(field, operator, value, null)); + } + + public void removeLimitsAfter(String field, String operator, String value, String... fieldsToRemove) { + removeExpressionsAfter("limit",new Expression(field,operator,value,null),fieldsToRemove); + } + + public void setStartrecs (String startrecs) { setParameter(new CommandParameter("startrecs","=",startrecs)); } @@ -120,15 +259,14 @@ public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand /** - * Sets a facet, in CQL, to restrict the current results, - * then executes the search + * Sets a facet, in CQL, to restrict the current results * * @param facetKey i.e. 'au' for author * @param term i.e. 'Dickens, Charles' */ public void setFacet(String facetKey, String term) { - if (term != null && term.length()>0) { - getParameter("query").addExpression(new Expression(facetKey,"=",term)); + if (term != null && term.length()>0) { + addExpression("query", new Expression(facetKey,"=",term,null)); } } @@ -151,8 +289,7 @@ public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand } /** - * Removes a facet set by setFacet(...), then executes - * the search. + * Removes a facet set by setFacet(...) * * Will not remove facets set by setFacetOnQuery(...) * @@ -161,75 +298,15 @@ public class SearchCommand extends Pazpar2Command implements ServiceProxyCommand */ public void removeFacet(String facetKey, String term) { if (getParameter("query") != null) { - getParameter("query").removeExpression(new Expression(facetKey,"=",term)); + removeExpression("query",new Expression(facetKey,"=",term,null)); } } - - - /** - * Adds a single target filter to restrict the current query by, - * then executes the current search. - * - * This is a special case of the general setFilter function, - * allowing to associate a descriptive target name with the - * filter expression for display in UI. - * - * @param targetId pazpar2's ID for the target to limit by - * @param targetName a descriptive name for the target - */ - public void setSingleTargetFilter (String targetId, String targetName) { - if (hasSingleTargetFilter(new SingleTargetFilter(targetId,targetName))) { - logger.debug("Already using target filter " + this.singleTargetFilter.getFilterExpression()); - } else { - logger.debug("Setting new single target filter for [" + targetName + "]"); - this.singleTargetFilter = new SingleTargetFilter(targetId,targetName); - setParameter(new CommandParameter("filter","=",this.singleTargetFilter.getFilterExpression())); - } - } - - public SingleTargetFilter getSingleTargetFilter () { - logger.debug("request to get the current single target filter " + singleTargetFilter); - return singleTargetFilter; - } - - /** - * Removes the current target filter from the search - * - */ - public String removeSingleTargetFilter () { - logger.debug("Removing target filter " + singleTargetFilter.getFilterExpression()); - this.singleTargetFilter = null; - removeParameter("filter"); - return null; - } - - /** - * - * @return The target filter set on the current search command - */ - public boolean hasSingleTargetFilter() { - logger.debug("Checking if a single target filter is set: " + (singleTargetFilter != null)); - return singleTargetFilter != null; - } - - /** - * Resolves if the current search command has a target filter - to - * be used by the UI for conditional rendering of target filter info. - * - * @return true if the current search command is limited by a target - * filter - */ - protected boolean hasSingleTargetFilter(SingleTargetFilter targetFilter) { - logger.debug("Checking if target filter for [" + targetFilter.getTargetName() + "] is set."); - return hasSingleTargetFilter() && targetFilter.equals(this.singleTargetFilter); - } - + public SearchCommand copy () { SearchCommand newCommand = new SearchCommand(); for (String parameterName : parameters.keySet()) { newCommand.setParameterInState(parameters.get(parameterName).copy()); } - newCommand.singleTargetFilter = this.singleTargetFilter; return newCommand; }