Clover icon

Coverage Report

  1. Project Clover database Mon Nov 18 2024 09:38:20 GMT
  2. Package jalview.fts.core

File FTSRestClient.java

 

Coverage histogram

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

Code metrics

50
168
41
1
565
465
105
0.62
4.1
41
2.56

Classes

Class Line # Actions
FTSRestClient 46 168 105
0.729729773%
 

Contributing tests

This file is covered by 50 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 java.io.BufferedReader;
24    import java.io.IOException;
25    import java.io.InputStream;
26    import java.io.InputStreamReader;
27    import java.util.ArrayList;
28    import java.util.Collection;
29    import java.util.HashMap;
30    import java.util.Locale;
31    import java.util.Objects;
32   
33    import jalview.fts.api.FTSDataColumnI;
34    import jalview.fts.api.FTSDataColumnI.FTSDataColumnGroupI;
35    import jalview.fts.api.FTSRestClientI;
36    import jalview.fts.core.FTSDataColumnPreferences.PreferenceSource;
37   
38    /**
39    * Base class providing implementation for common methods defined in
40    * FTSRestClientI
41    *
42    * @author tcnofoegbu
43    *
44    * @note implementations MUST be accessed as a singleton.
45    */
 
46    public abstract class FTSRestClient implements FTSRestClientI
47    {
48    protected Collection<FTSDataColumnI> dataColumns = new ArrayList<>();
49   
50    protected Collection<FTSDataColumnGroupI> dataColumnGroups = new ArrayList<>();
51   
52    protected Collection<FTSDataColumnI> searchableDataColumns = new ArrayList<>();
53   
54    protected Collection<FTSDataColumnI> defaulDisplayedDataColumns = new ArrayList<>();
55   
56    protected FTSDataColumnI primaryKeyColumn;
57   
58    private String primaryKeyColumnCode = null;
59   
60    private int defaultResponsePageSize = 100;
61   
62    protected HashMap<String, String> mockQueries = null;
63   
 
64  31 toggle protected FTSRestClient()
65    {
66   
67    }
68   
 
69  29 toggle public void parseDataColumnsConfigFile()
70    {
71  29 String fileName = getColumnDataConfigFileName();
72   
73  29 InputStream in = getClass().getResourceAsStream(fileName);
74   
75  29 try (BufferedReader br = new BufferedReader(new InputStreamReader(in)))
76    {
77  29 String line;
78  ? while ((line = br.readLine()) != null)
79    {
80  3685 final String[] lineData = line.split(";");
81  3685 try
82    {
83  3685 if (lineData.length == 2)
84    {
85  87 if (lineData[0].equalsIgnoreCase("_data_column.primary_key"))
86    {
87  29 primaryKeyColumnCode = lineData[1];
88    }
89  87 if (lineData[0].equalsIgnoreCase(
90    "_data_column.default_response_page_size"))
91    {
92  29 defaultResponsePageSize = Integer.valueOf(lineData[1]);
93    }
94    }
95  3598 else if (lineData.length == 3)
96    {
97  330 dataColumnGroups.add(new FTSDataColumnGroupI()
98    {
 
99  23904 toggle @Override
100    public String getID()
101    {
102  23904 return lineData[0];
103    }
104   
 
105  3403 toggle @Override
106    public String getName()
107    {
108  3403 return lineData[1];
109    }
110   
 
111  23781 toggle @Override
112    public int getSortOrder()
113    {
114  23781 return Integer.valueOf(lineData[2]);
115    }
116   
 
117  1 toggle @Override
118    public String toString()
119    {
120  1 return lineData[1];
121    }
122   
 
123  2455 toggle @Override
124    public int hashCode()
125    {
126  2455 return Objects.hash(this.getID(), this.getName(),
127    this.getSortOrder());
128    }
129   
 
130  473 toggle @Override
131    public boolean equals(Object otherObject)
132    {
133  473 FTSDataColumnGroupI that = (FTSDataColumnGroupI) otherObject;
134  473 return this.getID().equals(that.getID())
135    && this.getName().equals(that.getName())
136    && this.getSortOrder() == that.getSortOrder();
137    }
138    });
139    }
140  3268 else if (lineData.length > 6)
141    {
142  2195 FTSDataColumnI dataCol = new FTSDataColumnI()
143    {
 
144  67 toggle @Override
145    public String toString()
146    {
147  67 return getName();
148    }
149   
 
150  120908 toggle @Override
151    public String getName()
152    {
153  120908 return lineData[0];
154    }
155   
 
156  333459 toggle @Override
157    public String getCode()
158    {
159  333459 return lineData[1].split("\\|")[0];
160    }
161   
 
162  2 toggle @Override
163    public String getAltCode()
164    {
165  2 return lineData[1].split("\\|").length > 1
166    ? lineData[1].split("\\|")[1]
167    : getCode();
168    }
169   
 
170  139517 toggle @Override
171    public DataTypeI getDataType()
172    {
173  139517 final String[] dataTypeString = lineData[2].split("\\|");
174  139517 final String classString = dataTypeString[0]
175    .toUpperCase(Locale.ROOT);
176   
177  139517 return new DataTypeI()
178    {
179   
 
180  0 toggle @Override
181    public boolean isFormtted()
182    {
183  0 if (dataTypeString.length > 1
184    && dataTypeString[1] != null)
185    {
186  0 switch (dataTypeString[1].toUpperCase(Locale.ROOT))
187    {
188  0 case "T":
189  0 case "TRUE":
190  0 return true;
191  0 case "F":
192  0 case "False":
193  0 default:
194  0 return false;
195    }
196    }
197  0 return false;
198    }
199   
 
200  0 toggle @Override
201    public int getSignificantFigures()
202    {
203  0 if (dataTypeString.length > 2
204    && dataTypeString[2] != null)
205    {
206  0 return Integer.valueOf(dataTypeString[2]);
207    }
208  0 return 0;
209    }
210   
 
211  139517 toggle @Override
212    public Class getDataTypeClass()
213    {
214  139517 switch (classString)
215    {
216  1 case "INT":
217  10062 case "INTEGER":
218  10063 return Integer.class;
219  34999 case "DOUBLE":
220  34999 return Double.class;
221  94455 case "STRING":
222  0 default:
223  94455 return String.class;
224    }
225    }
226    };
227   
228    }
229   
 
230  5787 toggle @Override
231    public FTSDataColumnGroupI getGroup()
232    {
233  5787 FTSDataColumnGroupI group = null;
234  5787 try
235    {
236  5787 group = getDataColumnGroupById(lineData[3]);
237    } catch (Exception e)
238    {
239  0 e.printStackTrace();
240    }
241  5787 return group;
242    }
243   
 
244  2 toggle @Override
245    public int getMinWidth()
246    {
247  2 return Integer.valueOf(lineData[4]);
248    }
249   
 
250  1 toggle @Override
251    public int getMaxWidth()
252    {
253  1 return Integer.valueOf(lineData[5]);
254    }
255   
 
256  1 toggle @Override
257    public int getPreferredWidth()
258    {
259  1 return Integer.valueOf(lineData[6]);
260    }
261   
 
262  108727 toggle @Override
263    public boolean isPrimaryKeyColumn()
264    {
265  108727 return getName().equalsIgnoreCase(primaryKeyColumnCode)
266    || getCode().equalsIgnoreCase(primaryKeyColumnCode);
267    }
268   
 
269  2195 toggle @Override
270    public boolean isVisibleByDefault()
271    {
272  2195 return Boolean.valueOf(lineData[7]);
273    }
274   
 
275  2195 toggle @Override
276    public boolean isSearchable()
277    {
278  2195 return Boolean.valueOf(lineData[8]);
279    }
280   
 
281  2455 toggle @Override
282    public int hashCode()
283    {
284  2455 return Objects.hash(this.getName(), this.getCode(),
285    this.getGroup());
286    }
287   
 
288  12287 toggle @Override
289    public boolean equals(Object otherObject)
290    {
291  12287 FTSDataColumnI that = (FTSDataColumnI) otherObject;
292  12287 return otherObject == null ? false
293    : this.getCode().equals(that.getCode())
294    && this.getName().equals(that.getName())
295    && this.getGroup().equals(that.getGroup());
296    }
297   
298    };
299  2195 dataColumns.add(dataCol);
300   
301  2195 if (dataCol.isSearchable())
302    {
303  373 searchableDataColumns.add(dataCol);
304    }
305   
306  2195 if (dataCol.isVisibleByDefault())
307    {
308  296 defaulDisplayedDataColumns.add(dataCol);
309    }
310   
311    }
312    else
313    {
314  1073 continue;
315    }
316    } catch (Exception e)
317    {
318  0 e.printStackTrace();
319    }
320    }
321  29 try
322    {
323  29 this.primaryKeyColumn = getDataColumnByNameOrCode(
324    primaryKeyColumnCode);
325    } catch (Exception e)
326    {
327  0 e.printStackTrace();
328    }
329    } catch (IOException e)
330    {
331  0 e.printStackTrace();
332    }
333    }
334   
 
335  7 toggle @Override
336    public int getPrimaryKeyColumIndex(
337    Collection<FTSDataColumnI> wantedFields, boolean hasRefSeq)
338    throws Exception
339    {
340   
341    // If a reference sequence is attached then start counting from 1 else
342    // start from zero
343  7 int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;
344   
345  7 for (FTSDataColumnI field : wantedFields)
346    {
347  41 if (field.isPrimaryKeyColumn())
348    {
349  6 break; // Once PDB Id index is determined exit iteration
350    }
351  35 ++pdbFieldIndexCounter;
352    }
353  7 return pdbFieldIndexCounter;
354    }
355   
 
356  37 toggle @Override
357    public String getDataColumnsFieldsAsCommaDelimitedString(
358    Collection<FTSDataColumnI> dataColumnFields)
359    {
360  37 String result = "";
361  37 if (dataColumnFields != null && !dataColumnFields.isEmpty())
362    {
363  37 StringBuilder returnedFields = new StringBuilder();
364  37 for (FTSDataColumnI field : dataColumnFields)
365    {
366  163 returnedFields.append(",").append(field.getCode());
367    }
368  37 returnedFields.deleteCharAt(0);
369  37 result = returnedFields.toString();
370    }
371  37 return result;
372    }
373   
 
374  50 toggle @Override
375    public Collection<FTSDataColumnI> getAllFTSDataColumns()
376    {
377  50 if (dataColumns == null || dataColumns.isEmpty())
378    {
379  2 parseDataColumnsConfigFile();
380    }
381  50 return dataColumns;
382    }
383   
 
384  8 toggle @Override
385    public Collection<FTSDataColumnI> getSearchableDataColumns()
386    {
387  8 if (searchableDataColumns == null || searchableDataColumns.isEmpty())
388    {
389  5 parseDataColumnsConfigFile();
390    }
391  8 return searchableDataColumns;
392    }
393   
 
394  111 toggle @Override
395    public Collection<FTSDataColumnI> getAllDefaultDisplayedFTSDataColumns()
396    {
397  111 if (defaulDisplayedDataColumns == null
398    || defaulDisplayedDataColumns.isEmpty())
399    {
400  5 parseDataColumnsConfigFile();
401    }
402  111 return defaulDisplayedDataColumns;
403    }
404   
 
405  5 toggle @Override
406    public FTSDataColumnI getPrimaryKeyColumn()
407    {
408  5 if (defaulDisplayedDataColumns == null
409    || defaulDisplayedDataColumns.isEmpty())
410    {
411  1 parseDataColumnsConfigFile();
412    }
413  5 return primaryKeyColumn;
414    }
415   
 
416  61 toggle @Override
417    public FTSDataColumnI getDataColumnByNameOrCode(String nameOrCode)
418    throws Exception
419    {
420  61 if (dataColumns == null || dataColumns.isEmpty())
421    {
422  12 parseDataColumnsConfigFile();
423    }
424  61 for (FTSDataColumnI column : dataColumns)
425    {
426  749 if (column.getName().equalsIgnoreCase(nameOrCode)
427    || column.getCode().equalsIgnoreCase(nameOrCode))
428    {
429  58 return column;
430    }
431    }
432  3 throw new Exception(
433    "Couldn't find data column with name : " + nameOrCode);
434    }
435   
436    /**
437    *
438    * @param instance
439    * @param mocks
440    * {{working query, working response}, ...}
441    */
 
442  19 toggle public static void createMockFTSRestClient(FTSRestClient instance,
443    String[][] mocks)
444    {
445  19 instance.setMock(mocks);
446    }
447   
 
448  5792 toggle @Override
449    public FTSDataColumnGroupI getDataColumnGroupById(String id)
450    throws Exception
451    {
452  5792 if (dataColumns == null || dataColumns.isEmpty())
453    {
454  2 parseDataColumnsConfigFile();
455    }
456  5792 for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
457    {
458  20503 if (columnGroup.getID().equalsIgnoreCase(id))
459    {
460  5790 return columnGroup;
461    }
462    }
463  2 throw new Exception("Couldn't find data column group with id : " + id);
464    }
465   
 
466  0 toggle public static String getMessageByHTTPStatusCode(int code, String service)
467    {
468  0 String message = "";
469  0 switch (code)
470    {
471  0 case 400:
472  0 message = "Bad request. There is a problem with your input.";
473  0 break;
474   
475  0 case 410:
476  0 message = service + " rest services no longer available!";
477  0 break;
478  0 case 403:
479  0 case 404:
480  0 message = "The requested resource could not be found";
481  0 break;
482  0 case 408:
483  0 case 409:
484  0 case 500:
485  0 case 501:
486  0 case 502:
487  0 case 504:
488  0 case 505:
489  0 message = "There seems to be an error from the " + service
490    + " server";
491  0 break;
492  0 case 503:
493  0 message = "Service not available. The server is being updated, try again later.";
494  0 break;
495  0 default:
496  0 break;
497    }
498  0 return String.valueOf(code) + " " + message;
499    }
500   
 
501  2 toggle public static void unMock(FTSRestClient instance)
502    {
503  2 instance.mockQueries = null;
504    }
505   
 
506  1 toggle protected String getResourceFile(String fileName)
507    {
508  1 String result = "";
509  1 try
510    {
511  1 result = getClass().getResource(fileName).getFile();
512    } catch (Exception e)
513    {
514  0 e.printStackTrace();
515    }
516  1 return result;
517   
518    }
519   
 
520  4 toggle @Override
521    public int getDefaultResponsePageSize()
522    {
523  4 if (dataColumns == null || dataColumns.isEmpty())
524    {
525  2 parseDataColumnsConfigFile();
526    }
527  4 return defaultResponsePageSize;
528    }
529   
 
530  19 toggle protected void setMock(String[][] mocks)
531    {
532  19 if (mocks == null)
533    {
534  0 mockQueries = null;
535  0 return;
536    }
537  19 mockQueries = new HashMap<String, String>();
538  19 for (String[] mock : mocks)
539    {
540  140 mockQueries.put(mock[0], mock[1]);
541    }
542    }
543   
 
544  109 toggle protected boolean isMocked()
545    {
546  109 return mockQueries != null;
547    }
548   
 
549  0 toggle @Override
550    public String[] getPreferencesColumnsFor(PreferenceSource source)
551    {
552  0 String[] columnNames = null;
553  0 switch (source)
554    {
555  0 case SEARCH_SUMMARY:
556  0 columnNames = new String[] { "", "Display", "Group" };
557  0 break;
558  0 default:
559    // non structure sources don't return any other kind of preferences
560    // columns
561  0 break;
562    }
563  0 return columnNames;
564    }
565    }
  • Report generated by OpenClover v 4.4.1 on Mon Nov 18 2024 09:54:26 GMT using coverage data from Mon Nov 18 2024 09:54:15 GMT.
  • OpenClover is free and open-source software.