src/jalview/fts/service/pdb/PDBFTSRestClient.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.fts.service.pdb;
  22
  23 import java.net.URI;
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Objects;
  30
  31 import javax.ws.rs.core.MediaType;
  32
  33 import org.json.simple.parser.ParseException;
  34
  35 import com.sun.jersey.api.client.Client;
  36 import com.sun.jersey.api.client.ClientResponse;
  37 import com.sun.jersey.api.client.WebResource;
  38 import com.sun.jersey.api.client.config.DefaultClientConfig;
  39
  40 import jalview.datamodel.SequenceI;
  41 import jalview.fts.api.FTSData;
  42 import jalview.fts.api.FTSDataColumnI;
  43 import jalview.fts.api.FTSRestClientI;
  44 import jalview.fts.api.StructureFTSRestClientI;
  45 import jalview.fts.core.FTSDataColumnPreferences;
  46 import jalview.fts.core.FTSDataColumnPreferences.PreferenceSource;
  47 import jalview.fts.core.FTSRestClient;
  48 import jalview.fts.core.FTSRestRequest;
  49 import jalview.fts.core.FTSRestResponse;
  50 import jalview.fts.service.alphafold.AlphafoldRestClient;
  51 import jalview.util.JSONUtils;
  52 import jalview.util.MessageManager;
  53 import jalview.util.Platform;
  54
  55 /**
  56  * A rest client for querying the Search endpoint of the PDB API
  57  *
  58  * @author tcnofoegbu
  59  */
  60 public class PDBFTSRestClient extends FTSRestClient implements StructureFTSRestClientI
  61 {
  62
  63   private static FTSRestClientI instance = null;
  64
  65   public static final String PDB_SEARCH_ENDPOINT = "https://www.ebi.ac.uk/pdbe/search/pdb/select?";
  66
  67   protected PDBFTSRestClient()
  68   {
  69   }
  70
  71   /**
  72    * Takes a PDBRestRequest object and returns a response upon execution
  73    *
  74    * @param pdbRestRequest
  75    *          the PDBRestRequest instance to be processed
  76    * @return the pdbResponse object for the given request
  77    * @throws Exception
  78    */
  79   @SuppressWarnings({ "unused", "unchecked" })
  80   @Override
  81   public FTSRestResponse executeRequest(FTSRestRequest pdbRestRequest)
  82           throws Exception
  83   {
  84     try
  85     {
  86       String wantedFields = getDataColumnsFieldsAsCommaDelimitedString(
  87               pdbRestRequest.getWantedFields());
  88       int responseSize = (pdbRestRequest.getResponseSize() == 0)
  89               ? getDefaultResponsePageSize()
  90               : pdbRestRequest.getResponseSize();
  91       int offSet = pdbRestRequest.getOffSet();
  92       String sortParam = null;
  93       if (pdbRestRequest.getFieldToSortBy() == null
  94               || pdbRestRequest.getFieldToSortBy().trim().isEmpty())
  95       {
  96         sortParam = "";
  97       }
  98       else
  99       {
 100         if (pdbRestRequest.getFieldToSortBy()
 101                 .equalsIgnoreCase("Resolution"))
 102         {
 103           sortParam = pdbRestRequest.getFieldToSortBy()
 104                   + (pdbRestRequest.isAscending() ? " asc" : " desc");
 105         }
 106         else
 107         {
 108           sortParam = pdbRestRequest.getFieldToSortBy()
 109                   + (pdbRestRequest.isAscending() ? " desc" : " asc");
 110         }
 111       }
 112
 113       String facetPivot = (pdbRestRequest.getFacetPivot() == null
 114               || pdbRestRequest.getFacetPivot().isEmpty()) ? ""
 115                       : pdbRestRequest.getFacetPivot();
 116       String facetPivotMinCount = String
 117               .valueOf(pdbRestRequest.getFacetPivotMinCount());
 118
 119       String query = pdbRestRequest.getFieldToSearchBy()
 120               + pdbRestRequest.getSearchTerm()
 121               + (pdbRestRequest.isAllowEmptySeq() ? ""
 122                       : " AND molecule_sequence:['' TO *]")
 123               + (pdbRestRequest.isAllowUnpublishedEntries() ? ""
 124                       : " AND status:REL");
 125
 126       // Build request parameters for the REST Request
 127
 128       // BH 2018 the trick here is to coerce the classes in Javascript to be
 129       // different from the ones in Java yet still allow this to be correct for Java
 130       Client client;
 131       Class<ClientResponse> clientResponseClass;
 132       if (Platform.isJS())
 133       {
 134         // JavaScript only -- coerce types to Java types for Java
 135         client = (Client) (Object) new jalview.javascript.web.Client();
 136         clientResponseClass = (Class<ClientResponse>) (Object) jalview.javascript.web.ClientResponse.class;
 137       }
 138       else
 139       /**
 140        * Java only
 141        *
 142        * @j2sIgnore
 143        */
 144       {
 145         client = Client.create(new DefaultClientConfig());
 146         clientResponseClass = ClientResponse.class;
 147       }
 148
 149       WebResource webResource;
 150       if (pdbRestRequest.isFacet())
 151       {
 152         webResource = client.resource(PDB_SEARCH_ENDPOINT)
 153                 .queryParam("wt", "json").queryParam("fl", wantedFields)
 154                 .queryParam("rows", String.valueOf(responseSize))
 155                 .queryParam("q", query)
 156                 .queryParam("start", String.valueOf(offSet))
 157                 .queryParam("sort", sortParam).queryParam("facet", "true")
 158                 .queryParam("facet.pivot", facetPivot)
 159                 .queryParam("facet.pivot.mincount", facetPivotMinCount);
 160       }
 161       else
 162       {
 163         webResource = client.resource(PDB_SEARCH_ENDPOINT)
 164                 .queryParam("wt", "json").queryParam("fl", wantedFields)
 165                 .queryParam("rows", String.valueOf(responseSize))
 166                 .queryParam("start", String.valueOf(offSet))
 167                 .queryParam("q", query).queryParam("sort", sortParam);
 168       }
 169
 170       URI uri = webResource.getURI();
 171
 172       System.out.println(uri);
 173
 174       // Execute the REST request
 175       ClientResponse clientResponse = webResource
 176               .accept(MediaType.APPLICATION_JSON).get(clientResponseClass );
 177
 178       // Get the JSON string from the response object or directly from the
 179       // client (JavaScript)
 180       Map<String, Object> jsonObj = null;
 181       String responseString = null;
 182
 183       System.out.println("query >>>>>>> " + pdbRestRequest.toString());
 184
 185       // Check the response status and report exception if one occurs
 186       int responseStatus = clientResponse.getStatus();
 187       switch (responseStatus)
 188       {
 189       case 200:
 190         if (Platform.isJS())
 191         {
 192           jsonObj = clientResponse.getEntity(Map.class);
 193         }
 194         else
 195         {
 196           responseString = clientResponse.getEntity(String.class);
 197         }
 198         break;
 199       case 400:
 200         throw new Exception(parseJsonExceptionString(responseString));
 201       default:
 202         throw new Exception(
 203                 getMessageByHTTPStatusCode(responseStatus, "PDB"));
 204       }
 205
 206       // Process the response and return the result to the caller.
 207       return parsePDBJsonResponse(responseString, jsonObj, pdbRestRequest);
 208     } catch (Exception e)
 209     {
 210       String exceptionMsg = e.getMessage();
 211       if (exceptionMsg.contains("SocketException"))
 212       {
 213         // No internet connection
 214         throw new Exception(MessageManager.getString(
 215                 "exception.unable_to_detect_internet_connection"));
 216       }
 217       else if (exceptionMsg.contains("UnknownHostException"))
 218       {
 219         // The server 'www.ebi.ac.uk' is unreachable
 220         throw new Exception(MessageManager.formatMessage(
 221                 "exception.fts_server_unreachable", "PDB Solr"));
 222       }
 223       else
 224       {
 225         throw e;
 226       }
 227     }
 228   }
 229
 230   /**
 231    * Process error response from PDB server if/when one occurs.
 232    *
 233    * @param jsonResponse
 234    *          the JSON string containing error message from the server
 235    * @return the processed error message from the JSON string
 236    */
 237   @SuppressWarnings("unchecked")
 238 public static String parseJsonExceptionString(String jsonErrorResponse)
 239   {
 240     StringBuilder errorMessage = new StringBuilder(
 241             "\n============= PDB Rest Client RunTime error =============\n");
 242
 243
 244 //    {
 245 //      "responseHeader":{
 246 //        "status":0,
 247 //        "QTime":0,
 248 //        "params":{
 249 //          "q":"(text:q93xj9_soltu) AND molecule_sequence:['' TO *] AND status:REL",
 250 //          "fl":"pdb_id,title,experimental_method,resolution",
 251 //          "start":"0",
 252 //          "sort":"overall_quality desc",
 253 //          "rows":"500",
 254 //          "wt":"json"}},
 255 //      "response":{"numFound":1,"start":0,"docs":[
 256 //          {
 257 //            "experimental_method":["X-ray diffraction"],
 258 //            "pdb_id":"4zhp",
 259 //            "resolution":2.46,
 260 //            "title":"The crystal structure of Potato ferredoxin I with 2Fe-2S cluster"}]
 261 //      }}
 262 //
 263     try
 264     {
 265       Map<String, Object> jsonObj = (Map<String, Object>) JSONUtils.parse(jsonErrorResponse);
 266       Map<String, Object> errorResponse = (Map<String, Object>) jsonObj.get("error");
 267
 268       Map<String, Object> responseHeader = (Map<String, Object>) jsonObj
 269               .get("responseHeader");
 270       Map<String, Object> paramsObj = (Map<String, Object>) responseHeader.get("params");
 271       String status = responseHeader.get("status").toString();
 272       String message = errorResponse.get("msg").toString();
 273       String query = paramsObj.get("q").toString();
 274       String fl = paramsObj.get("fl").toString();
 275
 276       errorMessage.append("Status: ").append(status).append("\n");
 277       errorMessage.append("Message: ").append(message).append("\n");
 278       errorMessage.append("query: ").append(query).append("\n");
 279       errorMessage.append("fl: ").append(fl).append("\n");
 280
 281     } catch (ParseException e)
 282     {
 283       e.printStackTrace();
 284     }
 285     return errorMessage.toString();
 286   }
 287
 288   /**
 289    * Parses the JSON response string from PDB REST API. The response is dynamic
 290    * hence, only fields specifically requested for in the 'wantedFields'
 291    * parameter is fetched/processed
 292    *
 293    * @param pdbJsonResponseString
 294    *          the JSON string to be parsed
 295    * @param pdbRestRequest
 296    *          the request object which contains parameters used to process the
 297    *          JSON string
 298    * @return
 299    */
 300   public static FTSRestResponse parsePDBJsonResponse(
 301           String pdbJsonResponseString, FTSRestRequest pdbRestRequest)
 302   {
 303     return parsePDBJsonResponse(pdbJsonResponseString,
 304             (Map<String, Object>) null, pdbRestRequest);
 305   }
 306
 307   @SuppressWarnings("unchecked")
 308   public static FTSRestResponse parsePDBJsonResponse(
 309           String pdbJsonResponseString, Map<String, Object> jsonObj,
 310           FTSRestRequest pdbRestRequest)
 311   {
 312     FTSRestResponse searchResult = new FTSRestResponse();
 313     List<FTSData> result = null;
 314     try
 315     {
 316       if (jsonObj == null)
 317       {
 318         jsonObj = (Map<String, Object>) JSONUtils.parse(pdbJsonResponseString);
 319       }
 320       Map<String, Object> pdbResponse = (Map<String, Object>) jsonObj.get("response");
 321       String queryTime = ((Map<String, Object>) jsonObj.get("responseHeader"))
 322               .get("QTime").toString();
 323       int numFound = Integer
 324               .valueOf(pdbResponse.get("numFound").toString());
 325       List<Object> docs = (List<Object>) pdbResponse.get("docs");
 326       // add in any alphafold bits at the top
 327       result = AlphafoldRestClient.getFTSData(pdbRestRequest);
 328       if (numFound > 0)
 329       {
 330
 331         for (Iterator<Object> docIter = docs.iterator(); docIter
 332                 .hasNext();)
 333         {
 334           Map<String, Object> doc = (Map<String, Object>) docIter.next();
 335           result.add(getFTSData(doc, pdbRestRequest));
 336         }
 337       }
 338       searchResult.setNumberOfItemsFound(result.size());
 339       searchResult.setResponseTime(queryTime);
 340       searchResult.setSearchSummary(result);
 341
 342     } catch (ParseException e)
 343     {
 344       e.printStackTrace();
 345     }
 346     return searchResult;
 347   }
 348
 349   public static FTSData getFTSData(Map<String, Object> pdbJsonDoc,
 350           FTSRestRequest request)
 351   {
 352
 353     String primaryKey = null;
 354
 355     Object[] summaryRowData;
 356
 357     SequenceI associatedSequence;
 358
 359     Collection<FTSDataColumnI> diplayFields = request.getWantedFields();
 360     SequenceI associatedSeq = request.getAssociatedSequence();
 361     int colCounter = 0;
 362     summaryRowData = new Object[(associatedSeq != null)
 363             ? diplayFields.size() + 1
 364             : diplayFields.size()];
 365     if (associatedSeq != null)
 366     {
 367       associatedSequence = associatedSeq;
 368       summaryRowData[0] = associatedSequence;
 369       colCounter = 1;
 370     }
 371
 372     for (FTSDataColumnI field : diplayFields)
 373     {
 374       //System.out.println("Field " + field);
 375       String fieldData = (pdbJsonDoc.get(field.getCode()) == null) ? ""
 376               : pdbJsonDoc.get(field.getCode()).toString();
 377       //System.out.println("Field Data : " + fieldData);
 378       if (field.isPrimaryKeyColumn())
 379       {
 380         primaryKey = fieldData;
 381         summaryRowData[colCounter++] = primaryKey;
 382       }
 383       else if (fieldData == null || fieldData.isEmpty())
 384       {
 385         summaryRowData[colCounter++] = null;
 386       }
 387       else
 388       {
 389         try
 390         {
 391           summaryRowData[colCounter++] = (field.getDataType()
 392                   .getDataTypeClass() == Integer.class)
 393                           ? Integer.valueOf(fieldData)
 394                           : (field.getDataType()
 395                                   .getDataTypeClass() == Double.class)
 396                                           ? Double.valueOf(fieldData)
 397                                           : sanitiseData(fieldData);
 398         } catch (Exception e)
 399         {
 400           e.printStackTrace();
 401           System.out.println("offending value:" + fieldData);
 402         }
 403       }
 404     }
 405
 406     final String primaryKey1 = primaryKey;
 407
 408     final Object[] summaryRowData1 = summaryRowData;
 409     return new FTSData()
 410     {
 411       @Override
 412       public Object[] getSummaryData()
 413       {
 414         return summaryRowData1;
 415       }
 416
 417       @Override
 418       public Object getPrimaryKey()
 419       {
 420         return primaryKey1;
 421       }
 422
 423       /**
 424        * Returns a string representation of this object;
 425        */
 426       @Override
 427       public String toString()
 428       {
 429         StringBuilder summaryFieldValues = new StringBuilder();
 430         for (Object summaryField : summaryRowData1)
 431         {
 432           summaryFieldValues.append(
 433                   summaryField == null ? " " : summaryField.toString())
 434                   .append("\t");
 435         }
 436         return summaryFieldValues.toString();
 437       }
 438
 439       /**
 440        * Returns hash code value for this object
 441        */
 442       @Override
 443       public int hashCode()
 444       {
 445         return Objects.hash(primaryKey1, this.toString());
 446       }
 447
 448       @Override
 449       public boolean equals(Object that)
 450       {
 451         return this.toString().equals(that.toString());
 452       }
 453     };
 454   }
 455
 456   private static String sanitiseData(String data)
 457   {
 458     String cleanData = data.replaceAll("\\[\"", "").replaceAll("\\]\"", "")
 459             .replaceAll("\\[", "").replaceAll("\\]", "")
 460             .replaceAll("\",\"", ", ").replaceAll("\"", "");
 461     return cleanData;
 462   }
 463
 464   @Override
 465   public String getColumnDataConfigFileName()
 466   {
 467     return "/fts/pdb_data_columns.txt";
 468   }
 469
 470   public static FTSRestClientI getInstance()
 471   {
 472     if (instance == null)
 473     {
 474       instance = new PDBFTSRestClient();
 475     }
 476     return instance;
 477   }
 478
 479   private Collection<FTSDataColumnI> allDefaultDisplayedStructureDataColumns;
 480   @Override
 481   public Collection<FTSDataColumnI> getAllDefaultDisplayedStructureDataColumns()
 482   {
 483     if (allDefaultDisplayedStructureDataColumns == null
 484             || allDefaultDisplayedStructureDataColumns.isEmpty())
 485     {
 486       allDefaultDisplayedStructureDataColumns = new ArrayList<>();
 487       allDefaultDisplayedStructureDataColumns
 488               .addAll(super.getAllDefaultDisplayedFTSDataColumns());
 489     }
 490     return allDefaultDisplayedStructureDataColumns;
 491   }
 492   @Override
 493   public String[] getPreferencesColumnsFor(PreferenceSource source) {
 494     String[] columnNames = null;
 495     switch (source)
 496     {
 497     case SEARCH_SUMMARY:
 498       columnNames = new String[] { "", "Display", "Group" };
 499       break;
 500     case STRUCTURE_CHOOSER:
 501       columnNames = new String[] { "", "Display", "Group" };
 502       break;
 503     case PREFERENCES:
 504       columnNames = new String[] { "PDB Field", "Show in search summary",
 505           "Show in structure summary" };
 506       break;
 507     default:
 508       break;
 509     }
 510     return columnNames;
 511   }
 512 }