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].split("\\|")[0];
 135               }
 136
 137               @Override
 138               public String getAltCode()
 139               {
 140                 return lineData[1].split("\\|").length > 1 ? lineData[1]
 141                         .split("\\|")[1] : getCode();
 142               }
 143
 144               @Override
 145               public Class<?> getDataColumnClass()
 146               {
 147                 String classString = lineData[2];
 148                 classString = classString.toUpperCase();
 149                 switch (classString)
 150                 {
 151                 case "INT":
 152                 case "INTEGER":
 153                   return Integer.class;
 154                 case "DOUBLE":
 155                   return Double.class;
 156                 case "STRING":
 157                 default:
 158                   return String.class;
 159                 }
 160               }
 161
 162               @Override
 163               public FTSDataColumnGroupI getGroup()
 164               {
 165                 FTSDataColumnGroupI group = null;
 166                 try
 167                 {
 168                   group = getDataColumnGroupById(lineData[3]);
 169                 } catch (Exception e)
 170                 {
 171                   e.printStackTrace();
 172                 }
 173                 return group;
 174               }
 175
 176               @Override
 177               public int getMinWidth()
 178               {
 179                 return Integer.valueOf(lineData[4]);
 180               }
 181
 182               @Override
 183               public int getMaxWidth()
 184               {
 185                 return Integer.valueOf(lineData[5]);
 186               }
 187
 188               @Override
 189               public int getPreferredWidth()
 190               {
 191                 return Integer.valueOf(lineData[6]);
 192               }
 193
 194               @Override
 195               public boolean isPrimaryKeyColumn()
 196               {
 197                 return getName().equalsIgnoreCase(primaryKeyColumnCode)
 198                         || getCode().equalsIgnoreCase(primaryKeyColumnCode);
 199               }
 200
 201               @Override
 202               public boolean isVisibleByDefault()
 203               {
 204                 return Boolean.valueOf(lineData[7]);
 205               }
 206
 207               @Override
 208               public boolean isSearchable()
 209               {
 210                 return Boolean.valueOf(lineData[8]);
 211               }
 212
 213               @Override
 214               public int hashCode()
 215               {
 216                 return Objects.hash(this.getName(), this.getCode(),
 217                         this.getGroup());
 218               }
 219
 220
 221               @Override
 222               public boolean equals(Object otherObject)
 223               {
 224                 FTSDataColumnI that = (FTSDataColumnI) otherObject;
 225                 return this.getCode().equals(that.getCode())
 226                         && this.getName().equals(that.getName())
 227                         && this.getGroup().equals(that.getGroup());
 228               }
 229
 230             };
 231             dataColumns.add(dataCol);
 232
 233             if (dataCol.isSearchable())
 234             {
 235               searchableDataColumns.add(dataCol);
 236             }
 237
 238             if (dataCol.isVisibleByDefault())
 239             {
 240               defaulDisplayedDataColumns.add(dataCol);
 241             }
 242
 243           }
 244           else
 245           {
 246             continue;
 247           }
 248         } catch (Exception e)
 249         {
 250           e.printStackTrace();
 251         }
 252       }
 253       try
 254       {
 255         this.primaryKeyColumn = getDataColumnByNameOrCode(primaryKeyColumnCode);
 256       } catch (Exception e)
 257       {
 258         e.printStackTrace();
 259       }
 260     } catch (IOException e)
 261     {
 262       e.printStackTrace();
 263     }
 264   }
 265
 266   @Override
 267   public int getPrimaryKeyColumIndex(
 268           Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
 269           throws Exception
 270   {
 271
 272     // If a reference sequence is attached then start counting from 1 else
 273     // start from zero
 274     int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
 275
 276     for (FTSDataColumnI field : wantedFields)
 277     {
 278       if (field.isPrimaryKeyColumn())
 279       {
 280         break; // Once PDB Id index is determined exit iteration
 281       }
 282       ++pdbFieldIndexCounter;
 283     }
 284     return pdbFieldIndexCounter;
 285   }
 286
 287   @Override
 288   public String getDataColumnsFieldsAsCommaDelimitedString(
 289           Collection<FTSDataColumnI> dataColumnFields)
 290   {
 291     String result = "";
 292     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 293     {
 294       StringBuilder returnedFields = new StringBuilder();
 295       for (FTSDataColumnI field : dataColumnFields)
 296       {
 297         returnedFields.append(",").append(field.getCode());
 298       }
 299       returnedFields.deleteCharAt(0);
 300       result = returnedFields.toString();
 301     }
 302     return result;
 303   }
 304
 305
 306   @Override
 307   public Collection<FTSDataColumnI> getAllFTSDataColumns()
 308   {
 309     if (dataColumns == null || dataColumns.isEmpty())
 310     {
 311       parseDataColumnsConfigFile();
 312     }
 313     return dataColumns;
 314   }
 315
 316   @Override
 317   public Collection<FTSDataColumnI> getSearchableDataColumns()
 318   {
 319     if (searchableDataColumns == null || searchableDataColumns.isEmpty())
 320     {
 321       parseDataColumnsConfigFile();
 322     }
 323     return searchableDataColumns;
 324   }
 325
 326   @Override
 327   public Collection<FTSDataColumnI> getAllDefaulDisplayedDataColumns()
 328   {
 329     if (defaulDisplayedDataColumns == null
 330             || defaulDisplayedDataColumns.isEmpty())
 331     {
 332       parseDataColumnsConfigFile();
 333     }
 334     return defaulDisplayedDataColumns;
 335   }
 336
 337   @Override
 338   public FTSDataColumnI getPrimaryKeyColumn()
 339   {
 340     if (defaulDisplayedDataColumns == null
 341             || defaulDisplayedDataColumns.isEmpty())
 342     {
 343       parseDataColumnsConfigFile();
 344     }
 345     return primaryKeyColumn;
 346   }
 347
 348   @Override
 349   public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
 350           throws Exception
 351   {
 352     if (dataColumns == null || dataColumns.isEmpty())
 353     {
 354       parseDataColumnsConfigFile();
 355     }
 356     for (FTSDataColumnI column : dataColumns)
 357     {
 358       if (column.getName().equalsIgnoreCase(nameOrCode)
 359               || column.getCode().equalsIgnoreCase(nameOrCode))
 360       {
 361         return column;
 362       }
 363     }
 364     throw new Exception("Couldn't find data column with name : "
 365             + nameOrCode);
 366   }
 367
 368   @Override
 369   public FTSDataColumnGroupI getDataColumnGroupById(String id)
 370           throws Exception
 371   {
 372     if (dataColumns == null || dataColumns.isEmpty())
 373     {
 374       parseDataColumnsConfigFile();
 375     }
 376     for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
 377     {
 378       if (columnGroup.getID().equalsIgnoreCase(id))
 379       {
 380         return columnGroup;
 381       }
 382     }
 383     throw new Exception("Couldn't find data column group with id : " + id);
 384   }
 385
 386   protected String getResourceFile(String fileName)
 387   {
 388     String result = "";
 389     try
 390     {
 391       result = getClass().getResource(fileName).getFile();
 392     } catch (Exception e)
 393     {
 394       e.printStackTrace();
 395     }
 396     return result;
 397
 398   }
 399
 400   @Override
 401   public int getDefaultResponsePageSize()
 402   {
 403     if (dataColumns == null || dataColumns.isEmpty())
 404     {
 405       parseDataColumnsConfigFile();
 406     }
 407     return defaultResponsePageSize;
 408   }
 409
 410 }