src/jalview/fts/core/FTSRestClient.java

   1 package jalview.fts.core;
   2
   3 import jalview.fts.api.FTSDataColumnGroupI;
   4 import jalview.fts.api.FTSDataColumnI;
   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 public abstract class FTSRestClient implements FTSRestClientI
  15 {
  16   protected Collection<FTSDataColumnI> dataColumns = new ArrayList<FTSDataColumnI>();
  17
  18   protected Collection<FTSDataColumnGroupI> dataColumnGroups = new ArrayList<FTSDataColumnGroupI>();
  19
  20   protected Collection<FTSDataColumnI> searchableDataColumns = new ArrayList<FTSDataColumnI>();
  21
  22   protected Collection<FTSDataColumnI> defaulDisplayedDataColumns = new ArrayList<FTSDataColumnI>();
  23
  24   protected FTSDataColumnI primaryKeyColumn;
  25
  26   protected FTSRestClient()
  27   {
  28
  29   }
  30
  31   public void parseDataColumnsFile()
  32   {
  33     String fileName = getColumnDataConfigFile();
  34     try (BufferedReader br = new BufferedReader(new FileReader(fileName)))
  35     {
  36       String line;
  37       while ((line = br.readLine()) != null)
  38       {
  39         final String[] lineData = line.split(";");
  40         if (lineData.length == 3)
  41         {
  42           dataColumnGroups.add(new FTSDataColumnGroupI()
  43           {
  44             @Override
  45             public String getID()
  46             {
  47               return lineData[0];
  48             }
  49
  50             @Override
  51             public String getName()
  52             {
  53               return lineData[1];
  54             }
  55
  56             @Override
  57             public int getSortOrder()
  58             {
  59               return Integer.valueOf(lineData[2]);
  60             }
  61
  62             @Override
  63             public String toString()
  64             {
  65               return lineData[1];
  66             }
  67
  68             @Override
  69             public int hashCode()
  70             {
  71               return Objects.hash(this.getID(), this.getName(),
  72                       this.getSortOrder());
  73             }
  74
  75             @Override
  76             public boolean equals(Object otherObject)
  77             {
  78               FTSDataColumnGroupI that = (FTSDataColumnGroupI) otherObject;
  79               return this.getID().equals(that.getID())
  80                       && this.getName().equals(that.getName())
  81                       && this.getSortOrder() == that.getSortOrder();
  82             }
  83           });
  84         }
  85         else if (lineData.length > 6)
  86         {
  87           FTSDataColumnI dataCol = new FTSDataColumnI()
  88           {
  89             @Override
  90             public String toString()
  91             {
  92               return lineData[0];
  93             }
  94
  95             @Override
  96             public String getName()
  97             {
  98               return lineData[0];
  99             }
 100
 101             @Override
 102             public String getCode()
 103             {
 104               return lineData[1];
 105             }
 106
 107             @Override
 108             public FTSDataColumnGroupI getGroup()
 109             {
 110               FTSDataColumnGroupI group = null;
 111               try
 112               {
 113                 group = getDataColumnGroupById(lineData[2]);
 114               } catch (Exception e)
 115               {
 116                 e.printStackTrace();
 117               }
 118               return group;
 119             }
 120
 121             @Override
 122             public int getMinWidth()
 123             {
 124               return Integer.valueOf(lineData[3]);
 125             }
 126
 127             @Override
 128             public int getMaxWidth()
 129             {
 130               return Integer.valueOf(lineData[4]);
 131             }
 132
 133             @Override
 134             public int getPreferredWidth()
 135             {
 136               return Integer.valueOf(lineData[5]);
 137             }
 138
 139
 140             @Override
 141             public boolean isPrimaryKeyColumn()
 142             {
 143               return Boolean.valueOf(lineData[6]);
 144             }
 145
 146             @Override
 147             public boolean isVisibleByDefault()
 148             {
 149               return Boolean.valueOf(lineData[7]);
 150             }
 151
 152             @Override
 153             public boolean isSearchable()
 154             {
 155               return Boolean.valueOf(lineData[8]);
 156             }
 157
 158             @Override
 159             public int hashCode()
 160             {
 161               return Objects.hash(this.getName(), this.getCode(),
 162                       this.getGroup());
 163             }
 164
 165             @Override
 166             public boolean equals(Object otherObject)
 167             {
 168               FTSDataColumnI that = (FTSDataColumnI) otherObject;
 169               return this.getCode().equals(that.getCode())
 170                       && this.getName().equals(that.getName())
 171                       && this.getGroup().equals(that.getGroup());
 172             }
 173           };
 174           dataColumns.add(dataCol);
 175
 176           if (dataCol.isSearchable())
 177           {
 178             searchableDataColumns.add(dataCol);
 179           }
 180
 181           if (dataCol.isVisibleByDefault())
 182           {
 183             defaulDisplayedDataColumns.add(dataCol);
 184           }
 185
 186         }
 187         else
 188         {
 189           continue;
 190         }
 191       }
 192     } catch (IOException e)
 193     {
 194       e.printStackTrace();
 195     }
 196   }
 197
 198   /**
 199    * Determines the column index for 'Primary key' Fields in the dynamic summary
 200    * table.
 201    *
 202    * @param wantedFields
 203    *          the available table columns in no particular order
 204    * @return the primary key column index
 205    * @throws Exception
 206    */
 207   @Override
 208   public int getPrimaryKeyColumIndex(
 209           Collection<FTSDataColumnI> wantedFields,
 210           boolean hasRefSeq) throws Exception
 211   {
 212
 213     // If a reference sequence is attached then start counting from 1 else
 214     // start from zero
 215     int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
 216
 217     for (FTSDataColumnI field : wantedFields)
 218     {
 219       if (field.isPrimaryKeyColumn())
 220       {
 221         break; // Once PDB Id index is determined exit iteration
 222       }
 223       ++pdbFieldIndexCounter;
 224     }
 225     return pdbFieldIndexCounter;
 226   }
 227
 228   /**
 229    * Takes a collection of FTSDataColumnI and converts its 'code' values into a
 230    * comma delimited string.
 231    *
 232    * @param dataColumnFields
 233    *          the collection of FTSDataColumnI to process
 234    * @return the generated comma delimited string from the supplied
 235    *         FTSDataColumnI collection
 236    */
 237   public static String getDataColumnsFieldsAsCommaDelimitedString(
 238           Collection<FTSDataColumnI> dataColumnFields)
 239   {
 240     String result = "";
 241     if (dataColumnFields != null && !dataColumnFields.isEmpty())
 242     {
 243       StringBuilder returnedFields = new StringBuilder();
 244       for (FTSDataColumnI field : dataColumnFields)
 245       {
 246         returnedFields.append(",").append(field.getCode());
 247       }
 248       returnedFields.deleteCharAt(0);
 249       result = returnedFields.toString();
 250     }
 251     return result;
 252   }
 253
 254   @Override
 255   public Collection<FTSDataColumnI> getAllFTSDataColumns()
 256   {
 257     if (dataColumns == null || dataColumns.isEmpty())
 258     {
 259       parseDataColumnsFile();
 260     }
 261     return dataColumns;
 262   }
 263
 264   @Override
 265   public Collection<FTSDataColumnI> getSearchableDataColumns()
 266   {
 267     if (searchableDataColumns == null || searchableDataColumns.isEmpty())
 268     {
 269       parseDataColumnsFile();
 270     }
 271     return searchableDataColumns;
 272   }
 273
 274   @Override
 275   public Collection<FTSDataColumnI> getAllDefaulDisplayedDataColumns()
 276   {
 277     if (defaulDisplayedDataColumns == null
 278             || defaulDisplayedDataColumns.isEmpty())
 279     {
 280       parseDataColumnsFile();
 281     }
 282     return defaulDisplayedDataColumns;
 283   }
 284
 285   @Override
 286   public FTSDataColumnI getPrimaryKeyColumn()
 287   {
 288     return primaryKeyColumn;
 289   }
 290
 291   @Override
 292   public FTSDataColumnI getDataColumnByNameOrCode(
 293           String nameOrCode) throws Exception
 294   {
 295     for (FTSDataColumnI column : dataColumns)
 296     {
 297       if (column.getName().equalsIgnoreCase(nameOrCode)
 298               || column.getCode().equalsIgnoreCase(nameOrCode))
 299       {
 300         return column;
 301       }
 302     }
 303     throw new Exception("Couldn't find data column with name : "
 304             + nameOrCode);
 305   }
 306
 307   @Override
 308   public FTSDataColumnGroupI getDataColumnGroupById(String id)
 309           throws Exception
 310   {
 311     for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
 312     {
 313       if (columnGroup.getID().equalsIgnoreCase(id))
 314       {
 315         return columnGroup;
 316       }
 317     }
 318     throw new Exception("Couldn't find data column group with id : " + id);
 319   }
 320
 321   protected String getFile(String fileName)
 322   {
 323     ClassLoader classLoader = getClass().getClassLoader();
 324     // File file = new File(classLoader.getResource(fileName).getFile());
 325     String result = "";
 326     try
 327     {
 328       result = classLoader.getResource(fileName).getFile();
 329     } catch (Exception e)
 330     {
 331       e.printStackTrace();
 332     }
 333     return result;
 334
 335   }
 336
 337 }