Clover icon

jalviewX

  1. Project Clover database Wed Oct 31 2018 15:13:58 GMT
  2. Package jalview.fts.core

File FTSRestClient.java

 

Coverage histogram

../../../img/srcFileCovDistChart8.png
19% of files have more coverage

Code metrics

48
151
36
1
509
422
98
0.65
4.19
36
2.72

Classes

Class Line # Actions
FTSRestClient 44 151 98 64
0.727659672.8%
 

Contributing tests

This file is covered by 20 tests. .

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
7    * Jalview is free software: you can redistribute it and/or
8    * modify it under the terms of the GNU General Public License
9    * as published by the Free Software Foundation, either version 3
10    * of the License, or (at your option) any later version.
11    *
12    * Jalview is distributed in the hope that it will be useful, but
13    * WITHOUT ANY WARRANTY; without even the implied warranty
14    * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15    * PURPOSE. See the GNU General Public License for more details.
16    *
17    * You should have received a copy of the GNU General Public License
18    * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19    * The Jalview Authors are detailed in the 'AUTHORS' file.
20    */
21    package jalview.fts.core;
22   
23    import jalview.fts.api.FTSDataColumnI;
24    import jalview.fts.api.FTSDataColumnI.FTSDataColumnGroupI;
25    import jalview.fts.api.FTSRestClientI;
26    import jalview.util.MessageManager;
27   
28    import java.io.BufferedReader;
29    import java.io.IOException;
30    import java.io.InputStream;
31    import java.io.InputStreamReader;
32    import java.util.ArrayList;
33    import java.util.Collection;
34    import java.util.Objects;
35   
36    /**
37    * Base class providing implementation for common methods defined in
38    * FTSRestClientI
39    *
40    * @author tcnofoegbu
41    *
42    * @note implementations MUST be accessed as a singleton.
43    */
 
