src/main/java/com/indexdata/pz2utils4jsf/pazpar2/Pz2Session.java

   1 package com.indexdata.pz2utils4jsf.pazpar2;\r
   2 \r
   3 import java.util.ArrayList;\r
   4 import java.util.List;\r
   5 import java.util.Map;\r
   6 import java.util.StringTokenizer;\r
   7 import java.util.concurrent.ConcurrentHashMap;\r
   8 \r
   9 import javax.annotation.PostConstruct;\r
  10 import javax.inject.Inject;\r
  11 \r
  12 import org.apache.log4j.Logger;\r
  13 \r
  14 import com.indexdata.pz2utils4jsf.config.ConfigurationReader;\r
  15 import com.indexdata.pz2utils4jsf.controls.ResultsPager;\r
  16 import com.indexdata.pz2utils4jsf.errors.ConfigurationError;\r
  17 import com.indexdata.pz2utils4jsf.errors.ConfigurationException;\r
  18 import com.indexdata.pz2utils4jsf.errors.ErrorHelper;\r
  19 import com.indexdata.pz2utils4jsf.errors.ErrorInterface;\r
  20 import com.indexdata.pz2utils4jsf.pazpar2.commands.CommandParameter;\r
  21 import com.indexdata.pz2utils4jsf.pazpar2.commands.CommandReadOnly;\r
  22 import com.indexdata.pz2utils4jsf.pazpar2.commands.Pazpar2Command;\r
  23 import com.indexdata.pz2utils4jsf.pazpar2.commands.Pazpar2Commands;\r
  24 import com.indexdata.pz2utils4jsf.pazpar2.data.ByTarget;\r
  25 import com.indexdata.pz2utils4jsf.pazpar2.data.CommandError;\r
  26 import com.indexdata.pz2utils4jsf.pazpar2.data.Pazpar2ResponseData;\r
  27 import com.indexdata.pz2utils4jsf.pazpar2.data.Pazpar2ResponseParser;\r
  28 import com.indexdata.pz2utils4jsf.pazpar2.data.RecordResponse;\r
  29 import com.indexdata.pz2utils4jsf.pazpar2.data.SearchResponse;\r
  30 import com.indexdata.pz2utils4jsf.pazpar2.data.ShowResponse;\r
  31 import com.indexdata.pz2utils4jsf.pazpar2.data.StatResponse;\r
  32 import com.indexdata.pz2utils4jsf.pazpar2.data.TermListsResponse;\r
  33 import com.indexdata.pz2utils4jsf.pazpar2.data.TermResponse;\r
  34 import com.indexdata.pz2utils4jsf.pazpar2.state.StateListener;\r
  35 import com.indexdata.pz2utils4jsf.pazpar2.state.StateManager;\r
  36 import com.indexdata.pz2utils4jsf.utils.Utils;\r
  37 \r
  38 @ForStraightPz2\r
  39 public class Pz2Session implements Pz2Interface, StateListener {\r
  40     \r
  41   private static final long serialVersionUID = 3947514708343320514L;\r
  42   private static Logger logger = Logger.getLogger(Pz2Session.class);\r
  43   \r
  44   protected Map<String,Pazpar2ResponseData> dataObjects = new ConcurrentHashMap<String,Pazpar2ResponseData>();\r
  45   \r
  46   @Inject StateManager stateMgr;\r
  47   @Inject Pazpar2Commands req;\r
  48   \r
  49   protected ErrorHelper errorHelper = null;\r
  50   \r
  51   protected List<ErrorInterface> configurationErrors = null;\r
  52   protected SearchClient searchClient = null;   \r
  53   protected SingleTargetFilter singleTargetFilter = null;  \r
  54   protected ResultsPager pager = null; \r
  55     \r
  56   public Pz2Session () {\r
  57     logger.info("Instantiating pz2 session object [" + Utils.objectId(this) + "]");        \r
  58   }\r
  59   \r
  60   @PostConstruct\r
  61   public void listenToStateManager() {\r
  62     logger.debug("in post-construct of Pz2Session stateMgr is " + stateMgr);\r
  63     logger.debug("in post-construct req is " + req);\r
  64     stateMgr.addStateListener(this);\r
  65   }\r
  66     \r
  67   public void configureClient(SearchClient searchClient, ConfigurationReader configReader) {\r
  68     configurationErrors = new ArrayList<ErrorInterface>();\r
  69     errorHelper = new ErrorHelper(configReader);    \r
  70     logger.debug(Utils.objectId(this) + " will configure search client for the session");\r
  71     try {\r
  72       searchClient.configure(configReader);            \r
  73       // At the time of writing this search client is injected using Weld. \r
  74       // However, the client is used for asynchronously sending off requests\r
  75       // to the server AND propagation of context to threads is currently \r
  76       // not supported. Trying to do so throws a WELD-001303 error. \r
  77       // To avoid that, a context free client is cloned from the context \r
  78       // dependent one. \r
  79       // If propagation to threads gets supported, the cloning can go. \r
  80       this.searchClient = searchClient.cloneMe();         \r
  81     } catch (ConfigurationException e) {\r
  82       configurationErrors.add(new ConfigurationError("Search Client","Configuration",e.getMessage(),new ErrorHelper(configReader)));          \r
  83     } \r
  84     logger.info(configReader.document());\r
  85     resetDataObjects();\r
  86   }\r
  87       \r
  88   public void doSearch(String query) {\r
  89     setCommandParameter("search",new CommandParameter("query","=",query));     \r
  90     doSearch();\r
  91   }\r
  92 \r
  93   public void doSearch() { \r
  94     stateMgr.hasPendingStateChange("search",false);\r
  95     resetDataObjects();\r
  96     removeCommand("record");\r
  97     setCommandParameter("show",new CommandParameter("start","=",0));    \r
  98     logger.debug(Utils.objectId(this) + " is searching using "+req.getCommandReadOnly("search").getUrlEncodedParameterValue("query"));\r
  99     doCommand("search");    \r
 100   }\r
 101       \r
 102   /**\r
 103    * Refreshes 'show', 'stat', 'termlist', and 'bytarget' data object from pazpar2\r
 104    * \r
 105    * @return Number of activeclients at the time of the 'show' command.\r
 106    */\r
 107   public String update () {\r
 108     logger.debug("Updating show,stat,termlist,bytarget from pazpar2");\r
 109     return update("show,stat,termlist,bytarget");\r
 110   }\r
 111    \r
 112   /**\r
 113    * Refreshes the data objects listed in 'commands' from pazpar2\r
 114    * \r
 115    * @param commands\r
 116    * @return Number of activeclients at the time of the 'show' command\r
 117    */\r
 118   public String update (String commands) {\r
 119     if (! hasConfigurationErrors()) {\r
 120       if (hasQuery()) {\r
 121         handleQueryStateChanges(commands);\r
 122         logger.debug("Processing request for " + commands); \r
 123         List<CommandThread> threadList = new ArrayList<CommandThread>();\r
 124         StringTokenizer tokens = new StringTokenizer(commands,",");\r
 125         while (tokens.hasMoreElements()) {          \r
 126           threadList.add(new CommandThread(req.getCommandReadOnly(tokens.nextToken()),searchClient));            \r
 127         }\r
 128         for (CommandThread thread : threadList) {\r
 129           thread.start();\r
 130         }\r
 131         for (CommandThread thread : threadList) {\r
 132           try {\r
 133             thread.join();\r
 134           } catch (InterruptedException e) {\r
 135             e.printStackTrace();\r
 136           }\r
 137         }\r
 138         for (CommandThread thread : threadList) {\r
 139            String commandName = thread.getCommand().getName();\r
 140            String response = thread.getResponse();\r
 141            logger.debug("Response was: " + response);\r
 142            Pazpar2ResponseData responseObject = Pazpar2ResponseParser.getParser().getDataObject(response);\r
 143            dataObjects.put(commandName, responseObject);        \r
 144         }\r
 145         if (commands.equals("record")) {\r
 146           logger.debug("Record: Active clients: "+getRecord().getActiveClients());\r
 147           return getRecord().getActiveClients();\r
 148         } else {\r
 149           return getActiveClients();\r
 150         }  \r
 151       } else {\r
 152         logger.debug("Skipped requests for " + commands + " as there's not yet a query."); \r
 153         resetDataObjects();\r
 154         return "0";\r
 155       }\r
 156     } else {\r
 157       logger.error("Did not attempt to execute query since there are configuration errors.");\r
 158       return "0";\r
 159     }\r
 160     \r
 161   }\r
 162             \r
 163   public void setSingleTargetFilter (String targetId, String targetName) {    \r
 164     if (hasSingleTargetFilter(new SingleTargetFilter(targetId,targetName))) {\r
 165       logger.debug("Already using target filter " + this.singleTargetFilter.getFilterExpression());\r
 166     } else {      \r
 167       this.singleTargetFilter = new SingleTargetFilter(targetId,targetName);\r
 168       setCommandParameter("search",new CommandParameter("filter","=",this.singleTargetFilter.getFilterExpression()));      \r
 169       doSearch();\r
 170     }    \r
 171   }\r
 172 \r
 173   public SingleTargetFilter getSingleTargetFilter () {\r
 174     return singleTargetFilter;\r
 175   }\r
 176     \r
 177   public void removeSingleTargetFilter () {\r
 178     logger.debug("Removing target filter " + singleTargetFilter.getFilterExpression());\r
 179     this.singleTargetFilter = null;\r
 180     removeCommandParameter("search","filter");         \r
 181     doSearch();\r
 182   }\r
 183   \r
 184   public boolean hasSingleTargetFilter() {\r
 185     return singleTargetFilter != null;    \r
 186   }\r
 187                     \r
 188   public String toggleRecord (String recId) {\r
 189     if (hasRecord(recId)) {\r
 190       removeCommand("record");  \r
 191       dataObjects.put("record", new RecordResponse());\r
 192       return "";\r
 193     } else {\r
 194       req.getRecord().setRecordId(recId);\r
 195       return doCommand("record");\r
 196     }\r
 197   }\r
 198   \r
 199   @Override\r
 200   public boolean hasRecord (String recId) {\r
 201     return req.getCommandReadOnly("record").hasParameters() && getRecord().getRecId().equals(recId);\r
 202   }\r
 203       \r
 204   public ShowResponse getShow () {\r
 205     return ((ShowResponse) dataObjects.get("show"));\r
 206   }\r
 207   \r
 208   public StatResponse getStat () {\r
 209     return ((StatResponse) dataObjects.get("stat"));\r
 210   }\r
 211   \r
 212   public RecordResponse getRecord() {\r
 213     return ((RecordResponse) dataObjects.get("record"));\r
 214   }\r
 215   \r
 216   public TermListsResponse getTermLists () {\r
 217     return ((TermListsResponse) dataObjects.get("termlist"));\r
 218   }\r
 219   \r
 220   public List<TermResponse> getFacetTerms (String facet, int count) {\r
 221     return (getTermLists().getTermList(facet).getTerms(count));\r
 222   }\r
 223     \r
 224   public List<TermResponse> getFacetTerms (String facet) {\r
 225     return (getTermLists().getTermList(facet).getTerms());\r
 226   }\r
 227   \r
 228   public ByTarget getByTarget() {\r
 229     return ((ByTarget) dataObjects.get("bytarget"));\r
 230   }\r
 231   \r
 232   \r
 233   public String getCurrentStateKey () {    \r
 234     return stateMgr.getCurrentState().getKey();\r
 235   }\r
 236       \r
 237   public void setCurrentStateKey(String key) {       \r
 238     stateMgr.setCurrentStateKey(key);\r
 239   }\r
 240   \r
 241   public boolean hasConfigurationErrors () {\r
 242       return (configurationErrors.size()>0);      \r
 243   }\r
 244   \r
 245   public boolean hasCommandErrors () {\r
 246     if (dataObjects.get("search").hasApplicationError()) {\r
 247       logger.info("Error detected in search");\r
 248       return true;\r
 249     }\r
 250     for (String name : dataObjects.keySet()) {\r
 251       if (dataObjects.get(name).hasApplicationError()) {\r
 252         logger.info("Error detected in " + name);\r
 253         return true;\r
 254       }\r
 255     }    \r
 256     return false;    \r
 257   }\r
 258   \r
 259   /**\r
 260    * Returns true if application error found in any response data objects \r
 261    */\r
 262   public boolean hasErrors () {\r
 263     return hasConfigurationErrors() || hasCommandErrors();\r
 264   }\r
 265 \r
 266   public List<ErrorInterface> getConfigurationErrors() {    \r
 267     return configurationErrors;\r
 268   }\r
 269   \r
 270   /**\r
 271    * Returns a search command error, if any, otherwise the first\r
 272    * error found for an arbitrary command, if any, otherwise\r
 273    * an empty dummy error. \r
 274    */    \r
 275   public ErrorInterface getCommandError() {\r
 276     CommandError error = new CommandError();    \r
 277     if (dataObjects.get("search").hasApplicationError()) {\r
 278       error = dataObjects.get("search").getApplicationError();                        \r
 279     } else {\r
 280       for (String name : dataObjects.keySet()) {     \r
 281         if (dataObjects.get(name).hasApplicationError()) {     \r
 282           error = dataObjects.get(name).getApplicationError(); \r
 283           break;\r
 284         } \r
 285       }\r
 286     }\r
 287     error.setErrorHelper(errorHelper);\r
 288     return error;         \r
 289   }\r
 290 \r
 291     \r
 292   protected boolean hasSingleTargetFilter(SingleTargetFilter targetFilter) {\r
 293     return hasSingleTargetFilter() && targetFilter.equals(this.singleTargetFilter);\r
 294   }\r
 295   \r
 296   protected boolean hasQuery() {    \r
 297     return req.getSearch().getParameter("query") != null && req.getSearch().getParameter("query").getValueWithExpressions().length()>0;\r
 298   }\r
 299     \r
 300   public boolean hasRecords () {\r
 301     return getStat().getRecords() > 0            \r
 302            && getShow().getHits() != null \r
 303            && getShow().getHits().size()>0;\r
 304   }\r
 305     \r
 306   public ResultsPager getPager () {\r
 307     if (pager == null) {\r
 308       pager = new ResultsPager(this);      \r
 309     } \r
 310     return pager;      \r
 311   }\r
 312   \r
 313   public ResultsPager setPager (int pageRange) {\r
 314     pager =  new ResultsPager(this,pageRange,req);\r
 315     return pager;\r
 316   }\r
 317   \r
 318   protected ErrorHelper getTroubleshooter() {\r
 319     return errorHelper;\r
 320   }\r
 321   \r
 322   protected void handleQueryStateChanges (String commands) {\r
 323     if (stateMgr.hasPendingStateChange("search") && hasQuery()) { \r
 324       logger.debug("Found pending search change. Doing search before updating " + commands);      \r
 325       doSearch();\r
 326     } \r
 327     if (stateMgr.hasPendingStateChange("record") && ! commands.equals("record")) {        \r
 328       logger.debug("Found pending record ID change. Doing record before updating " + commands);\r
 329       stateMgr.hasPendingStateChange("record",false);\r
 330       if (req.getCommandReadOnly("record").hasParameters()) {\r
 331         update("record");\r
 332       } else {\r
 333         removeCommand("record");  \r
 334         dataObjects.put("record", new RecordResponse());\r
 335       }\r
 336     }\r
 337   }\r
 338 \r
 339   protected String getActiveClients() {    \r
 340     if (getShow()!=null) {\r
 341       logger.debug("Active clients: "+getShow().getActiveClients());\r
 342       return getShow().getActiveClients();\r
 343     } else {\r
 344       return "";\r
 345     }\r
 346   }\r
 347 \r
 348   /**\r
 349    * Returns a Pazpar2 command 'detached' from the current Pazpar2 state.\r
 350    * \r
 351    * 'Detached' is meant to imply that this is a copy of a command in the \r
 352    * current state, detached so as to NOT change the current state if \r
 353    * modified. It can be viewed and executed, however. \r
 354    * \r
 355    * In order to modify the command with effect for subsequent searches,\r
 356    * it must be checked back into the StateManager, which will\r
 357    * then create a new current Pazpar2 state as needed.\r
 358    *  \r
 359    * @param name\r
 360    * @return\r
 361    */\r
 362   protected Pazpar2Command getCommand(String name) {\r
 363     return req.getCommand(name);\r
 364   }\r
 365   \r
 366   /** \r
 367    * Returns an interface to a Pazpar2Command with only String getters.\r
 368    * \r
 369    * Since the command cannot be modified (unless it is cast) we can avoid \r
 370    * cloning it before returning it from the current state. \r
 371    * It can be used for log statements, checks and for performing the \r
 372    * actual pazpar2 request. \r
 373    * \r
 374    * @param name\r
 375    * @return\r
 376    */\r
 377   protected CommandReadOnly getCommandReadOnly(String name) {\r
 378     return req.getCommandReadOnly(name);\r
 379   }\r
 380 \r
 381   \r
 382   protected void setCommandParameter(String commandName, CommandParameter parameter) {\r
 383     logger.debug("Setting parameter for " + commandName + ": " + parameter);\r
 384     Pazpar2Command command = req.getCommand(commandName);\r
 385     command.setParameter(parameter);\r
 386     stateMgr.checkIn(command);    \r
 387   }\r
 388   \r
 389   \r
 390   protected void removeCommandParameter(String commandName, String parameterName) {\r
 391     Pazpar2Command command = req.getCommand(commandName);\r
 392     command.removeParameter(parameterName);\r
 393     stateMgr.checkIn(command);    \r
 394   }\r
 395   \r
 396   protected void removeCommand (String commandName) {\r
 397     Pazpar2Command command = req.getCommand(commandName);\r
 398     command.removeParameters();\r
 399     stateMgr.checkIn(command);\r
 400   }\r
 401     \r
 402   protected String getCommandParameterValue (String commandName, String parameterName, String defaultValue) {    \r
 403     CommandReadOnly command = req.getCommandReadOnly(commandName);\r
 404     if (command != null) {\r
 405       String parameter = command.getParameterValue(parameterName);\r
 406       if (parameter != null) {\r
 407         return parameter;\r
 408       }\r
 409     }\r
 410     return defaultValue;    \r
 411   }\r
 412     \r
 413   protected int getCommandParameterValue (String commandName, String parameterName, int defaultValue) {\r
 414     CommandReadOnly command = req.getCommandReadOnly(commandName);\r
 415     if (command != null) {\r
 416       String parameter = command.getParameterValue(parameterName);\r
 417       if (parameter != null) {\r
 418         return Integer.parseInt(parameter);\r
 419       }\r
 420     }\r
 421     return defaultValue;    \r
 422   }\r
 423 \r
 424   protected String doCommand(String commandName) {             \r
 425     logger.debug(req.getCommandReadOnly(commandName).getEncodedQueryString() + ": Results for "+ req.getCommandReadOnly("search").getEncodedQueryString());\r
 426     return update(commandName);\r
 427   }\r
 428   \r
 429   protected void resetDataObjects() {\r
 430     logger.debug("Resetting show,stat,termlist,bytarget,search response objects.");\r
 431     dataObjects = new ConcurrentHashMap<String,Pazpar2ResponseData>();\r
 432     dataObjects.put("show", new ShowResponse());\r
 433     dataObjects.put("stat", new StatResponse());\r
 434     dataObjects.put("termlist", new TermListsResponse());\r
 435     dataObjects.put("bytarget", new ByTarget());\r
 436     dataObjects.put("record", new RecordResponse());\r
 437     dataObjects.put("search", new SearchResponse());\r
 438   }\r
 439   \r
 440   @Override\r
 441   public void setFilter(String filterExpression) {\r
 442     logger.debug("Setting filter to " + filterExpression);\r
 443     setCommandParameter("search",new CommandParameter("filter","=",filterExpression));    \r
 444   }\r
 445   \r
 446   public String getFilter() {\r
 447     return getCommandParameterValue("search", "filter", "");\r
 448   }\r
 449   \r
 450   public boolean hasFilter () {\r
 451     return getFilter().length()>0;\r
 452   }\r
 453 \r
 454   @Override\r
 455   public void stateUpdated(String commandName) {\r
 456     logger.debug("State change reported for [" + commandName + "]");\r
 457     if (commandName.equals("show")) {\r
 458       logger.debug("Updating show");\r
 459       update(commandName);\r
 460     } \r
 461   }\r
 462   \r
 463 }\r