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               @Override
 263               public boolean equals(Object otherObject)
 264               {
 265                 FTSDataColumnI that = (FTSDataColumnI) otherObject;
 266                 return this.getCode().equals(that.getCode())
 267                         && this.getName().equals(that.getName())
 268                         && this.getGroup().equals(that.getGroup());
 269               }
 270
 271             };
 272             dataColumns.add(dataCol);
 273
 274             if (dataCol.isSearchable())
 275             {
 276               searchableDataColumns.add(dataCol);
 277             }
 278
 279             if (dataCol.isVisibleByDefault())
 280             {
 281               defaulDisplayedDataColumns.add(dataCol);
 282             }
 283
 284           }
 285           else
 286           {
 287             continue;
 288           }
 289         } catch (Exception e)
 290         {
 291           e.printStackTrace();
 292         }
 293       }
 294       try
 295       {
 296         this.primaryKeyColumn = getDataColumnByNameOrCode(primaryKeyColumnCode);
 297       } catch (Exception e)
 298       {
 299         e.printStackTrace();
 300       }
 301     } catch (IOException e)
 302     {
 303       e.printStackTrace();
 304     }
 305   }
 306
 307   @Override
 308   public int getPrimaryKeyColumIndex(
 309           Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
 310           throws Exception
 311   {
 312
 313     // If a reference sequence is attached then start counting from 1 else
 314     // start from zero
 315     int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
 316
 317     for (FTSDataColumnI field : wantedFields)
 318     {
 319       if (field.isPrimaryKeyColumn())
 320       {
 321         break; // Once PDB Id index is determined exit iteration
 322       }
 323       ++pdbFieldIndexCounter;
 324     }
 325     return pdbFieldIndexCounter;
 326   }
 327
 328   @Override
 329   public String getDataColumnsFieldsAsCommaDelimitedString(
 330           Collection<FTSDataColumnI> dataColumnFields)
 331   {
 332     String result = "";
 333     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 334     {
 335       StringBuilder returnedFields = new StringBuilder();
 336       for (FTSDataColumnI field : dataColumnFields)
 337       {
 338         returnedFields.append(",").append(field.getCode());
 339       }
 340       returnedFields.deleteCharAt(0);
 341       result = returnedFields.toString();
 342     }
 343     return result;
 344   }
 345
 346   @Override
 347   public Collection<FTSDataColumnI> getAllFTSDataColumns()
 348   {
 349     if (dataColumns == null || dataColumns.isEmpty())
 350     {
 351       parseDataColumnsConfigFile();
 352     }
 353     return dataColumns;
 354   }
 355
 356   @Override
 357   public Collection<FTSDataColumnI> getSearchableDataColumns()
 358   {
 359     if (searchableDataColumns == null || searchableDataColumns.isEmpty())
 360     {
 361       parseDataColumnsConfigFile();
 362     }
 363     return searchableDataColumns;
 364   }
 365
 366   @Override
 367   public Collection<FTSDataColumnI> getAllDefaultDisplayedFTSDataColumns()
 368   {
 369     if (defaulDisplayedDataColumns == null
 370             || defaulDisplayedDataColumns.isEmpty())
 371     {
 372       parseDataColumnsConfigFile();
 373     }
 374     return defaulDisplayedDataColumns;
 375   }
 376
 377   @Override
 378   public FTSDataColumnI getPrimaryKeyColumn()
 379   {
 380     if (defaulDisplayedDataColumns == null
 381             || defaulDisplayedDataColumns.isEmpty())
 382     {
 383       parseDataColumnsConfigFile();
 384     }
 385     return primaryKeyColumn;
 386   }
 387
 388   @Override
 389   public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
 390           throws Exception
 391   {
 392     if (dataColumns == null || dataColumns.isEmpty())
 393     {
 394       parseDataColumnsConfigFile();
 395     }
 396     for (FTSDataColumnI column : dataColumns)
 397     {
 398       if (column.getName().equalsIgnoreCase(nameOrCode)
 399               || column.getCode().equalsIgnoreCase(nameOrCode))
 400       {
 401         return column;
 402       }
 403     }
 404     throw new Exception("Couldn't find data column with name : "
 405             + nameOrCode);
 406   }
 407
 408   @Override
 409   public FTSDataColumnGroupI getDataColumnGroupById(String id)
 410           throws Exception
 411   {
 412     if (dataColumns == null || dataColumns.isEmpty())
 413     {
 414       parseDataColumnsConfigFile();
 415     }
 416     for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
 417     {
 418       if (columnGroup.getID().equalsIgnoreCase(id))
 419       {
 420         return columnGroup;
 421       }
 422     }
 423     throw new Exception("Couldn't find data column group with id : " + id);
 424   }
 425
 426   public String getMessageByHTTPStatusCode(int code, String service)
 427   {
 428     String message = "";
 429     switch (code)
 430     {
 431     case 400:
 432       message = MessageManager.getString("exception.bad_request");
 433       break;
 434
 435     case 410:
 436       message = MessageManager.formatMessage(
 437               "exception.fts_rest_service_no_longer_available", service);
 438       break;
 439     case 403:
 440     case 404:
 441       message = MessageManager.getString("exception.resource_not_be_found");
 442       break;
 443     case 408:
 444     case 409:
 445     case 500:
 446     case 501:
 447     case 502:
 448     case 504:
 449     case 505:
 450       message = MessageManager.formatMessage("exception.fts_server_error",
 451               service);
 452       break;
 453     case 503:
 454       message = MessageManager.getString("exception.service_not_available");
 455       break;
 456     default:
 457       break;
 458     }
 459     return message;
 460   }
 461
 462   protected String getResourceFile(String fileName)
 463   {
 464     String result = "";
 465     try
 466     {
 467       result = getClass().getResource(fileName).getFile();
 468     } catch (Exception e)
 469     {
 470       e.printStackTrace();
 471     }
 472     return result;
 473
 474   }
 475
 476   @Override
 477   public int getDefaultResponsePageSize()
 478   {
 479     if (dataColumns == null || dataColumns.isEmpty())
 480     {
 481       parseDataColumnsConfigFile();
 482     }
 483     return defaultResponsePageSize;
 484   }
 485
 486 }