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