Revision b9a0d300
Added by Lorna Morris over 12 years ago
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermStore.java | ||
---|---|---|
11 | 11 |
package eu.etaxonomy.taxeditor.store; |
12 | 12 |
|
13 | 13 |
import java.util.ArrayList; |
14 |
import java.util.Arrays; |
|
14 | 15 |
import java.util.Collections; |
15 | 16 |
import java.util.Comparator; |
17 |
import java.util.HashSet; |
|
16 | 18 |
import java.util.List; |
19 |
import java.util.Set; |
|
17 | 20 |
|
18 | 21 |
import eu.etaxonomy.cdm.api.service.ITermService; |
19 |
import eu.etaxonomy.cdm.api.service.IVocabularyService; |
|
20 |
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper; |
|
21 |
import eu.etaxonomy.cdm.model.common.AnnotationType; |
|
22 | 22 |
import eu.etaxonomy.cdm.model.common.DefinedTermBase; |
23 |
import eu.etaxonomy.cdm.model.common.ExtensionType; |
|
24 |
import eu.etaxonomy.cdm.model.common.Language; |
|
25 | 23 |
import eu.etaxonomy.cdm.model.common.MarkerType; |
26 |
import eu.etaxonomy.cdm.model.common.OrderedTermBase; |
|
27 |
import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary; |
|
28 |
import eu.etaxonomy.cdm.model.common.TermVocabulary; |
|
29 |
import eu.etaxonomy.cdm.model.common.VocabularyEnum; |
|
30 | 24 |
import eu.etaxonomy.cdm.model.description.AbsenceTerm; |
31 | 25 |
import eu.etaxonomy.cdm.model.description.Feature; |
32 |
import eu.etaxonomy.cdm.model.description.MeasurementUnit; |
|
33 |
import eu.etaxonomy.cdm.model.description.Modifier; |
|
34 | 26 |
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase; |
35 | 27 |
import eu.etaxonomy.cdm.model.description.PresenceTerm; |
36 |
import eu.etaxonomy.cdm.model.description.Scope; |
|
37 |
import eu.etaxonomy.cdm.model.description.Stage; |
|
38 |
import eu.etaxonomy.cdm.model.description.State; |
|
39 |
import eu.etaxonomy.cdm.model.description.StatisticalMeasure; |
|
40 |
import eu.etaxonomy.cdm.model.location.NamedAreaType; |
|
41 |
import eu.etaxonomy.cdm.model.location.ReferenceSystem; |
|
42 |
import eu.etaxonomy.cdm.model.media.RightsTerm; |
|
43 |
import eu.etaxonomy.cdm.model.name.NameRelationshipType; |
|
44 |
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus; |
|
45 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType; |
|
46 | 28 |
import eu.etaxonomy.cdm.model.name.Rank; |
47 |
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus; |
|
48 |
import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier; |
|
49 |
import eu.etaxonomy.cdm.model.occurrence.PreservationMethod; |
|
50 | 29 |
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType; |
30 |
import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer; |
|
51 | 31 |
import eu.etaxonomy.taxeditor.preference.PreferencesUtil; |
52 | 32 |
|
53 | 33 |
/** |
... | ... | |
60 | 40 |
* @version 1.0 |
61 | 41 |
*/ |
62 | 42 |
public class TermStore { |
63 |
|
|
64 |
/** |
|
65 |
* <p>getSpecimenTypeDesignationStatus</p> |
|
66 |
* |
|
67 |
* @return a {@link java.util.List} object. |
|
68 |
*/ |
|
69 |
public static List<SpecimenTypeDesignationStatus> getSpecimenTypeDesignationStatus() { |
|
70 |
return getTerms(SpecimenTypeDesignationStatus.class); |
|
71 |
} |
|
72 |
|
|
73 | 43 |
|
74 |
/** |
|
75 |
* <p>getNameTypeDesignationStatus</p> |
|
76 |
* |
|
77 |
* @return a {@link java.util.List} object. |
|
78 |
*/ |
|
79 |
public static List<NameTypeDesignationStatus> getNameTypeDesignationStatus() { |
|
80 |
return getTerms(NameTypeDesignationStatus.class); |
|
81 |
} |
|
82 |
|
|
83 |
/** |
|
84 |
* <p>getNamedAreaTypes</p> |
|
85 |
* |
|
86 |
* @return a {@link java.util.List} object. |
|
87 |
*/ |
|
88 |
public static List<NamedAreaType> getNamedAreaTypes(){ |
|
89 |
return getTerms(NamedAreaType.class); |
|
90 |
} |
|
91 | 44 |
|
92 |
/** |
|
93 |
* <p>getAnnotationTypes</p> |
|
94 |
* |
|
95 |
* @return a {@link java.util.List} object. |
|
96 |
*/ |
|
97 |
public static List<AnnotationType> getAnnotationTypes(){ |
|
98 |
return getTerms(AnnotationType.class); |
|
99 |
} |
|
100 | 45 |
|
101 |
/** |
|
102 |
* <p>getTaxonRelationshipTypes</p> |
|
103 |
* |
|
104 |
* @return a {@link java.util.List} object. |
|
105 |
*/ |
|
106 |
public static List<TaxonRelationshipType> getTaxonRelationshipTypes(){ |
|
107 |
return getTerms(TaxonRelationshipType.class); |
|
46 |
public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){ |
|
47 |
return getTerms(clazz, null, true); |
|
108 | 48 |
} |
109 | 49 |
|
110 |
|
|
111 | 50 |
/** |
112 |
* <p>getLanguages</p> |
|
113 |
* |
|
114 |
* @return a {@link java.util.List} object. |
|
51 |
* Returns a list of terms of the given type currently available in the system. |
|
52 |
* If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be |
|
53 |
* gathered from edge cases. |
|
54 |
* |
|
55 |
* @param clazz |
|
56 |
* @param comparator |
|
57 |
* @param filtered Will filter out some results |
|
58 |
* @return |
|
115 | 59 |
*/ |
116 |
public static List<Language> getLanguages(){ |
|
117 |
return getTerms(Language.class); |
|
118 |
} |
|
119 |
|
|
120 |
/** |
|
121 |
* <p>getFeatures</p> |
|
122 |
* |
|
123 |
* @return a {@link java.util.List} object. |
|
124 |
*/ |
|
125 |
public static List<Feature> getFeatures() { |
|
126 |
List<Feature> features = getTerms(Feature.class); |
|
127 |
features.remove(Feature.IMAGE()); |
|
128 |
return features; |
|
129 |
|
|
130 |
} |
|
131 |
|
|
132 |
/** |
|
133 |
* <p>getNameRelationshipTypes</p> |
|
134 |
* |
|
135 |
* @return a {@link java.util.List} object. |
|
136 |
*/ |
|
137 |
public static List<NameRelationshipType> getNameRelationshipTypes() { |
|
138 |
return getTerms(NameRelationshipType.class); |
|
139 |
} |
|
140 |
|
|
141 |
/** |
|
142 |
* <p>getNomenclaturalStatusTypes</p> |
|
143 |
* |
|
144 |
* @return a {@link java.util.List} object. |
|
145 |
*/ |
|
146 |
public static List<NomenclaturalStatusType> getNomenclaturalStatusTypes(){ |
|
147 |
return getTerms(NomenclaturalStatusType.class); |
|
148 |
} |
|
149 |
|
|
60 |
public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator, boolean filtered){ |
|
61 |
List<TERM> terms = new ArrayList<TERM>(); |
|
150 | 62 |
|
151 |
/** |
|
152 |
* <p>getNonTechnicalMarkerTypes</p> |
|
153 |
* |
|
154 |
* @return a {@link java.util.List} object. |
|
155 |
*/ |
|
156 |
public static List<MarkerType> getNonTechnicalMarkerTypes() { |
|
157 |
List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>(); |
|
158 |
List<MarkerType> markerTypes = getTerms(MarkerType.class); |
|
159 |
|
|
160 |
for (Object type : markerTypes) { |
|
161 |
if (((MarkerType) type).isTechnical() == false) { |
|
162 |
nonTechnicalMarkerTypes.add((MarkerType) type); |
|
163 |
} |
|
63 |
ITermStoreEdgeCase<TERM> edgeCase = getEdgeCase(clazz); |
|
64 |
if(filtered && edgeCase != null){ |
|
65 |
terms = edgeCase.getTerms(); |
|
66 |
}else{ |
|
67 |
terms = getTermsFromService(clazz, comparator); |
|
164 | 68 |
} |
165 | 69 |
|
166 |
return nonTechnicalMarkerTypes; |
|
167 |
} |
|
168 |
|
|
169 |
|
|
170 |
/** |
|
171 |
* <p>getExtensionTypes</p> |
|
172 |
* |
|
173 |
* @return a {@link java.util.List} object. |
|
174 |
*/ |
|
175 |
public static List<ExtensionType> getExtensionTypes() { |
|
176 |
return getTerms(ExtensionType.class); |
|
177 |
} |
|
178 |
|
|
179 |
/** |
|
180 |
* <p>getRightsTypes</p> |
|
181 |
* |
|
182 |
* @return a {@link java.util.List} object. |
|
183 |
*/ |
|
184 |
public static List<RightsTerm> getRightsTypes() { |
|
185 |
return getTerms(RightsTerm.class); |
|
70 |
return terms; |
|
71 |
|
|
186 | 72 |
} |
187 | 73 |
|
188 |
|
|
189 |
/** |
|
190 |
* Retrieve all ranks from data store. |
|
191 |
* |
|
192 |
* @return a {@link java.util.List} object. |
|
193 |
*/ |
|
194 |
public static List<Rank> getRanks(){ |
|
195 |
if(PreferencesUtil.getSortRanksHierarchichally()){ |
|
196 |
return getTerms(Rank.class, new Comparator<Rank>(){ |
|
197 |
|
|
74 |
private static <T extends DefinedTermBase> List<T> getTermsFromService(Class<T> termClass, Comparator<T> comparator){ |
|
75 |
if (comparator == null){ |
|
76 |
comparator = new Comparator<T>() { |
|
198 | 77 |
@Override |
199 |
public int compare(Rank o1, Rank o2) { |
|
200 |
return o1.compareTo(o2); |
|
78 |
public int compare(T o1, T o2) { |
|
79 |
String label1 = o1.getLabel(CdmStore.getDefaultLanguage()) != null ? o1.getLabel(CdmStore.getDefaultLanguage()) : o1.getTitleCache(); |
|
80 |
String label2 = o2.getLabel(CdmStore.getDefaultLanguage()) != null ? o2.getLabel(CdmStore.getDefaultLanguage()) : o2.getTitleCache(); |
|
81 |
return label1.compareTo(label2); |
|
201 | 82 |
} |
202 |
|
|
203 |
}); |
|
204 |
}else{ |
|
205 |
return getTerms(Rank.class); |
|
83 |
}; |
|
206 | 84 |
} |
85 |
|
|
86 |
List<T> terms = CdmStore.getService(ITermService.class).listByTermClass(termClass, null, null, null, null); |
|
87 |
Collections.sort(terms, comparator); |
|
88 |
return terms; |
|
207 | 89 |
} |
208 | 90 |
|
91 |
// /** |
|
92 |
// * <p>getFeatures</p> |
|
93 |
// * |
|
94 |
// * @return a {@link java.util.List} object. |
|
95 |
// */ |
|
96 |
// public static List<Feature> getFeatures() { |
|
97 |
// List<Feature> features = getTerms(Feature.class); |
|
98 |
// features.remove(Feature.IMAGE()); |
|
99 |
// return features; |
|
100 |
// |
|
101 |
// } |
|
102 |
// |
|
103 |
// |
|
104 |
// /** |
|
105 |
// * <p>getNonTechnicalMarkerTypes</p> |
|
106 |
// * |
|
107 |
// * @return a {@link java.util.List} object. |
|
108 |
// */ |
|
109 |
// public static List<MarkerType> getNonTechnicalMarkerTypes() { |
|
110 |
// List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>(); |
|
111 |
// List<MarkerType> markerTypes = getTerms(MarkerType.class); |
|
112 |
// |
|
113 |
// for (Object type : markerTypes) { |
|
114 |
// if (((MarkerType) type).isTechnical() == false) { |
|
115 |
// nonTechnicalMarkerTypes.add((MarkerType) type); |
|
116 |
// } |
|
117 |
// } |
|
118 |
// |
|
119 |
// return nonTechnicalMarkerTypes; |
|
120 |
// } |
|
121 |
// |
|
122 |
// /** |
|
123 |
// * Retrieve all ranks from data store. |
|
124 |
// * |
|
125 |
// * @return a {@link java.util.List} object. |
|
126 |
// */ |
|
127 |
// public static List<Rank> getRanks(){ |
|
128 |
// if(PreferencesUtil.getSortRanksHierarchichally()){ |
|
129 |
// return getTerms(Rank.class, new Comparator<Rank>(){ |
|
130 |
// |
|
131 |
// @Override |
|
132 |
// public int compare(Rank o1, Rank o2) { |
|
133 |
// return o1.compareTo(o2); |
|
134 |
// } |
|
135 |
// |
|
136 |
// }); |
|
137 |
// }else{ |
|
138 |
// return getTerms(Rank.class); |
|
139 |
// } |
|
140 |
// } |
|
141 |
// |
|
142 |
// |
|
143 |
// /** |
|
144 |
// * Retrieve all presence and absence terms from data store. |
|
145 |
// * |
|
146 |
// * @return a {@link java.util.List} object. |
|
147 |
// */ |
|
148 |
// public static List<PresenceAbsenceTermBase> getPresenceAbsenceTerms() { |
|
149 |
// List presenceAbsenceTerms = getTerms(PresenceTerm.class); |
|
150 |
// presenceAbsenceTerms.addAll(getTerms(AbsenceTerm.class)); |
|
151 |
// |
|
152 |
// return presenceAbsenceTerms; |
|
153 |
// } |
|
209 | 154 |
|
210 | 155 |
/** |
211 |
* Retrieve all presence and absence terms from data store. |
|
212 |
* |
|
213 |
* @return a {@link java.util.List} object. |
|
214 |
*/ |
|
215 |
public static List<PresenceAbsenceTermBase> getPresenceAbsenceTerms() { |
|
216 |
List presenceAbsenceTerms = getTerms(PresenceTerm.class); |
|
217 |
presenceAbsenceTerms.addAll(getTerms(AbsenceTerm.class)); |
|
218 |
|
|
219 |
return presenceAbsenceTerms; |
|
220 |
} |
|
221 |
|
|
222 |
/** |
|
223 |
* Retrieve all stages from data store. |
|
224 |
* |
|
225 |
* @return a {@link java.util.List} object. |
|
226 |
*/ |
|
227 |
public static List<Stage> getStages(){ |
|
228 |
return getTerms(Stage.class); |
|
229 |
} |
|
230 |
|
|
231 |
/** |
|
232 |
* Retrieve all states from data store. |
|
233 |
* |
|
234 |
* @return a {@link java.util.List} object. |
|
235 |
*/ |
|
236 |
public static List<State> getStates() { |
|
237 |
return getTerms(State.class); |
|
238 |
} |
|
239 |
|
|
240 |
/** |
|
241 |
* Retrieve all preservation methods from data store. |
|
242 |
* |
|
243 |
* @return a {@link java.util.List} object. |
|
244 |
*/ |
|
245 |
public static List<PreservationMethod> getPreservationMethods(){ |
|
246 |
return getTerms(PreservationMethod.class); |
|
247 |
} |
|
248 |
|
|
249 |
|
|
250 |
|
|
251 |
/** |
|
252 |
* <p>getMeasurementUnits</p> |
|
253 |
* |
|
254 |
* @return a {@link java.util.List} object. |
|
255 |
*/ |
|
256 |
public static List<MeasurementUnit> getMeasurementUnits() { |
|
257 |
return getTerms(MeasurementUnit.class); |
|
258 |
} |
|
259 |
|
|
260 |
|
|
261 |
/** |
|
262 |
* <p>getModifiers</p> |
|
263 |
* |
|
264 |
* @return a {@link java.util.List} object. |
|
265 |
*/ |
|
266 |
public static List<Modifier> getModifiers() { |
|
267 |
return getTerms(Modifier.class); |
|
268 |
} |
|
269 |
|
|
270 |
|
|
271 |
/** |
|
272 |
* <p>getStatisticalMeasures</p> |
|
273 |
* |
|
274 |
* @return a {@link java.util.List} object. |
|
275 |
*/ |
|
276 |
public static List<StatisticalMeasure> getStatisticalMeasures() { |
|
277 |
return getTerms(StatisticalMeasure.class); |
|
278 |
} |
|
279 |
|
|
280 |
/** |
|
281 |
* <p>getScopes</p> |
|
282 |
* |
|
283 |
* @return a {@link java.util.List} object. |
|
284 |
*/ |
|
285 |
public static List<Scope> getScopes() { |
|
286 |
return getTerms(Scope.class); |
|
287 |
} |
|
288 |
|
|
289 |
/** |
|
290 |
* <p>getDeterminationModifiers</p> |
|
291 |
* |
|
292 |
* @return a {@link java.util.List} object. |
|
293 |
*/ |
|
294 |
public static List<DeterminationModifier> getDeterminationModifiers() { |
|
295 |
return getTerms(DeterminationModifier.class); |
|
296 |
} |
|
297 |
|
|
298 |
/** |
|
299 |
* <p>getReferenceSystems</p> |
|
300 |
* |
|
301 |
* @return a {@link java.util.List} object. |
|
302 |
*/ |
|
303 |
public static List<ReferenceSystem> getReferenceSystems() { |
|
304 |
return getTerms(ReferenceSystem.class); |
|
305 |
} |
|
306 |
|
|
307 |
/** |
|
308 |
************* save methods ***************************** |
|
309 |
* |
|
310 | 156 |
* @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object. |
311 | 157 |
*/ |
312 | 158 |
public static void saveTerm(DefinedTermBase term){ |
313 |
getTermService().saveOrUpdate(term);
|
|
159 |
CdmStore.getService(ITermService.class).saveOrUpdate(term);
|
|
314 | 160 |
} |
315 | 161 |
|
316 | 162 |
/** |
... | ... | |
319 | 165 |
* @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object. |
320 | 166 |
*/ |
321 | 167 |
public static void delete(DefinedTermBase selected) { |
322 |
getTermService().delete(selected);
|
|
168 |
CdmStore.getService(ITermService.class).delete(selected);
|
|
323 | 169 |
} |
324 | 170 |
|
325 | 171 |
/** |
... | ... | |
328 | 174 |
* @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object. |
329 | 175 |
*/ |
330 | 176 |
public static void updateVocabulary(DefinedTermBase term) { |
331 |
getTermService().saveOrUpdate(term);
|
|
177 |
CdmStore.getService(ITermService.class).saveOrUpdate(term);
|
|
332 | 178 |
} |
333 | 179 |
|
180 |
private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>(); |
|
334 | 181 |
|
335 |
|
|
336 |
/*************** internal methods **************************/ |
|
337 |
|
|
338 |
private static Language getDefaultLanguage(){ |
|
339 |
return CdmStore.getDefaultLanguage(); |
|
340 |
} |
|
341 |
|
|
342 |
private static OrderedTermVocabulary<? extends OrderedTermBase> getOrderedTermVocabulary(VocabularyEnum vocabularyType){ |
|
343 |
TermVocabulary<DefinedTermBase> vocabulary = getTermVocabulary(vocabularyType); |
|
344 |
return HibernateProxyHelper.deproxy(vocabulary, OrderedTermVocabulary.class); |
|
182 |
static { |
|
183 |
termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() { |
|
184 |
|
|
185 |
@Override |
|
186 |
public Class<Feature> getTermClass() { |
|
187 |
return Feature.class; |
|
188 |
} |
|
189 |
|
|
190 |
@Override |
|
191 |
public List<Feature> getTerms() { |
|
192 |
List<Feature> features = TermStore.getTermsFromService(Feature.class, null); |
|
193 |
features.remove(Feature.IMAGE()); |
|
194 |
return features; |
|
195 |
} |
|
196 |
}); |
|
197 |
termStoreEdgeCases.add(new ITermStoreEdgeCase<MarkerType>(){ |
|
198 |
|
|
199 |
@Override |
|
200 |
public Class<MarkerType> getTermClass() { |
|
201 |
return MarkerType.class; |
|
202 |
} |
|
203 |
|
|
204 |
@Override |
|
205 |
public List<MarkerType> getTerms() { |
|
206 |
// filter out non technical markers |
|
207 |
List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>(); |
|
208 |
List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null); |
|
209 |
|
|
210 |
for (Object type : markerTypes) { |
|
211 |
if (((MarkerType) type).isTechnical() == false) { |
|
212 |
nonTechnicalMarkerTypes.add((MarkerType) type); |
|
213 |
} |
|
214 |
} |
|
215 |
|
|
216 |
return nonTechnicalMarkerTypes; |
|
217 |
} |
|
218 |
|
|
219 |
}); |
|
220 |
termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() { |
|
221 |
|
|
222 |
@Override |
|
223 |
public Class<Rank> getTermClass() { |
|
224 |
return Rank.class; |
|
225 |
} |
|
226 |
|
|
227 |
@Override |
|
228 |
public List<Rank> getTerms() { |
|
229 |
if(PreferencesUtil.getSortRanksHierarchichally()){ |
|
230 |
return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){ |
|
231 |
|
|
232 |
@Override |
|
233 |
public int compare(Rank o1, Rank o2) { |
|
234 |
return o1.compareTo(o2); |
|
235 |
} |
|
236 |
|
|
237 |
}); |
|
238 |
}else{ |
|
239 |
return TermStore.getTermsFromService(Rank.class, null); |
|
240 |
} |
|
241 |
} |
|
242 |
|
|
243 |
}); |
|
244 |
termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTermBase>() { |
|
245 |
|
|
246 |
@Override |
|
247 |
public Class<PresenceAbsenceTermBase> getTermClass() { |
|
248 |
return PresenceAbsenceTermBase.class; |
|
249 |
} |
|
250 |
|
|
251 |
@Override |
|
252 |
public List<PresenceAbsenceTermBase> getTerms() { |
|
253 |
List presenceAbsenceTerms = TermStore.getTermsFromService(PresenceTerm.class, null); |
|
254 |
presenceAbsenceTerms.addAll(TermStore.getTermsFromService(AbsenceTerm.class, null)); |
|
255 |
|
|
256 |
return presenceAbsenceTerms; |
|
257 |
} |
|
258 |
}); |
|
259 |
termStoreEdgeCases.add(new ITermStoreEdgeCase<TaxonRelationshipTypeInverseContainer>() { |
|
260 |
|
|
261 |
@Override |
|
262 |
public Class<TaxonRelationshipTypeInverseContainer> getTermClass() { |
|
263 |
return TaxonRelationshipTypeInverseContainer.class; |
|
264 |
} |
|
265 |
|
|
266 |
@Override |
|
267 |
public List<TaxonRelationshipTypeInverseContainer> getTerms() { |
|
268 |
List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{ |
|
269 |
TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), |
|
270 |
TaxonRelationshipType.MISAPPLIED_NAME_FOR(), |
|
271 |
TaxonRelationshipType.ALL_RELATIONSHIPS() |
|
272 |
}); |
|
273 |
|
|
274 |
List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>(); |
|
275 |
|
|
276 |
List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class); |
|
277 |
|
|
278 |
relationshipTypes.removeAll(excludeTaxonRelationshipTypes); |
|
279 |
|
|
280 |
for (TaxonRelationshipType relationshipType : relationshipTypes){ |
|
281 |
if(!relationshipType.isSymmetric()){ |
|
282 |
TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true); |
|
283 |
relationshipTypeInverseContainers.add(inverseContainer); |
|
284 |
} |
|
285 |
TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false); |
|
286 |
relationshipTypeInverseContainers.add(container); |
|
287 |
} |
|
288 |
|
|
289 |
return relationshipTypeInverseContainers; |
|
290 |
} |
|
291 |
}); |
|
345 | 292 |
} |
346 | 293 |
|
347 |
/** |
|
348 |
* <p>getTermVocabulary</p> |
|
349 |
* |
|
350 |
* @param vocabularyType a {@link eu.etaxonomy.cdm.model.common.VocabularyEnum} object. |
|
351 |
* @return a {@link eu.etaxonomy.cdm.model.common.TermVocabulary} object. |
|
352 |
*/ |
|
353 |
public static TermVocabulary<DefinedTermBase> getTermVocabulary(VocabularyEnum vocabularyType){ |
|
294 |
private static <T extends DefinedTermBase> ITermStoreEdgeCase<T> getEdgeCase(Class<T> termClass) { |
|
354 | 295 |
|
355 |
return CdmStore.getService(IVocabularyService.class).getVocabulary(vocabularyType); |
|
356 |
} |
|
357 |
|
|
358 |
private static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){ |
|
359 |
Comparator<TERM> comparator = new Comparator<TERM>() { |
|
360 |
@Override |
|
361 |
public int compare(TERM o1, TERM o2) { |
|
362 |
String label1 = o1.getLabel(getDefaultLanguage()) != null ? o1.getLabel(getDefaultLanguage()) : o1.getTitleCache(); |
|
363 |
String label2 = o2.getLabel(getDefaultLanguage()) != null ? o2.getLabel(getDefaultLanguage()) : o2.getTitleCache(); |
|
364 |
return label1.compareTo(label2); |
|
296 |
for (ITermStoreEdgeCase termStoreEdgeCase : termStoreEdgeCases){ |
|
297 |
if (termStoreEdgeCase.getTermClass().equals(termClass)){ |
|
298 |
return termStoreEdgeCase; |
|
365 | 299 |
} |
366 |
};
|
|
300 |
} |
|
367 | 301 |
|
368 |
return getTerms(clazz, comparator);
|
|
302 |
return null;
|
|
369 | 303 |
} |
370 | 304 |
|
371 |
|
|
372 |
private static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator){ |
|
305 |
private interface ITermStoreEdgeCase<TERM> { |
|
373 | 306 |
|
307 |
public abstract Class<TERM> getTermClass(); |
|
374 | 308 |
|
375 |
List<TERM> terms = new ArrayList<TERM>(); |
|
376 |
if(getTermService() != null){ |
|
377 |
terms = getTermService().listByTermClass(clazz, null, null, null, null); |
|
309 |
public abstract List<TERM> getTerms(); |
|
378 | 310 |
|
379 |
Collections.sort(terms, comparator); |
|
380 |
} |
|
381 |
|
|
382 |
return terms; |
|
383 |
|
|
384 |
} |
|
385 |
|
|
386 |
private static ITermService getTermService(){ |
|
387 |
return CdmStore.getService(ITermService.class); |
|
388 | 311 |
} |
389 | 312 |
} |
Also available in: Unified diff
Committing changes to definedtermeditor after merge from branch