Revision f4888ff9
Added by Patrick Plitzner over 6 years ago
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java | ||
---|---|---|
11 | 11 |
|
12 | 12 |
import java.util.ArrayList; |
13 | 13 |
import java.util.Collection; |
14 |
import java.util.HashMap; |
|
15 | 14 |
import java.util.List; |
16 |
import java.util.Map; |
|
17 | 15 |
import java.util.UUID; |
18 | 16 |
|
19 |
import org.eclipse.core.runtime.IProgressMonitor; |
|
20 |
import org.eclipse.ui.IMemento; |
|
21 |
|
|
22 | 17 |
import eu.etaxonomy.cdm.model.common.DefinedTermBase; |
23 | 18 |
import eu.etaxonomy.cdm.model.common.TermBase; |
24 | 19 |
import eu.etaxonomy.cdm.model.common.TermType; |
25 | 20 |
import eu.etaxonomy.cdm.model.common.TermVocabulary; |
26 |
import eu.etaxonomy.taxeditor.model.ContextListenerAdapter; |
|
27 | 21 |
import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer; |
22 |
import eu.etaxonomy.taxeditor.preference.PreferencesUtil; |
|
28 | 23 |
|
29 | 24 |
/** |
30 | 25 |
* @author n.hoffmann |
31 | 26 |
* @created Dec 7, 2010 |
32 | 27 |
* @version 1.0 |
33 | 28 |
*/ |
34 |
public class TermManager extends ContextListenerAdapter{
|
|
29 |
public class TermManager { |
|
35 | 30 |
|
36 | 31 |
private static final String TERMS = "terms"; |
37 | 32 |
private static final String TERM = "term"; |
... | ... | |
40 | 35 |
private static final String CLASS = "class"; |
41 | 36 |
private static final String UUID_STRING = "uuid"; |
42 | 37 |
|
43 |
private final Map<String, Collection<UUID>> hiddenTermsMap = new HashMap<String, Collection<UUID>>(); |
|
44 |
|
|
45 | 38 |
public TermManager(){ |
46 |
CdmStore.getContextManager().addContextListener(this); |
|
47 | 39 |
} |
48 | 40 |
|
49 | 41 |
/** |
... | ... | |
73 | 65 |
return getFilteredTerms(TermStore.getTerms(clazz)); |
74 | 66 |
} |
75 | 67 |
|
76 |
@Override |
|
77 |
public void contextStart(IMemento memento, IProgressMonitor monitor) { |
|
78 |
// read preferred terms from memento into an in memory representation |
|
79 |
if(memento == null){ |
|
80 |
return; |
|
81 |
} |
|
82 |
|
|
83 |
IMemento terms = memento.getChild(TERMS); |
|
84 |
|
|
85 |
if(terms == null){ |
|
86 |
return; |
|
87 |
} |
|
88 |
|
|
89 |
for(IMemento term : terms.getChildren(TERM)){ |
|
90 |
String typeName = term.getString(CLASS); |
|
91 |
Collection<UUID> hiddenTermUuids = new ArrayList<UUID>(); |
|
92 |
for(IMemento hide : term.getChildren(HIDE)){ |
|
93 |
String uuidString = hide.getString(UUID_STRING); |
|
94 |
UUID uuid = UUID.fromString(uuidString); |
|
95 |
hiddenTermUuids.add(uuid); |
|
96 |
} |
|
97 |
hiddenTermsMap.put(typeName, hiddenTermUuids); |
|
98 |
} |
|
99 |
} |
|
100 |
|
|
101 |
@Override |
|
102 |
public void contextStop(IMemento memento, IProgressMonitor monitor) { |
|
103 |
saveTerms(memento, monitor); |
|
104 |
} |
|
105 |
|
|
106 |
@Override |
|
107 |
public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) { |
|
108 |
saveTerms(memento, monitor); |
|
109 |
} |
|
110 |
|
|
111 |
private void saveTerms(IMemento memento, IProgressMonitor monitor){ |
|
112 |
if(memento == null) { |
|
113 |
return; |
|
114 |
} |
|
115 |
|
|
116 |
IMemento terms = memento.createChild(TERMS); |
|
117 |
for (String preferredTerm : hiddenTermsMap.keySet()){ |
|
118 |
IMemento term = terms.createChild(TERM); |
|
119 |
term.putString(CLASS, preferredTerm); |
|
120 |
for(UUID uuid : hiddenTermsMap.get(preferredTerm)){ |
|
121 |
IMemento hide = term.createChild(HIDE); |
|
122 |
hide.putString(UUID_STRING, uuid.toString()); |
|
123 |
} |
|
124 |
} |
|
125 |
} |
|
126 |
|
|
127 | 68 |
/** |
128 | 69 |
* Generic method to get term preferences for a term vocabulary |
129 | 70 |
* |
... | ... | |
134 | 75 |
|
135 | 76 |
List<T> filteredTerms = new ArrayList<T>(); |
136 | 77 |
|
137 |
String typeName = getTermClass(initialTerms); |
|
138 |
Collection<UUID> hiddenTermUuids = hiddenTermsMap.get(typeName); |
|
139 |
|
|
140 |
|
|
141 |
if(hiddenTermUuids == null){ |
|
142 |
return initialTerms; |
|
143 |
} |
|
144 |
|
|
145 | 78 |
for (T term : initialTerms){ |
79 |
|
|
146 | 80 |
if (term instanceof TaxonRelationshipTypeInverseContainer){ |
147 |
if(! hiddenTermUuids.contains(((TaxonRelationshipTypeInverseContainer) term).getType().getUuid())){
|
|
81 |
if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
|
|
148 | 82 |
T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType(); |
149 | 83 |
filteredTerms.add(type); |
150 | 84 |
|
151 | 85 |
} |
152 | 86 |
} |
153 |
if(! hiddenTermUuids.contains(term.getUuid())){
|
|
87 |
if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
|
|
154 | 88 |
filteredTerms.add(term); |
155 | 89 |
} |
156 | 90 |
} |
... | ... | |
158 | 92 |
return filteredTerms; |
159 | 93 |
} |
160 | 94 |
|
95 |
private <T extends TermBase> String getPrefName(T term) { |
|
96 |
return term.getTermType().toString()+term.getUuid().toString(); |
|
97 |
} |
|
98 |
|
|
161 | 99 |
private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){ |
162 | 100 |
|
163 | 101 |
String result = null; |
... | ... | |
175 | 113 |
return null; |
176 | 114 |
} |
177 | 115 |
|
178 |
// /** |
|
179 |
// * <p>getPreferredSpecimenTypeDesignationStatus</p> |
|
180 |
// * |
|
181 |
// * @return a {@link java.util.List} object. |
|
182 |
// */ |
|
183 |
// public List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getFilteredTerms(TermStore.getSpecimenTypeDesignationStatus());} |
|
184 |
// |
|
185 |
// /** |
|
186 |
// * <p>getPreferredNameTypeDesignationStatus</p> |
|
187 |
// * |
|
188 |
// * @return a {@link java.util.List} object. |
|
189 |
// */ |
|
190 |
// public List<NameTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getFilteredTerms(TermStore.getNameTypeDesignationStatus()); } |
|
191 |
// |
|
192 |
// /** |
|
193 |
// * <p>getPreferredTaxonRelationshipTypes</p> |
|
194 |
// * |
|
195 |
// * @return a {@link java.util.List} object. |
|
196 |
// */ |
|
197 |
// public List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getFilteredTerms(TermStore.getTaxonRelationshipTypes());} |
|
198 |
// |
|
199 |
// private static List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{ |
|
200 |
// TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), |
|
201 |
// TaxonRelationshipType.MISAPPLIED_NAME_FOR(), |
|
202 |
// TaxonRelationshipType.ALL_RELATIONSHIPS() |
|
203 |
// }); |
|
204 |
// |
|
205 |
// /** |
|
206 |
// * Please note that the {@link TaxonRelationshipType}s TAXONOMICALLY_INCLUDED_IN, MISAPPLIED_NAME_FOR and ALL_RELATIONSHIPS |
|
207 |
// * are filtered out as they are most likely not needed. If you do need them please refactor this method to your needs. |
|
208 |
// * |
|
209 |
// * @return a list of {@link TaxonRelationshipTypeInverseContainer} elements |
|
210 |
// */ |
|
211 |
// public List<TaxonRelationshipTypeInverseContainer> getPreferredRelationshipTypesWithInverses(){ |
|
212 |
// List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>(); |
|
213 |
// |
|
214 |
// List<TaxonRelationshipType> relationshipTypes = getPreferredTaxonRelationshipTypes(); |
|
215 |
// |
|
216 |
// relationshipTypes.removeAll(excludeTaxonRelationshipTypes); |
|
217 |
// |
|
218 |
// for (TaxonRelationshipType relationshipType : relationshipTypes){ |
|
219 |
// if(!relationshipType.isSymmetric()){ |
|
220 |
// TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true); |
|
221 |
// relationshipTypeInverseContainers.add(inverseContainer); |
|
222 |
// } |
|
223 |
// TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false); |
|
224 |
// relationshipTypeInverseContainers.add(container); |
|
225 |
// } |
|
226 |
// |
|
227 |
// return relationshipTypeInverseContainers; |
|
228 |
// } |
|
229 |
|
|
230 |
|
|
231 |
|
|
232 |
|
|
233 |
// |
|
234 |
// /** |
|
235 |
// * <p>getPreferredFeatures</p> |
|
236 |
// * |
|
237 |
// * @return a {@link java.util.List} object. |
|
238 |
// */ |
|
239 |
// public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());} |
|
240 |
// |
|
241 |
// /** |
|
242 |
// * <p>getPreferredRanks</p> |
|
243 |
// * |
|
244 |
// * @return a {@link java.util.List} object. |
|
245 |
// */ |
|
246 |
// public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());} |
|
247 |
// |
|
248 |
// /** |
|
249 |
// * <p>getPreferredPresenceAbsenceTerms</p> |
|
250 |
// * |
|
251 |
// * @return a {@link java.util.List} object. |
|
252 |
// */ |
|
253 |
// public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());} |
|
254 |
// |
|
255 |
// /** |
|
256 |
// * <p>getPreferredNomenclaturalStatusTypes</p> |
|
257 |
// * |
|
258 |
// * @return a {@link java.util.List} object. |
|
259 |
// */ |
|
260 |
// public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){ return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());} |
|
261 |
// |
|
262 |
// /** |
|
263 |
// * <p>getPreferredNameRelationshipTypes</p> |
|
264 |
// * |
|
265 |
// * @return a {@link java.util.List} object. |
|
266 |
// */ |
|
267 |
// public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());} |
|
268 |
// |
|
269 |
// /** |
|
270 |
// * <p>getPreferredLanguages</p> |
|
271 |
// * |
|
272 |
// * @return a {@link java.util.List} object. |
|
273 |
// */ |
|
274 |
// public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); } |
|
275 |
// |
|
276 |
// /** |
|
277 |
// * <p>getPreferredMarkerTypes</p> |
|
278 |
// * |
|
279 |
// * @return a {@link java.util.List} object. |
|
280 |
// */ |
|
281 |
// public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); } |
|
282 |
// |
|
283 |
// /** |
|
284 |
// * <p>getPreferredExtensionTypes</p> |
|
285 |
// * |
|
286 |
// * @return a {@link java.util.List} object. |
|
287 |
// */ |
|
288 |
// public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); } |
|
289 |
// |
|
290 |
// /** |
|
291 |
// * <p>getPreferredRightsTypes</p> |
|
292 |
// * |
|
293 |
// * @return a {@link java.util.List} object. |
|
294 |
// */ |
|
295 |
// public List<RightsType> getPreferredRightsTypes() { return getFilteredTerms(TermStore.getRightsTypes());} |
|
296 |
// |
|
297 |
// /** |
|
298 |
// * <p>getPreferredNamedAreaTypes</p> |
|
299 |
// * |
|
300 |
// * @return a {@link java.util.List} object. |
|
301 |
// */ |
|
302 |
// public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); } |
|
303 |
// |
|
304 |
// /** |
|
305 |
// * <p>getPreferredNamedAreaTypes</p> |
|
306 |
// * |
|
307 |
// * @return a {@link java.util.List} object. |
|
308 |
// */ |
|
309 |
// public List<NamedAreaLevel> getPreferredNamedAreaLevels() { return getFilteredTerms(TermStore.getNamedAreaLevels()); } |
|
310 |
// |
|
311 |
// /** |
|
312 |
// * <p>getPreferredAnnotationTypes</p> |
|
313 |
// * |
|
314 |
// * @return a {@link java.util.List} object. |
|
315 |
// */ |
|
316 |
// public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); } |
|
317 |
// |
|
318 |
// /** |
|
319 |
// * <p>getPreferredStages</p> |
|
320 |
// * |
|
321 |
// * @return a {@link java.util.List} object. |
|
322 |
// */ |
|
323 |
// public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); } |
|
324 |
// |
|
325 |
// /** |
|
326 |
// * <p>getPreferredPreservationMethods</p> |
|
327 |
// * |
|
328 |
// * @return a {@link java.util.List} object. |
|
329 |
// */ |
|
330 |
// public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); } |
|
331 |
// |
|
332 |
// /** |
|
333 |
// * <p>getPreferredMeasurementUnits</p> |
|
334 |
// * |
|
335 |
// * @return a {@link java.util.List} object. |
|
336 |
// */ |
|
337 |
// public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); } |
|
338 |
// |
|
339 |
// /** |
|
340 |
// * <p>getPreferredStates</p> |
|
341 |
// * |
|
342 |
// * @return a {@link java.util.List} object. |
|
343 |
// */ |
|
344 |
// public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); } |
|
345 |
// |
|
346 |
// /** |
|
347 |
// * <p>getPreferredModifiers</p> |
|
348 |
// * |
|
349 |
// * @return a {@link java.util.List} object. |
|
350 |
// */ |
|
351 |
// public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); } |
|
352 |
// |
|
353 |
// /** |
|
354 |
// * <p>getPreferredStatisticalMeasures</p> |
|
355 |
// * |
|
356 |
// * @return a {@link java.util.List} object. |
|
357 |
// */ |
|
358 |
// public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); } |
|
359 |
// |
|
360 |
// /** |
|
361 |
// * <p>getPreferredScopes</p> |
|
362 |
// * |
|
363 |
// * @return a {@link java.util.List} object. |
|
364 |
// */ |
|
365 |
// public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); } |
|
366 |
// |
|
367 |
// /** |
|
368 |
// * <p>getPreferredDeterminationModifiers</p> |
|
369 |
// * |
|
370 |
// * @return a {@link java.util.List} object. |
|
371 |
// */ |
|
372 |
// public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); } |
|
373 |
// |
|
374 | 116 |
/** |
375 | 117 |
* Generic method to set term preferences |
376 | 118 |
* |
... | ... | |
386 | 128 |
for(TermBase term : initialTerms){ |
387 | 129 |
if(! preferredTerms.contains(term)){ |
388 | 130 |
undesiredTermUuids.add(term.getUuid()); |
131 |
PreferencesUtil.getPreferenceStore().setValue(getPrefName(term), true); |
|
389 | 132 |
} |
390 | 133 |
} |
391 |
|
|
392 |
hiddenTermsMap.put(typeName, undesiredTermUuids); |
|
393 | 134 |
} |
394 | 135 |
} |
Also available in: Unified diff
ref #7007 Migrate TermManager memento to preference store