44    public abstract class FTSRestClient implements FTSRestClientI
45    {
46    protected Collection<FTSDataColumnI> dataColumns = new ArrayList<FTSDataColumnI>();
47   
48    protected Collection<FTSDataColumnGroupI> dataColumnGroups = new ArrayList<FTSDataColumnGroupI>();
49   
50    protected Collection<FTSDataColumnI> searchableDataColumns = new ArrayList<FTSDataColumnI>();
51   
52    protected Collection<FTSDataColumnI> defaulDisplayedDataColumns = new ArrayList<FTSDataColumnI>();
53   
54    protected FTSDataColumnI primaryKeyColumn;
55   
56    private String primaryKeyColumnCode = null;
57   
58    private int defaultResponsePageSize = 100;
59   
 
60  17 toggle protected FTSRestClient()
61    {
62   
63    }
64   
 
65  17 toggle public void parseDataColumnsConfigFile()
66    {
67  17 String fileName = getColumnDataConfigFileName();
68   
69  17 InputStream in = getClass().getResourceAsStream(fileName);
70   
71  17 try (BufferedReader br = new BufferedReader(new InputStreamReader(in)))
72    {
73  17 String line;
74  ? while ((line = br.readLine()) != null)
75    {
76  2930 final String[] lineData = line.split(";");
77  2930 try
78    {
79  2930 if (lineData.length == 2)
80    {
81  51 if (lineData[0].equalsIgnoreCase("_data_column.primary_key"))
82    {
83  17 primaryKeyColumnCode = lineData[1];
84    }
85  51 if (lineData[0].equalsIgnoreCase(
86    "_data_column.default_response_page_size"))
87    {
88  17 defaultResponsePageSize = Integer.valueOf(lineData[1]);
89    }
90    }
91  2879 else if (lineData.length == 3)
92    {
93  294 dataColumnGroups.add(new FTSDataColumnGroupI()
94    {
 
95  2165 toggle @Override
96    public String getID()
97    {
98  2165 return lineData[0];
99    }
100   
 
101  235 toggle @Override
102    public String getName()
103    {
104  235 return lineData[1];
105    }
106   
 
107  1730 toggle @Override
108    public int getSortOrder()
109    {
110  1730 return Integer.valueOf(lineData[2]);
111    }
112   
 
113  1 toggle @Override
114    public String toString()
115    {
116  1 return lineData[1];
117    }
118   
 
119  212 toggle @Override
120    public int hashCode()
121    {
122  212 return Objects.hash(this.getID(), this.getName(),
123    this.getSortOrder());
124    }
125   
 
126  11 toggle @Override
127    public boolean equals(Object otherObject)
128    {
129  11 FTSDataColumnGroupI that = (FTSDataColumnGroupI) otherObject;
130  11 return this.getID().equals(that.getID())
131    && this.getName().equals(that.getName())
132    && this.getSortOrder() == that.getSortOrder();
133    }
134    });
135    }
136  2585 else if (lineData.length > 6)
137    {
138  1956 FTSDataColumnI dataCol = new FTSDataColumnI()
139    {
 
140  51 toggle @Override
141    public String toString()
142    {
143  51 return lineData[0];
144    }
145   
 
146  1225 toggle @Override
147    public String getName()
148    {
149  1225 return lineData[0];
150    }
151   
 
152  1938 toggle @Override
153    public String getCode()
154    {
155  1938 return lineData[1].split("\\|")[0];
156    }
157   
 
158  0 toggle @Override
159    public String getAltCode()
160    {
161  0 return lineData[1].split("\\|").length > 1
162    ? lineData[1].split("\\|")[1]
163    : getCode();
164    }
165   
 
166  2 toggle @Override
167    public DataTypeI getDataType()
168    {
169  2 final String[] dataTypeString = lineData[2].split("\\|");
170  2 final String classString = dataTypeString[0].toUpperCase();
171   
172  2 return new DataTypeI()
173    {
174   
 
175  0 toggle @Override
176    public boolean isFormtted()
177    {
178  0 if (dataTypeString.length > 1
179    && dataTypeString[1] != null)
180    {
181  0 switch (dataTypeString[1].toUpperCase())
182    {
183  0 case "T":
184  0 case "TRUE":
185  0 return true;
186  0 case "F":
187  0 case "False":
188  0 default:
189  0 return false;
190    }
191    }
192  0 return false;
193    }
194   
 
195  0 toggle @Override
196    public int getSignificantFigures()
197    {
198  0 if (dataTypeString.length > 2
199    && dataTypeString[2] != null)
200    {
201  0 return Integer.valueOf(dataTypeString[2]);
202    }
203  0 return 0;
204    }
205   
 
206  2 toggle @Override
207    public Class getDataTypeClass()
208    {
209  2 switch (classString)
210    {
211  1 case "INT":
212  0 case "INTEGER":
213  1 return Integer.class;
214  0 case "DOUBLE":
215  0 return Double.class;
216  1 case "STRING":
217  0 default:
218  1 return String.class;
219    }
220    }
221    };
222   
223    }
224   
 
225  400 toggle @Override
226    public FTSDataColumnGroupI getGroup()
227    {
228  400 FTSDataColumnGroupI group = null;
229  400 try
230    {
231  400 group = getDataColumnGroupById(lineData[3]);
232    } catch (Exception e)
233    {
234  0 e.printStackTrace();
235    }
236  400 return group;
237    }
238   
 
239  1 toggle @Override
240    public int getMinWidth()
241    {
242  1 return Integer.valueOf(lineData[4]);
243    }
244   
 
245  1 toggle @Override
246    public int getMaxWidth()
247    {
248  1 return Integer.valueOf(lineData[5]);
249    }
250   
 
251  1 toggle @Override
252    public int getPreferredWidth()
253    {
254  1 return Integer.valueOf(lineData[6]);
255    }
256   
 
257  12 toggle @Override
258    public boolean isPrimaryKeyColumn()
259    {
260  12 return getName().equalsIgnoreCase(primaryKeyColumnCode)
261    || getCode().equalsIgnoreCase(primaryKeyColumnCode);
262    }
263   
 
264  1956 toggle @Override
265    public boolean isVisibleByDefault()
266    {
267  1956 return Boolean.valueOf(lineData[7]);
268    }
269   
 
270  1956 toggle @Override
271    public boolean isSearchable()
272    {
273  1956 return Boolean.valueOf(lineData[8]);
274    }
275   
 
276  212 toggle @Override
277    public int hashCode()
278    {
279  212 return Objects.hash(this.getName(), this.getCode(),
280    this.getGroup());
281    }
282   
 
283  655 toggle @Override
284    public boolean equals(Object otherObject)
285    {
286  655 FTSDataColumnI that = (FTSDataColumnI) otherObject;
287  655 return otherObject == null ? false
288    : this.getCode().equals(that.getCode())
289    && this.getName().equals(that.getName())
290    && this.getGroup().equals(that.getGroup());
291    }
292   
293    };
294  1956 dataColumns.add(dataCol);
295   
296  1956 if (dataCol.isSearchable())
297    {
298  361 searchableDataColumns.add(dataCol);
299    }
300   
301  1956 if (dataCol.isVisibleByDefault())
302    {
303  116 defaulDisplayedDataColumns.add(dataCol);
304    }
305   
306    }
307    else
308    {
309  629 continue;
310    }
311    } catch (Exception e)
312    {
313  0 e.printStackTrace();
314    }
315    }
316  17 try
317    {
318  17 this.primaryKeyColumn = getDataColumnByNameOrCode(
319    primaryKeyColumnCode);
320    } catch (Exception e)
321    {
322  0 e.printStackTrace();
323    }
324    } catch (IOException e)
325    {
326  0 e.printStackTrace();
327    }
328    }
329   
 
330  4 toggle @Override
331    public int getPrimaryKeyColumIndex(
332    Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
333    throws Exception
334    {
335   
336    // If a reference sequence is attached then start counting from 1 else
337    // start from zero
338  4 int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
339   
340  4 for (FTSDataColumnI field : wantedFields)
341    {
342  12 if (field.isPrimaryKeyColumn())
343    {
344  4 break; // Once PDB Id index is determined exit iteration
345    }
346  8 ++pdbFieldIndexCounter;
347    }
348  4 return pdbFieldIndexCounter;
349    }
350   
 
351  3 toggle @Override
352    public String getDataColumnsFieldsAsCommaDelimitedString(
353    Collection<FTSDataColumnI> dataColumnFields)
354    {
355  3 String result = "";
356  3 if (dataColumnFields != null && !dataColumnFields.isEmpty())
357    {
358  3 StringBuilder returnedFields = new StringBuilder();
359  3 for (FTSDataColumnI field : dataColumnFields)
360    {
361  16 returnedFields.append(",").append(field.getCode());
362    }
363  3 returnedFields.deleteCharAt(0);
364  3 result = returnedFields.toString();
365    }
366  3 return result;
367    }
368   
 
369  3 toggle @Override
370    public Collection<FTSDataColumnI> getAllFTSDataColumns()
371    {
372  3 if (dataColumns == null || dataColumns.isEmpty())
373    {
374  1 parseDataColumnsConfigFile();
375    }
376  3 return dataColumns;
377    }
378   
 
379  4 toggle @Override
380    public Collection<FTSDataColumnI> getSearchableDataColumns()
381    {
382  4 if (searchableDataColumns == null || searchableDataColumns.isEmpty())
383    {
384  3 parseDataColumnsConfigFile();
385    }
386  4 return searchableDataColumns;
387    }
388   
 
389  89 toggle @Override
390    public Collection<FTSDataColumnI> getAllDefaultDisplayedFTSDataColumns()
391    {
392  89 if (defaulDisplayedDataColumns == null
393    || defaulDisplayedDataColumns.isEmpty())
394    {
395  3 parseDataColumnsConfigFile();
396    }
397  89 return defaulDisplayedDataColumns;
398    }
399   
 
400  3 toggle @Override
401    public FTSDataColumnI getPrimaryKeyColumn()
402    {
403  3 if (defaulDisplayedDataColumns == null
404    || defaulDisplayedDataColumns.isEmpty())
405    {
406  1 parseDataColumnsConfigFile();
407    }
408  3 return primaryKeyColumn;
409    }
410   
 
411  36 toggle @Override
412    public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
413    throws Exception
414    {
415  36 if (dataColumns == null || dataColumns.isEmpty())
416    {
417  7 parseDataColumnsConfigFile();
418    }
419  36 for (FTSDataColumnI column : dataColumns)
420    {
421  398 if (column.getName().equalsIgnoreCase(nameOrCode)
422    || column.getCode().equalsIgnoreCase(nameOrCode))
423    {
424  34 return column;
425    }
426    }
427  2 throw new Exception(
428    "Couldn't find data column with name : " + nameOrCode);
429    }
430   
 
431  404 toggle @Override
432    public FTSDataColumnGroupI getDataColumnGroupById(String id)
433    throws Exception
434    {
435  404 if (dataColumns == null || dataColumns.isEmpty())
436    {
437  1 parseDataColumnsConfigFile();
438    }
439  404 for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
440    {
441  1931 if (columnGroup.getID().equalsIgnoreCase(id))
442    {
443  402 return columnGroup;
444    }
445    }
446  2 throw new Exception("Couldn't find data column group with id : " + id);
447    }
448   
 
449  0 toggle public String getMessageByHTTPStatusCode(int code, String service)
450    {
451  0 String message = "";
452  0 switch (code)
453    {
454  0 case 400:
455  0 message = MessageManager.getString("exception.bad_request");
456  0 break;
457   
458  0 case 410:
459  0 message = MessageManager.formatMessage(
460    "exception.fts_rest_service_no_longer_available", service);
461  0 break;
462  0 case 403:
463  0 case 404:
464  0 message = MessageManager.getString("exception.resource_not_be_found");
465  0 break;
466  0 case 408:
467  0 case 409:
468  0 case 500:
469  0 case 501:
470  0 case 502:
471  0 case 504:
472  0 case 505:
473  0 message = MessageManager.formatMessage("exception.fts_server_error",
474    service);
475  0 break;
476  0 case 503:
477  0 message = MessageManager.getString("exception.service_not_available");
478  0 break;
479  0 default:
480  0 break;
481    }
482  0 return message;
483    }
484   
 
485  1 toggle protected String getResourceFile(String fileName)
486    {
487  1 String result = "";
488  1 try
489    {
490  1 result = getClass().getResource(fileName).getFile();
491    } catch (Exception e)
492    {
493  0 e.printStackTrace();
494    }
495  1 return result;
496   
497    }
498   
 
499  2 toggle @Override
500    public int getDefaultResponsePageSize()
501    {
502  2 if (dataColumns == null || dataColumns.isEmpty())
503    {
504  1 parseDataColumnsConfigFile();
505    }
506  2 return defaultResponsePageSize;
507    }
508   
509    }
  • Report generated by OpenClover v 4.2.1 on Wed Oct 31 2018 15:15:54 GMT using coverage data from Wed Oct 31 2018 15:15:47 GMT.
  • Clover free edition.