src/jalview/fts/core/FTSRestClient.java

   1 package jalview.fts.core;
   2
   3 import jalview.fts.api.FTSDataColumnI;
   4 import jalview.fts.api.FTSDataColumnI.FTSDataColumnGroupI;
   5 import jalview.fts.api.FTSRestClientI;
   6 import jalview.util.MessageManager;
   7
   8 import java.io.BufferedReader;
   9 import java.io.IOException;
  10 import java.io.InputStream;
  11 import java.io.InputStreamReader;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Objects;
  15
  16 /**
  17  * Base class providing implementation for common methods defined in
  18  * FTSRestClientI
  19  *
  20  * @author tcnofoegbu
  21  *
  22  * @note implementations MUST be accessed as a singleton.
  23  */
  24 public abstract class FTSRestClient implements FTSRestClientI
  25 {
  26   protected Collection<FTSDataColumnI> dataColumns = new ArrayList<FTSDataColumnI>();
  27
  28   protected Collection<FTSDataColumnGroupI> dataColumnGroups = new ArrayList<FTSDataColumnGroupI>();
  29
  30   protected Collection<FTSDataColumnI> searchableDataColumns = new ArrayList<FTSDataColumnI>();
  31
  32   protected Collection<FTSDataColumnI> defaulDisplayedDataColumns = new ArrayList<FTSDataColumnI>();
  33
  34   protected FTSDataColumnI primaryKeyColumn;
  35
  36   private String primaryKeyColumnCode = null;
  37
  38   private int defaultResponsePageSize = 100;
  39
  40   protected FTSRestClient()
  41   {
  42
  43   }
  44
  45   public void parseDataColumnsConfigFile()
  46   {
  47     String fileName = getColumnDataConfigFileName();
  48
  49     InputStream in = getClass().getResourceAsStream(fileName);
  50
  51     try (BufferedReader br = new BufferedReader(new InputStreamReader(in)))
  52     {
  53       String line;
  54       while ((line = br.readLine()) != null)
  55       {
  56         final String[] lineData = line.split(";");
  57         try
  58         {
  59           if (lineData.length == 2)
  60           {
  61             if (lineData[0].equalsIgnoreCase("_data_column.primary_key"))
  62             {
  63               primaryKeyColumnCode = lineData[1];
  64             }
  65             if (lineData[0]
  66                     .equalsIgnoreCase("_data_column.default_response_page_size"))
  67             {
  68               defaultResponsePageSize = Integer.valueOf(lineData[1]);
  69             }
  70           }
  71           else if (lineData.length == 3)
  72           {
  73             dataColumnGroups.add(new FTSDataColumnGroupI()
  74             {
  75               @Override
  76               public String getID()
  77               {
  78                 return lineData[0];
  79               }
  80
  81               @Override
  82               public String getName()
  83               {
  84                 return lineData[1];
  85               }
  86
  87               @Override
  88               public int getSortOrder()
  89               {
  90                 return Integer.valueOf(lineData[2]);
  91               }
  92
  93               @Override
  94               public String toString()
  95               {
  96                 return lineData[1];
  97               }
  98
  99               @Override
 100               public int hashCode()
 101               {
 102                 return Objects.hash(this.getID(), this.getName(),
 103                         this.getSortOrder());
 104               }
 105
 106               @Override
 107               public boolean equals(Object otherObject)
 108               {
 109                 FTSDataColumnGroupI that = (FTSDataColumnGroupI) otherObject;
 110                 return this.getID().equals(that.getID())
 111                         && this.getName().equals(that.getName())
 112                         && this.getSortOrder() == that.getSortOrder();
 113               }
 114             });
 115           }
 116           else if (lineData.length > 6)
 117           {
 118             FTSDataColumnI dataCol = new FTSDataColumnI()
 119             {
 120               @Override
 121               public String toString()
 122               {
 123                 return lineData[0];
 124               }
 125
 126               @Override
 127               public String getName()
 128               {
 129                 return lineData[0];
 130               }
 131
 132               @Override
 133               public String getCode()
 134               {
 135                 return lineData[1].split("\\|")[0];
 136               }
 137
 138               @Override
 139               public String getAltCode()
 140               {
 141                 return lineData[1].split("\\|").length > 1 ? lineData[1]
 142                         .split("\\|")[1] : getCode();
 143               }
 144
 145               @Override
 146               public DataTypeI getDataType()
 147               {
 148                 final String[] dataTypeString = lineData[2].split("\\|");
 149                 final String classString = dataTypeString[0].toUpperCase();
 150
 151                 return new DataTypeI()
 152                 {
 153
 154                   @Override
 155                   public boolean isFormtted()
 156                   {
 157                     if (dataTypeString.length > 1
 158                             && dataTypeString[1] != null)
 159                     {
 160                       switch (dataTypeString[1].toUpperCase())
 161                       {
 162                       case "T":
 163                       case "TRUE":
 164                         return true;
 165                       case "F":
 166                       case "False":
 167                       default:
 168                         return false;
 169                       }
 170                     }
 171                     return false;
 172                   }
 173
 174                   @Override
 175                   public int getSignificantFigures()
 176                   {
 177                     if (dataTypeString.length > 2
 178                             && dataTypeString[2] != null)
 179                     {
 180                       return Integer.valueOf(dataTypeString[2]);
 181                     }
 182                     return 0;
 183                   }
 184
 185                   @Override
 186                   public Class getDataTypeClass()
 187                   {
 188                     switch (classString)
 189                     {
 190                     case "INT":
 191                     case "INTEGER":
 192                       return Integer.class;
 193                     case "DOUBLE":
 194                       return Double.class;
 195                     case "STRING":
 196                     default:
 197                       return String.class;
 198                     }
 199                   }
 200                 };
 201
 202               }
 203
 204               @Override
 205               public FTSDataColumnGroupI getGroup()
 206               {
 207                 FTSDataColumnGroupI group = null;
 208                 try
 209                 {
 210                   group = getDataColumnGroupById(lineData[3]);
 211                 } catch (Exception e)
 212                 {
 213                   e.printStackTrace();
 214                 }
 215                 return group;
 216               }
 217
 218               @Override
 219               public int getMinWidth()
 220               {
 221                 return Integer.valueOf(lineData[4]);
 222               }
 223
 224               @Override
 225               public int getMaxWidth()
 226               {
 227                 return Integer.valueOf(lineData[5]);
 228               }
 229
 230               @Override
 231               public int getPreferredWidth()
 232               {
 233                 return Integer.valueOf(lineData[6]);
 234               }
 235
 236               @Override
 237               public boolean isPrimaryKeyColumn()
 238               {
 239                 return getName().equalsIgnoreCase(primaryKeyColumnCode)
 240                         || getCode().equalsIgnoreCase(primaryKeyColumnCode);
 241               }
 242
 243               @Override
 244               public boolean isVisibleByDefault()
 245               {
 246                 return Boolean.valueOf(lineData[7]);
 247               }
 248
 249               @Override
 250               public boolean isSearchable()
 251               {
 252                 return Boolean.valueOf(lineData[8]);
 253               }
 254
 255               @Override
 256               public int hashCode()
 257               {
 258                 return Objects.hash(this.getName(), this.getCode(),
 259                         this.getGroup());
 260               }
 261
 262
 263               @Override
 264               public boolean equals(Object otherObject)
 265               {
 266                 FTSDataColumnI that = (FTSDataColumnI) otherObject;
 267                 return this.getCode().equals(that.getCode())
 268                         && this.getName().equals(that.getName())
 269                         && this.getGroup().equals(that.getGroup());
 270               }
 271
 272
 273             };
 274             dataColumns.add(dataCol);
 275
 276             if (dataCol.isSearchable())
 277             {
 278               searchableDataColumns.add(dataCol);
 279             }
 280
 281             if (dataCol.isVisibleByDefault())
 282             {
 283               defaulDisplayedDataColumns.add(dataCol);
 284             }
 285
 286           }
 287           else
 288           {
 289             continue;
 290           }
 291         } catch (Exception e)
 292         {
 293           e.printStackTrace();
 294         }
 295       }
 296       try
 297       {
 298         this.primaryKeyColumn = getDataColumnByNameOrCode(primaryKeyColumnCode);
 299       } catch (Exception e)
 300       {
 301         e.printStackTrace();
 302       }
 303     } catch (IOException e)
 304     {
 305       e.printStackTrace();
 306     }
 307   }
 308
 309   @Override
 310   public int getPrimaryKeyColumIndex(
 311           Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
 312           throws Exception
 313   {
 314
 315     // If a reference sequence is attached then start counting from 1 else
 316     // start from zero
 317     int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
 318
 319     for (FTSDataColumnI field : wantedFields)
 320     {
 321       if (field.isPrimaryKeyColumn())
 322       {
 323         break; // Once PDB Id index is determined exit iteration
 324       }
 325       ++pdbFieldIndexCounter;
 326     }
 327     return pdbFieldIndexCounter;
 328   }
 329
 330   @Override
 331   public String getDataColumnsFieldsAsCommaDelimitedString(
 332           Collection<FTSDataColumnI> dataColumnFields)
 333   {
 334     String result = "";
 335     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 336     {
 337       StringBuilder returnedFields = new StringBuilder();
 338       for (FTSDataColumnI field : dataColumnFields)
 339       {
 340         returnedFields.append(",").append(field.getCode());
 341       }
 342       returnedFields.deleteCharAt(0);
 343       result = returnedFields.toString();
 344     }
 345     return result;
 346   }
 347
 348
 349   @Override
 350   public Collection<FTSDataColumnI> getAllFTSDataColumns()
 351   {
 352     if (dataColumns == null || dataColumns.isEmpty())
 353     {
 354       parseDataColumnsConfigFile();
 355     }
 356     return dataColumns;
 357   }
 358
 359   @Override
 360   public Collection<FTSDataColumnI> getSearchableDataColumns()
 361   {
 362     if (searchableDataColumns == null || searchableDataColumns.isEmpty())
 363     {
 364       parseDataColumnsConfigFile();
 365     }
 366     return searchableDataColumns;
 367   }
 368
 369   @Override
 370   public Collection<FTSDataColumnI> getAllDefaultDisplayedFTSDataColumns()
 371   {
 372     if (defaulDisplayedDataColumns == null
 373             || defaulDisplayedDataColumns.isEmpty())
 374     {
 375       parseDataColumnsConfigFile();
 376     }
 377     return defaulDisplayedDataColumns;
 378   }
 379
 380   @Override
 381   public FTSDataColumnI getPrimaryKeyColumn()
 382   {
 383     if (defaulDisplayedDataColumns == null
 384             || defaulDisplayedDataColumns.isEmpty())
 385     {
 386       parseDataColumnsConfigFile();
 387     }
 388     return primaryKeyColumn;
 389   }
 390
 391   @Override
 392   public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
 393           throws Exception
 394   {
 395     if (dataColumns == null || dataColumns.isEmpty())
 396     {
 397       parseDataColumnsConfigFile();
 398     }
 399     for (FTSDataColumnI column : dataColumns)
 400     {
 401       if (column.getName().equalsIgnoreCase(nameOrCode)
 402               || column.getCode().equalsIgnoreCase(nameOrCode))
 403       {
 404         return column;
 405       }
 406     }
 407     throw new Exception("Couldn't find data column with name : "
 408             + nameOrCode);
 409   }
 410
 411   @Override
 412   public FTSDataColumnGroupI getDataColumnGroupById(String id)
 413           throws Exception
 414   {
 415     if (dataColumns == null || dataColumns.isEmpty())
 416     {
 417       parseDataColumnsConfigFile();
 418     }
 419     for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
 420     {
 421       if (columnGroup.getID().equalsIgnoreCase(id))
 422       {
 423         return columnGroup;
 424       }
 425     }
 426     throw new Exception("Couldn't find data column group with id : " + id);
 427   }
 428
 429   public String getMessageByHTTPStatusCode(int code, String service)
 430   {
 431     String message = "";
 432     switch (code)
 433     {
 434     case 400:
 435       message = MessageManager
 436               .getString("exception.bad_request");
 437       break;
 438
 439     case 410:
 440       message = MessageManager.formatMessage(
 441               "exception.fts_rest_service_no_longer_available", service);
 442       break;
 443     case 403:
 444     case 404:
 445       message = MessageManager.getString("exception.resource_not_be_found");
 446       break;
 447     case 408:
 448     case 409:
 449     case 500:
 450     case 501:
 451     case 502:
 452     case 504:
 453     case 505:
 454       message = MessageManager.formatMessage("exception.fts_server_error",
 455               service);
 456       break;
 457     case 503:
 458       message = MessageManager.getString("exception.service_not_available");
 459       break;
 460     default:
 461       break;
 462     }
 463     return message;
 464   }
 465
 466   protected String getResourceFile(String fileName)
 467   {
 468     String result = "";
 469     try
 470     {
 471       result = getClass().getResource(fileName).getFile();
 472     } catch (Exception e)
 473     {
 474       e.printStackTrace();
 475     }
 476     return result;
 477
 478   }
 479
 480   @Override
 481   public int getDefaultResponsePageSize()
 482   {
 483     if (dataColumns == null || dataColumns.isEmpty())
 484     {
 485       parseDataColumnsConfigFile();
 486     }
 487     return defaultResponsePageSize;
 488   }
 489
 490 }