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