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     } catch (IOException e)
 243     {
 244       e.printStackTrace();
 245     }
 246   }
 247
 248   @Override
 249   public int getPrimaryKeyColumIndex(
 250           Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
 251           throws Exception
 252   {
 253
 254     // If a reference sequence is attached then start counting from 1 else
 255     // start from zero
 256     int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
 257
 258     for (FTSDataColumnI field : wantedFields)
 259     {
 260       if (field.isPrimaryKeyColumn())
 261       {
 262         break; // Once PDB Id index is determined exit iteration
 263       }
 264       ++pdbFieldIndexCounter;
 265     }
 266     return pdbFieldIndexCounter;
 267   }
 268
 269   @Override
 270   public String getDataColumnsFieldsAsCommaDelimitedString(
 271           Collection<FTSDataColumnI> dataColumnFields)
 272   {
 273     String result = "";
 274     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 275     {
 276       StringBuilder returnedFields = new StringBuilder();
 277       for (FTSDataColumnI field : dataColumnFields)
 278       {
 279         returnedFields.append(",").append(field.getCode());
 280       }
 281       returnedFields.deleteCharAt(0);
 282       result = returnedFields.toString();
 283     }
 284     return result;
 285   }
 286
 287   /**
 288    * Takes a collection of FTSDataColumnI and converts its 'code' values into a
 289    * tab delimited string.
 290    *
 291    * @param dataColumnFields
 292    *          the collection of FTSDataColumnI to process
 293    * @return the generated comma delimited string from the supplied
 294    *         FTSDataColumnI collection
 295    */
 296   public String getDataColumnsFieldsAsTabDelimitedString(
 297           Collection<FTSDataColumnI> dataColumnFields)
 298   {
 299     String result = "";
 300     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 301     {
 302       StringBuilder returnedFields = new StringBuilder();
 303       for (FTSDataColumnI field : dataColumnFields)
 304       {
 305         returnedFields.append("\t").append(field.getName());
 306       }
 307       returnedFields.deleteCharAt(0);
 308       result = returnedFields.toString();
 309     }
 310     return result;
 311   }
 312
 313   @Override
 314   public Collection<FTSDataColumnI> getAllFTSDataColumns()
 315   {
 316     if (dataColumns == null || dataColumns.isEmpty())
 317     {
 318       parseDataColumnsConfigFile();
 319     }
 320     return dataColumns;
 321   }
 322
 323   @Override
 324   public Collection<FTSDataColumnI> getSearchableDataColumns()
 325   {
 326     if (searchableDataColumns == null || searchableDataColumns.isEmpty())
 327     {
 328       parseDataColumnsConfigFile();
 329     }
 330     return searchableDataColumns;
 331   }
 332
 333   @Override
 334   public Collection<FTSDataColumnI> getAllDefaulDisplayedDataColumns()
 335   {
 336     if (defaulDisplayedDataColumns == null
 337             || defaulDisplayedDataColumns.isEmpty())
 338     {
 339       parseDataColumnsConfigFile();
 340     }
 341     return defaulDisplayedDataColumns;
 342   }
 343
 344   @Override
 345   public FTSDataColumnI getPrimaryKeyColumn()
 346   {
 347     return primaryKeyColumn;
 348   }
 349
 350   @Override
 351   public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
 352           throws Exception
 353   {
 354     if (dataColumns == null || dataColumns.isEmpty())
 355     {
 356       parseDataColumnsConfigFile();
 357     }
 358     for (FTSDataColumnI column : dataColumns)
 359     {
 360       if (column.getName().equalsIgnoreCase(nameOrCode)
 361               || column.getCode().equalsIgnoreCase(nameOrCode))
 362       {
 363         return column;
 364       }
 365     }
 366     throw new Exception("Couldn't find data column with name : "
 367             + nameOrCode);
 368   }
 369
 370   @Override
 371   public FTSDataColumnGroupI getDataColumnGroupById(String id)
 372           throws Exception
 373   {
 374     if (dataColumns == null || dataColumns.isEmpty())
 375     {
 376       parseDataColumnsConfigFile();
 377     }
 378     for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
 379     {
 380       if (columnGroup.getID().equalsIgnoreCase(id))
 381       {
 382         return columnGroup;
 383       }
 384     }
 385     throw new Exception("Couldn't find data column group with id : " + id);
 386   }
 387
 388   protected String getResourceFile(String fileName)
 389   {
 390     ClassLoader classLoader = getClass().getClassLoader();
 391     String result = "";
 392     try
 393     {
 394       result = classLoader.getResource(fileName).getFile();
 395     } catch (Exception e)
 396     {
 397       e.printStackTrace();
 398     }
 399     return result;
 400
 401   }
 402
 403   @Override
 404   public int getDefaultResponsePageSize()
 405   {
 406     return defaultResponsePageSize;
 407   }
 408
 409 }